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 uma peneiração SageMaker inteligente em seu script de Hugging Face Transformers
<a name="train-smart-sifting-apply-to-hugging-face-transformers-script"></a>

Há duas maneiras de implementar a peneiração SageMaker inteligente na classe Transformers`Trainer`.

**nota**  
Se você usar um dos DLCs for PyTorch com o pacote SageMaker smart sifting instalado, observe que você precisa instalar a `transformers` biblioteca. Você pode instalar pacotes adicionais [estendendo DLCs ou passando `requirements.txt` para a](prebuilt-containers-extend.md) classe de iniciador de tarefas de treinamento for PyTorch ([https://sagemaker.readthedocs.io/en/stable/frameworks/pytorch/sagemaker.pytorch.html](https://sagemaker.readthedocs.io/en/stable/frameworks/pytorch/sagemaker.pytorch.html)) no SDK do AI SageMaker Python.

## Configuração simples
<a name="train-smart-sifting-apply-to-hugging-face-transformers-script-simple"></a>

A maneira mais simples de implementar a peneiração SageMaker inteligente na `Trainer` classe Transformers é usar a função. `enable_sifting` Essa função aceita um objeto `Trainer` existente e envolve o objeto `DataLoader` existente com `SiftingDataloader`. É possível continuar usando o mesmo objeto de treinamento. Veja o exemplo de uso a seguir.

```
from smart_sifting.integrations.trainer import enable_sifting
from smart_sifting.loss.abstract_sift_loss_module import Loss
from smart_sifting.sift_config.sift_configs import (
    RelativeProbabilisticSiftConfig
    LossConfig
    SiftingBaseConfig
)

class SiftingImplementedLoss(Loss):
   def loss(self, model, transformed_batch, original_batch):
        loss_fct = MSELoss(reduction="none") # make sure to set reduction to "none"
        logits = model.bert(**original_batch)
        return loss_fct(logits, original_batch.get("labels"))

sift_config = RelativeProbabilisticSiftConfig(
    beta_value=0.5,
    loss_history_length=500,
    loss_based_sift_config=LossConfig(
         sift_config=SiftingBaseConfig(sift_delay=0)
    )
)

trainer = Trainer(...)
enable_sifting(trainer, sift_config, loss=SiftingImplementedLoss()) # updates the trainer with Sifting Loss and config
trainer.train()
```

A classe `SiftingDataloader` é um carregador de dados iterável. O tamanho exato do conjunto de dados resultante não é conhecido de antemão devido à amostragem aleatória durante a seleção. Como resultado, o `Trainer` Hugging Face espera o [argumento do treinamento `max_steps`](https://huggingface.co/docs/transformers/main_classes/trainer#transformers.TrainingArguments.max_steps). Observe que esse argumento substitui o parâmetro de configuração epoch `num_train_epochs`. Se seu carregador de dados original também fosse iterável, ou se seu treinamento `max_steps` usasse uma única época, o `SiftingDataloader` funcionaria da mesma forma que o carregador de dados existente. Se o carregador de dados original não fosse iterável ou não `max_steps` fosse fornecido, o treinador Hugging Face poderia gerar uma mensagem de erro semelhante à seguinte: 

```
args.max_steps must be set to a positive value if dataloader does not have a length,
was -1
```

Para resolver isso, a função `enable_sifting` fornece um parâmetro `set_epochs` opcional. Isso permite o treinamento com épocas, usando o número de épocas fornecido pelo [argumento num\$1train\$1epochs](https://huggingface.co/docs/transformers/main_classes/trainer#transformers.TrainingArguments.num_train_epochs(float,) da classe `Trainer`, e define `max_steps` como o número inteiro máximo do sistema, permitindo que o treinamento progrida até que as épocas especificadas sejam concluídas.

## Configuração personalizada
<a name="train-smart-sifting-apply-to-hugging-face-transformers-script-custom-trainer"></a>

Para uma integração personalizada do carregador de dados de peneiramento SageMaker inteligente, você pode utilizar uma classe personalizada Hugging Face. `Trainer` Em qualquer subclasse de `Trainer`, a função `get_train_dataloader()` pode ser substituída para retornar um objeto da classe `SiftingDataloader`. Para casos com treinadores personalizados existentes, essa abordagem pode ser menos invasiva, mas requer alterações no código do que a simples opção de configuração. Veja a seguir um exemplo de implementação da seleção SageMaker inteligente em uma classe personalizada do Hugging Face`Trainer`.

```
from smart_sifting.sift_config.sift_configs import (
    RelativeProbabilisticSiftConfig
    LossConfig
    SiftingBaseConfig
)
from smart_sifting.dataloader.sift_dataloader import SiftingDataloader
from smart_sifting.loss.abstract_sift_loss_module import Loss
from smart_sifting.data_model.data_model_interface import SiftingBatch, SiftingBatchTransform
from smart_sifting.data_model.list_batch import ListBatch

class SiftingListBatchTransform(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

class SiftingImplementedLoss():
    # You should add the following initializaztion function 
    # to calculate loss per sample, not per batch.
    def __init__(self):
        self.celoss = 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]

        # compute loss
        outputs = model(batch)
        return self.celoss(outputs.logits, batch[2])

class SiftingImplementedTrainer(Trainer):
    def get_train_dataloader(self):
        dl = super().get_train_dataloader()

        sift_config = RelativeProbabilisticSiftConfig(
            beta_value=0.5,
            loss_history_length=500,
            loss_based_sift_config=LossConfig(
                sift_config=SiftingBaseConfig(sift_delay=0)
            )
        )

        return SiftingDataloader(
                sift_config=sift_config,
                orig_dataloader=dl,
                batch_transforms=SiftingListBatchTransform(),
                loss_impl=SiftingImplementedLoss(),
                model=self.model
        )
```

Usando a classe `Trainer` envolvida, crie um objeto dela da seguinte maneira:

```
trainer = SiftingImplementedTrainer(
    model=model,
    args=training_args,
    train_dataset=small_train_dataset,
    eval_dataset=small_eval_dataset
)

trainer.train()
```