Aplique a peneiração SageMaker inteligente ao seu script PyTorch

Configure a interface de peneiramento SageMaker inteligente.

A biblioteca de peneiramento SageMaker inteligente implementa uma técnica de amostragem baseada em perda de limite relativo que ajuda a filtrar amostras com menor impacto na redução do valor da perda. O algoritmo de peneiramento SageMaker inteligente calcula o valor de perda de cada amostra de dados de entrada usando uma passagem direta e calcula seu percentil relativo em relação aos valores de perda dos dados anteriores.

Os dois parâmetros a seguir são o que você precisa especificar para a classe RelativeProbabilisticSiftConfig para criar um objeto de configuração de filtragem.

O exemplo de código a seguir demonstra a configuração de um objeto da 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)
    )
)

Para obter mais informações sobre o loss_based_sift_config parâmetro e as classes relacionadas, consulte a seção SageMaker módulos de configuração de peneiramento inteligente de referência do SageMaker SDK Python do smart sifting.

O objeto sift_config no exemplo de código anterior é usado na etapa 4 para configurar a classe SiftingDataloader.

(Opcional) Configure uma classe de transformação em lote de peneiramento SageMaker inteligente.

Casos de uso de treinamento diferentes exigem formatos de dados de treinamento diferentes. Dada a variedade de formatos de dados, o algoritmo de peneiramento SageMaker inteligente precisa identificar como realizar a peneiração em um determinado lote. Para resolver isso, a peneiração SageMaker inteligente fornece um módulo de transformação em lote que ajuda a converter lotes em formatos padronizados que podem ser filtrados com eficiência.

1. SageMaker A peneiração inteligente manipula a transformação em lote de dados de treinamento nos seguintes formatos: listas, dicionários, tuplas e tensores do Python. Para esses formatos de dados, a peneiração SageMaker inteligente processa automaticamente a conversão do formato de dados em lote, e você pode pular o restante desta etapa. Se você pular essa etapa, na etapa 4 de configuração do SiftingDataloader, deixe o parâmetro batch_transforms de SiftingDataloader com seu valor padrão, que é None.

2. Se seu conjunto de dados não estiver nesses formatos, você deverá prosseguir com o restante desta etapa para criar uma transformação em lote personalizada usando SiftingBatchTransform.

   Nos casos em que seu conjunto de dados não está em um dos formatos compatíveis com a peneiração SageMaker inteligente, você pode se deparar com erros. Esses erros de formato de dados podem ser resolvidos adicionando o parâmetro batch_format_index ou batch_transforms à classe SiftingDataloader, que você configurou na etapa 4. A seguir, são mostrados exemplos de erros devido a um formato de dados e resoluções incompatíveis para eles.

   Mensagem de erro	Resolução
   Por padrão, não {type(batch)} há suporte para lotes desse tipo.	Esse erro indica que o formato de lote não é compatível por padrão. Você deve implementar uma classe de transformação em lote personalizada e usá-la especificando-a no parâmetro batch_transforms da classe SiftingDataloader.
   Não é possível indexar o lote do tipo {type(batch)}	Esse erro indica que o objeto em lote não pode ser indexado normalmente. O usuário deve implementar uma transformação em lote personalizada e transmiti-la usando o parâmetro batch_transforms.
   {batch_size}O tamanho do lote não corresponde aos tamanhos da dimensão 0 ou da dimensão 1	Esse erro ocorre quando o tamanho do lote fornecido não corresponde à 0ª ou 1ª dimensão do lote. O usuário deve implementar uma transformação em lote personalizada e transmiti-la usando o parâmetro batch_transforms.
   Tanto a dimensão 0 quanto a dimensão 1 correspondem ao tamanho do lote	Esse erro indica que, como várias dimensões correspondem ao tamanho do lote fornecido, são necessárias mais informações para filtrar o lote. O usuário pode fornecer o parâmetro batch_format_index para indicar se o lote é indexável por amostra ou atributo. Os usuários também podem implementar uma transformação em lote personalizada, mas isso é mais trabalhoso do que o necessário.

   Para resolver os problemas mencionados acima, você precisa criar uma classe de transformação em lote personalizada usando o módulo SiftingBatchTransform. Uma classe de transformação em lote deve consistir em um par de funções de transformação e transformação reversa. O par de funções converte seu formato de dados em um formato que o algoritmo de peneiramento SageMaker inteligente possa processar. Depois de criar uma classe de transformação em lote, a classe retorna um objeto SiftingBatch que você passará para a classe SiftingDataloader na etapa 4.

   Veja a seguir exemplos de classes personalizadas de transformação em lote do módulo SiftingBatchTransform.

   • Um exemplo de implementação personalizada de transformação em lote de listas com peneiramento SageMaker inteligente para casos em que o bloco do carregador de dados tem entradas, máscaras e rótulos.

     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

   • Um exemplo de implementação personalizada de transformação em lote de listas com peneiramento SageMaker inteligente para casos em que não são necessários rótulos para a transformação reversa.

     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

   • Um exemplo de implementação personalizada em lote de tensores com peneiramento SageMaker inteligente para casos em que o fragmento do carregador de dados tem entradas, máscaras e rótulos.

     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

   Depois de criar uma classe de transformação em lote implementada com SiftingBatchTransform, use essa classe na etapa 4 para configurar a classe SiftingDataloader. O restante deste guia pressupõe que uma classe ListBatchTransform foi criada. Na etapa 4, essa classe é passada para o batch_transforms.

Crie uma classe para implementar a interface de peneiramento SageMaker Loss inteligente. Este tutorial pressupõe que a classe tenha um nome SiftingImplementedLoss. Ao configurar essa classe, recomendamos que você use a mesma função de perda no loop de treinamento de modelo. Siga as subetapas a seguir para criar uma classe implementada de peneiramento SageMaker Loss inteligente.

1. SageMaker a peneiração inteligente calcula um valor de perda para cada amostra de dados de treinamento, em vez de calcular um único valor de perda para um lote. Para garantir que a peneiração SageMaker inteligente use a mesma lógica de cálculo de perda, crie uma função de smart-sifting-implemented perda usando o Loss módulo de peneiração SageMaker inteligente que usa sua função de perda e calcula a perda por amostra de treinamento.

   dica

   SageMaker o algoritmo de peneiramento inteligente é executado em todas as amostras de dados, não no lote inteiro, portanto, você deve adicionar uma função de inicialização para definir a função de PyTorch perda sem nenhuma estratégia de redução.

   class SiftingImplementedLoss(Loss):  
       def __init__(self):
           self.loss = torch.nn.CrossEntropyLoss(reduction='none')

   Isso também é mostrado no exemplo de código a seguir.

2. Defina uma função de perda que aceite original_batch (ou transformed_batch se você tiver configurado uma transformação em lote na etapa 2) e o PyTorch modelo. Usando a função de perda especificada sem redução, a peneiração SageMaker inteligente executa uma passagem direta para cada amostra de dados para avaliar seu valor de perda.

O código a seguir é um exemplo de uma smart-sifting-implemented Loss interface chamadaSiftingImplementedLoss.

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

Antes que o ciclo de treinamento o avanço direto real, esse cálculo de perda por seleção é feito durante a fase de carregamento de dados de busca de um lote em cada iteração. O valor da perda individual é então comparado aos valores de perda anteriores e seu percentil relativo é estimado de acordo com o objeto RelativeProbabilisticSiftConfig que você configurou na etapa 1.

Envolva o carregador de PyTroch dados de acordo com a SiftingDataloader classe de SageMaker IA.

Por fim, use todas as classes implementadas de peneiramento SageMaker inteligente que você configurou nas etapas anteriores da classe de SiftingDataloder configuração de SageMaker IA. Esta classe é um invólucro para PyTorch DataLoader. Ao empacotar PyTorchDataLoader, a peneiração SageMaker inteligente é registrada para ser executada como parte do carregamento de dados em cada iteração de um trabalho de treinamento. PyTorch O exemplo de código a seguir demonstra a implementação da filtragem de dados de SageMaker IA em um. 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
)