Terjemahan disediakan oleh mesin penerjemah. Jika konten terjemahan yang diberikan bertentangan dengan versi bahasa Inggris aslinya, utamakan versi bahasa Inggris.

# Terapkan penyaringan SageMaker cerdas ke skrip Hugging Face Transformers
<a name="train-smart-sifting-apply-to-hugging-face-transformers-script"></a>

Ada dua cara untuk menerapkan SageMaker smart sifting ke dalam kelas Transformers`Trainer`.

**catatan**  
Jika Anda menggunakan salah satu DLCs untuk PyTorch dengan paket penyaringan SageMaker pintar diinstal, perhatikan bahwa Anda perlu menginstal `transformers` perpustakaan. Anda dapat menginstal paket tambahan dengan [memperluas DLCs](prebuilt-containers-extend.md) atau meneruskan `requirements.txt` ke kelas peluncur pekerjaan pelatihan untuk PyTorch ([https://sagemaker.readthedocs.io/en/stable/frameworks/pytorch/sagemaker.pytorch.html](https://sagemaker.readthedocs.io/en/stable/frameworks/pytorch/sagemaker.pytorch.html)) di AI SageMaker Python SDK.

## Pengaturan sederhana
<a name="train-smart-sifting-apply-to-hugging-face-transformers-script-simple"></a>

Cara paling sederhana untuk menerapkan SageMaker smart sifting ke dalam `Trainer` kelas Transformers adalah dengan menggunakan fungsi tersebut. `enable_sifting` Fungsi ini menerima objek yang ada, dan membungkus `Trainer` objek yang ada `DataLoader` dengan. `SiftingDataloader` Anda dapat terus menggunakan objek pelatihan yang sama. Lihat contoh penggunaan berikut.

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

`SiftingDataloader`Kelas adalah pemuat data iterable. Ukuran pasti dari kumpulan data yang dihasilkan tidak diketahui sebelumnya karena pengambilan sampel acak selama pengayakan. Akibatnya, Hugging `Trainer` Face mengharapkan argumen pelatihan [`max_steps`.](https://huggingface.co/docs/transformers/main_classes/trainer#transformers.TrainingArguments.max_steps) Perhatikan bahwa argumen ini mengesampingkan parameter konfigurasi epoch. `num_train_epochs` Jika pemuat data asli Anda juga dapat diulang, atau pelatihan Anda menggunakan `max_steps` dan satu epoch, maka akan `SiftingDataloader` melakukan hal yang sama dengan dataloader yang ada. Jika dataloader asli tidak dapat diulang atau `max_steps` tidak disediakan, Pelatih Wajah Pemeluk mungkin akan menampilkan pesan kesalahan yang mirip dengan berikut ini. 

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

Untuk mengatasi hal ini, `enable_sifting` fungsi menyediakan `set_epochs` parameter opsional. Hal ini memungkinkan pelatihan dengan epoch, menggunakan jumlah epoch yang disediakan oleh [argumen num\$1train\$1epochs](https://huggingface.co/docs/transformers/main_classes/trainer#transformers.TrainingArguments.num_train_epochs(float,) `Trainer` kelas, dan set `max_steps` ke integer sistem maksimum, memungkinkan pelatihan untuk maju sampai epoch yang ditentukan telah selesai.

## Penyiapan kustom
<a name="train-smart-sifting-apply-to-hugging-face-transformers-script-custom-trainer"></a>

Untuk integrasi kustom dari SageMaker smart sifting dataloader, Anda dapat menggunakan kelas Hugging Face khusus. `Trainer` Dalam setiap subclass dari`Trainer`, `get_train_dataloader()` fungsi dapat diganti untuk mengembalikan objek kelas sebagai gantinya. `SiftingDataloader` Untuk kasus dengan pelatih khusus yang ada, pendekatan ini mungkin kurang mengganggu tetapi memerlukan perubahan kode daripada opsi pengaturan sederhana. Berikut ini adalah contoh implementasi SageMaker smart sifting ke dalam kelas Hugging Face kustom. `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
        )
```

Menggunakan `Trainer` kelas yang dibungkus, buat objek itu sebagai berikut.

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

trainer.train()
```