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

Terapkan SageMaker penyaringan cerdas ke skrip Hugging Face Transformers Anda

Ada dua cara untuk menerapkan penyaringan SageMaker cerdas ke dalam Trainer kelas Transformers.

Pengaturan sederhana

Cara paling sederhana untuk menerapkan pen SageMaker yaringan cerdas ke dalam Trainer kelas Transformers adalah dengan menggunakan enable_sifting fungsi tersebut. Fungsi ini menerima Trainer objek yang ada, dan membungkus DataLoader objek yang ada denganSiftingDataloader. 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()

SiftingDataloaderKelas adalah pemuat data yang dapat diiterasi. Ukuran pasti dari kumpulan data yang dihasilkan tidak diketahui sebelumnya karena pengambilan sampel acak selama penyaringan. Akibatnya, Hugging Face Trainer mengharapkan argum en max_steps pelatihan. Perhatikan bahwa argumen ini menggantikan parameter num_train_epochs konfigurasi zaman. Jika pemuat data asli Anda juga dapat diulang, atau pelatihan Anda menggunakan satu max_steps zaman, maka kinerjanya sama SiftingDataloader dengan pemuat data yang ada. Jika pemuat data asli tidak dapat diulang atau max_steps tidak disediakan, Hugging Face Trainer mungkin 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. Ini memungkinkan pelatihan dengan zaman, menggunakan jumlah zaman yang disediakan oleh argum en num_train_epochs Trainer kelas, dan menetapkan max_steps ke bilangan bulat sistem maksimum, memungkinkan pelatihan untuk maju sampai zaman tertentu selesai.

Pengaturan khusus

Untuk integrasi kustom dari SageMaker smart sifting dataloader, Anda dapat menggunakan kelas Hugging Face khusus. Trainer Dalam subkelas mana punTrainer, 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 penyar SageMaker ingan cerdas ke kelas Hugging Face Trainer kustom.

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 sebagai berikut.

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

trainer.train()