Las traducciones son generadas a través de traducción automática. En caso de conflicto entre la traducción y la version original de inglés, prevalecerá la version en inglés.

# Aplica un tamizado SageMaker inteligente a tu script PyTorch
<a name="train-smart-sifting-apply-to-pytorch-script"></a>

Estas instrucciones muestran cómo habilitar el tamizado SageMaker inteligente con tu guion de entrenamiento.

1. Configure la interfaz de cribado SageMaker inteligente.

   La biblioteca de tamizado SageMaker inteligente implementa una técnica de muestreo basada en el umbral de pérdida relativa que ayuda a filtrar las muestras con un menor impacto en la reducción del valor de la pérdida. El algoritmo de tamizado SageMaker inteligente calcula el valor de pérdida de cada muestra de datos de entrada mediante una pasada directa y calcula su percentil relativo respecto a los valores de pérdida de los datos anteriores. 

   Los dos parámetros siguientes son los que debe especificar para la clase `RelativeProbabilisticSiftConfig` para crear un objeto de configuración de selección. 
   + Especifique la proporción de los datos que se deben utilizar para el entrenamiento con el parámetro `beta_value`.
   + Especifique el número de muestras utilizadas en la comparación con el parámetro `loss_history_length`.

   En el siguiente ejemplo de código, se muestra la configuración de un objeto de la clase `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 obtener más información sobre el `loss_based_sift_config` parámetro y las clases relacionadas, consulte [SageMaker módulos de configuración de tamizado inteligente](train-smart-sifting-pysdk-reference.md#train-smart-sifting-pysdk-base-config-modules) la sección de referencia del SDK de Python para filtrado SageMaker inteligente.

   El objeto `sift_config` del ejemplo de código anterior se utiliza en el paso 4 para configurar la clase `SiftingDataloader`.

1. (Opcional) Configure una clase de transformación por lotes de filtrado SageMaker inteligente.

   Los diferentes casos de uso de entrenamiento requieren diferentes formatos de datos de entrenamiento. Dada la variedad de formatos de datos, el algoritmo de tamizado SageMaker inteligente debe identificar cómo realizar el tamizado en un lote en particular. Para solucionar este problema, el tamizado SageMaker inteligente proporciona un módulo de transformación por lotes que ayuda a convertir los lotes en formatos estandarizados que se pueden tamizar de manera eficiente. 

   1. SageMaker El tamizado inteligente gestiona la transformación por lotes de los datos de entrenamiento en los siguientes formatos: listas de Python, diccionarios, tuplas y tensores. Para estos formatos de datos, el tamizado SageMaker inteligente gestiona automáticamente la conversión del formato de datos por lotes, y puedes saltarte el resto de este paso. Si omite este paso, en el paso 4 de la configuración de `SiftingDataloader`, deje el parámetro `batch_transforms` de `SiftingDataloader` en su valor predeterminado, que es `None`.

   1. Si el conjunto de datos no se encuentra en este formato, debe continuar con el resto de este paso para crear una transformación por lotes personalizada mediante `SiftingBatchTransform`. 

      En los casos en los que el conjunto de datos no esté en uno de los formatos compatibles con el SageMaker filtrado inteligente, es posible que se produzcan errores. Estos errores de formato de datos se pueden resolver agregando el parámetro `batch_format_index` o `batch_transforms` a la clase `SiftingDataloader`, que configuró en el paso 4. A continuación se muestran ejemplos de errores debidos a un formato de datos incompatible y sus resoluciones.    
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/sagemaker/latest/dg/train-smart-sifting-apply-to-pytorch-script.html)

      Para resolver los problemas antes mencionados, debe crear una clase de transformación por lotes personalizada mediante el módulo `SiftingBatchTransform`. Una clase de transformación por lotes debe constar de un par de funciones de transformación y transformación inversa. El par de funciones convierte el formato de datos a un formato que el algoritmo de filtrado SageMaker inteligente pueda procesar. Tras crear una clase de transformación por lotes, la clase devuelve un objeto `SiftingBatch` que pasará a la clase `SiftingDataloader` en el paso 4.

      Los siguientes son ejemplos de clases de transformación por lotes personalizadas del módulo `SiftingBatchTransform`.
      + Un ejemplo de implementación de transformación por lotes de listas personalizada con filtrado SageMaker inteligente para los casos en los que el fragmento del cargador de datos contiene entradas, máscaras y etiquetas.

        ```
        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 ejemplo de implementación de transformación por lotes de listas personalizada con filtrado SageMaker inteligente para los casos en los que no se necesitan etiquetas para la transformación 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 ejemplo de implementación por lotes de tensores personalizada con filtrado SageMaker inteligente para los casos en los que el fragmento del cargador de datos contiene entradas, máscaras y etiquetas.

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

      Tras crear una clase de transformación por lotes implementada `SiftingBatchTransform`, utilice esta clase en el paso 4 para configurar la clase `SiftingDataloader`. En el resto de esta guía se presupone que se ha creado una clase `ListBatchTransform`. En el paso 4, esta clase se pasa a `batch_transforms`.

1. Cree una clase para implementar la interfaz de filtrado SageMaker inteligente. `Loss` En este tutorial se presupone que la clase se llama `SiftingImplementedLoss`. Al configurar esta clase, le recomendamos que utilice la misma función de pérdida en el ciclo de entrenamiento del modelo. Siga los siguientes subpasos para crear una clase implementada para el tamizado SageMaker `Loss` inteligente.

   1. SageMaker El tamizado inteligente calcula un valor de pérdida para cada muestra de datos de entrenamiento, en lugar de calcular un valor de pérdida único para un lote. Para garantizar que el tamizado SageMaker inteligente utilice la misma lógica de cálculo de pérdidas, cree una función de smart-sifting-implemented pérdida mediante el `Loss` módulo de tamizado SageMaker inteligente que utilice su función de pérdida y calcule las pérdidas por muestra de entrenamiento. 
**sugerencia**  
SageMaker El algoritmo de tamizado inteligente se ejecuta en todas las muestras de datos, no en todo el lote, por lo que debe añadir una función de inicialización para configurar la función de PyTorch pérdida sin ninguna estrategia de reducción.  

      ```
      class SiftingImplementedLoss(Loss):  
          def __init__(self):
              self.loss = torch.nn.CrossEntropyLoss(reduction='none')
      ```
Esto se también se muestra en el siguiente ejemplo.

   1. Defina una función de pérdida que acepte el `original_batch` modelo (o `transformed_batch` si ha configurado una transformación por lotes en el paso 2) y el PyTorch modelo. Al utilizar la función de pérdida especificada sin reducción, el cribado SageMaker inteligente realiza una transferencia directa de cada muestra de datos para evaluar su valor de pérdida. 

   El código siguiente es un ejemplo de una smart-sifting-implemented `Loss` interfaz denominada`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 de que el ciclo de entrenamiento llegue a la pasada hacia adelante real, este cálculo de la pérdida de selección se realiza durante la fase de carga de datos, en la que se recupera un lote en cada iteración. A continuación, el valor de pérdida individual se compara con los valores de pérdida anteriores y su percentil relativo se estima según el objeto de `RelativeProbabilisticSiftConfig` que haya configurado en el paso 1.

1. Envuelva el cargador de PyTroch datos según la `SiftingDataloader` clase SageMaker AI.

   Por último, utilice todas las clases implementadas de filtrado SageMaker inteligente que configuró en los pasos anteriores para la clase de `SiftingDataloder` configuración de SageMaker IA. Esta clase es un contenedor para. PyTorch [https://pytorch.org/docs/stable/data.html#torch.utils.data.DataLoader](https://pytorch.org/docs/stable/data.html#torch.utils.data.DataLoader) Al empaquetar PyTorch`DataLoader`, el tamizado SageMaker inteligente se registra para ejecutarse como parte de la carga de datos en cada iteración de un PyTorch trabajo de formación. El siguiente ejemplo de código muestra la implementación del filtrado de datos de SageMaker IA en un. 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
   )
   ```