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 Anda

Ada dua cara untuk menerapkan SageMaker smart sifting ke dalam kelas TransformersTrainer.

Pengaturan sederhana

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

SiftingDataloaderKelas 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. 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 ini, enable_sifting fungsi menyediakan set_epochs parameter opsional. Hal ini memungkinkan pelatihan dengan epoch, menggunakan jumlah epoch yang disediakan oleh argumen num_train_epochs Trainer kelas, dan set max_steps ke integer sistem maksimum, memungkinkan pelatihan untuk maju sampai epoch yang ditentukan telah selesai.

Pengaturan khusus

Untuk integrasi kustom dari SageMaker smart sifting dataloader, Anda dapat menggunakan kelas Hugging Face khusus. Trainer Dalam setiap subclass dariTrainer, 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 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()