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

# SageMaker penyaringan cerdas dalam skrip pelatihan Anda
<a name="train-smart-sifting-apply-to-script"></a>

Pustaka penyaringan SageMaker pintar dikemas dalam [kerangka SageMaker AI DLCs](train-smart-sifting-what-is-supported.md#train-smart-sifting-supported-frameworks) sebagai perpustakaan pelengkap. Ini memberikan logika penyaringan terhadap sampel pelatihan yang memiliki dampak yang relatif lebih rendah pada pelatihan model, dan model Anda dapat mencapai akurasi model yang diinginkan dengan sampel pelatihan yang lebih sedikit jika dibandingkan dengan pelatihan model dengan sampel data lengkap.

Untuk mempelajari cara menerapkan alat penyaringan cerdas ke dalam skrip pelatihan Anda, pilih salah satu dari berikut ini berdasarkan kerangka kerja yang Anda gunakan.

**Topics**
+ [Terapkan penyaringan SageMaker cerdas ke skrip Anda PyTorch](train-smart-sifting-apply-to-pytorch-script.md)
+ [Terapkan penyaringan SageMaker cerdas ke skrip Hugging Face Transformers](train-smart-sifting-apply-to-hugging-face-transformers-script.md)

# Terapkan penyaringan SageMaker cerdas ke skrip Anda PyTorch
<a name="train-smart-sifting-apply-to-pytorch-script"></a>

Instruksi ini menunjukkan cara mengaktifkan penyaringan SageMaker cerdas dengan skrip pelatihan Anda.

1. Konfigurasikan antarmuka penyaringan SageMaker cerdas.

   Pustaka penyaringan SageMaker cerdas mengimplementasikan teknik pengambilan sampel berbasis kerugian ambang batas relatif yang membantu menyaring sampel dengan dampak yang lebih rendah dalam mengurangi nilai kerugian. Algoritma penyaringan SageMaker cerdas menghitung nilai kerugian dari setiap sampel data input menggunakan pass maju, dan menghitung persentil relatifnya terhadap nilai kehilangan data sebelumnya. 

   Dua parameter berikut adalah apa yang perlu Anda tentukan ke `RelativeProbabilisticSiftConfig` kelas untuk membuat objek konfigurasi penyaringan. 
   + Tentukan proporsi data yang harus digunakan untuk pelatihan ke `beta_value` parameter.
   + Tentukan jumlah sampel yang digunakan dalam perbandingan dengan `loss_history_length` parameter.

   Contoh kode berikut menunjukkan pengaturan sebuah objek dari `RelativeProbabilisticSiftConfig` kelas.

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

   Untuk informasi selengkapnya tentang `loss_based_sift_config` parameter dan class terkait, lihat [SageMaker modul konfigurasi penyaringan cerdas](train-smart-sifting-pysdk-reference.md#train-smart-sifting-pysdk-base-config-modules) di bagian referensi SageMaker Smart Sifting Python SDK.

   `sift_config`Objek dalam contoh kode sebelumnya digunakan pada langkah 4 untuk menyiapkan kelas. `SiftingDataloader`

1. (Opsional) Konfigurasikan kelas transformasi batch penyaringan SageMaker cerdas.

   Kasus penggunaan pelatihan yang berbeda memerlukan format data pelatihan yang berbeda. Mengingat berbagai format data, algoritma penyaringan SageMaker cerdas perlu mengidentifikasi cara melakukan penyaringan pada batch tertentu. Untuk mengatasi hal ini, SageMaker smart sifting menyediakan modul transformasi batch yang membantu mengonversi batch menjadi format standar yang dapat disaring secara efisien. 

   1. SageMaker smart sifting menangani transformasi batch data pelatihan dalam format berikut: Daftar Python, kamus, tupel, dan tensor. Untuk format data ini, SageMaker smart sifting secara otomatis menangani konversi format data batch, dan Anda dapat melewati sisa langkah ini. Jika Anda melewati langkah ini, pada langkah 4 untuk mengkonfigurasi`SiftingDataloader`, biarkan `batch_transforms` parameter `SiftingDataloader` ke nilai defaultnya, yaitu`None`.

   1. Jika kumpulan data Anda tidak dalam format ini, Anda harus melanjutkan ke sisa langkah ini untuk membuat transformasi batch khusus menggunakan`SiftingBatchTransform`. 

      Dalam kasus di mana kumpulan data Anda tidak berada dalam salah satu format yang didukung oleh penyaringan SageMaker cerdas, Anda mungkin mengalami kesalahan. Kesalahan format data tersebut dapat diatasi dengan menambahkan `batch_transforms` parameter `batch_format_index` or ke `SiftingDataloader` kelas, yang Anda atur di langkah 4. Berikut ini menunjukkan contoh kesalahan karena format data yang tidak kompatibel dan resolusi untuk mereka.    
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/id_id/sagemaker/latest/dg/train-smart-sifting-apply-to-pytorch-script.html)

      Untuk mengatasi masalah yang disebutkan di atas, Anda perlu membuat kelas transformasi batch khusus menggunakan `SiftingBatchTransform` modul. Kelas transformasi batch harus terdiri dari sepasang fungsi transformasi dan reverse-transform. Pasangan fungsi mengonversi format data Anda ke format yang dapat diproses oleh algoritme penyaringan SageMaker cerdas. Setelah Anda membuat kelas transformasi batch, kelas mengembalikan `SiftingBatch` objek yang akan Anda berikan ke `SiftingDataloader` kelas di langkah 4.

      Berikut ini adalah contoh kelas transformasi batch kustom `SiftingBatchTransform` modul.
      + Contoh implementasi transformasi batch daftar kustom dengan penyaringan SageMaker cerdas untuk kasus di mana potongan dataloader memiliki input, mask, dan label.

        ```
        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
        ```
      + Contoh implementasi transformasi batch daftar kustom dengan penyaringan SageMaker cerdas untuk kasus di mana tidak ada label yang diperlukan untuk transformasi terbalik.

        ```
        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
        ```
      + Contoh implementasi batch tensor khusus dengan penyaringan SageMaker cerdas untuk kasus di mana potongan pemuat data memiliki input, masker, dan label.

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

      Setelah Anda membuat `SiftingBatchTransform` kelas transformasi batch yang diimplementasikan, Anda menggunakan kelas ini di langkah 4 untuk menyiapkan kelas. `SiftingDataloader` Sisa dari panduan ini mengasumsikan bahwa `ListBatchTransform` kelas dibuat. Pada langkah 4, kelas ini diteruskan ke`batch_transforms`.

1. Buat kelas untuk mengimplementasikan `Loss` antarmuka penyaringan SageMaker cerdas. Tutorial ini mengasumsikan bahwa kelas diberi nama`SiftingImplementedLoss`. Saat menyiapkan kelas ini, kami sarankan Anda menggunakan fungsi kerugian yang sama dalam loop pelatihan model. Ikuti sublangkah berikut untuk membuat kelas `Loss` implementasi penyaringan SageMaker cerdas.

   1. SageMaker smart sifting menghitung nilai kerugian untuk setiap sampel data pelatihan, sebagai lawan menghitung nilai kerugian tunggal untuk batch. Untuk memastikan bahwa penyaringan SageMaker cerdas menggunakan logika perhitungan kerugian yang sama, buat fungsi smart-sifting-implemented kerugian menggunakan `Loss` modul penyaringan SageMaker pintar yang menggunakan fungsi kerugian Anda dan hitung kerugian per sampel pelatihan. 
**Tip**  
SageMaker algoritma penyaringan cerdas berjalan pada setiap sampel data, bukan pada seluruh batch, jadi Anda harus menambahkan fungsi inisialisasi untuk mengatur fungsi PyTorch kerugian tanpa strategi pengurangan apa pun.  

      ```
      class SiftingImplementedLoss(Loss):  
          def __init__(self):
              self.loss = torch.nn.CrossEntropyLoss(reduction='none')
      ```
Ini juga ditunjukkan dalam contoh kode berikut.

   1. Tentukan fungsi kerugian yang menerima `original_batch` (atau `transformed_batch` jika Anda telah menyiapkan transformasi batch pada langkah 2) dan PyTorch model. Menggunakan fungsi kerugian yang ditentukan tanpa pengurangan, SageMaker smart sifting menjalankan forward pass untuk setiap sampel data untuk mengevaluasi nilai kerugiannya. 

   Kode berikut adalah contoh dari smart-sifting-implemented `Loss` antarmuka bernama`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])
   ```

   Sebelum loop pelatihan mencapai pass maju yang sebenarnya, perhitungan kerugian penyaringan ini dilakukan selama fase pemuatan data pengambilan batch di setiap iterasi. Nilai kerugian individu kemudian dibandingkan dengan nilai kerugian sebelumnya, dan persentil relatifnya diperkirakan per objek yang telah `RelativeProbabilisticSiftConfig` Anda atur pada langkah 1.

1. Bungkus pemuat PyTroch data dengan `SiftingDataloader` kelas SageMaker AI.

   Terakhir, gunakan semua kelas implementasi penyaringan SageMaker cerdas yang Anda konfigurasikan pada langkah sebelumnya ke kelas `SiftingDataloder` konfigurasi SageMaker AI. Kelas ini adalah pembungkus untuk PyTorch [https://pytorch.org/docs/stable/data.html#torch.utils.data.DataLoader](https://pytorch.org/docs/stable/data.html#torch.utils.data.DataLoader). Dengan membungkus PyTorch`DataLoader`, penyaringan SageMaker cerdas terdaftar untuk dijalankan sebagai bagian dari pemuatan data di setiap iterasi pekerjaan pelatihan. PyTorch Contoh kode berikut menunjukkan penerapan penyaringan data SageMaker AI ke file. 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
   )
   ```

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