As traduções são geradas por tradução automática. Em caso de conflito entre o conteúdo da tradução e da versão original em inglês, a versão em inglês prevalecerá.

# Aplique a peneiração SageMaker inteligente ao seu script PyTorch
<a name="train-smart-sifting-apply-to-pytorch-script"></a>

Essas instruções demonstram como habilitar a peneiração SageMaker inteligente com seu script de treinamento.

1. 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. 
   + Especifique a proporção de dados que devem ser usados para treinamento em relação ao parâmetro `beta_value`.
   + Especifique o número de amostras usadas na comparação com o parâmetro `loss_history_length`.

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

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

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

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

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

   1. 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 chamada`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])
   ```

   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.

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 [https://pytorch.org/docs/stable/data.html#torch.utils.data.DataLoader](https://pytorch.org/docs/stable/data.html#torch.utils.data.DataLoader). Ao empacotar PyTorch`DataLoader`, 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
   )
   ```