Applica SageMaker lo smart sifting allo script di Hugging Face Transformers

Esistono due modi per implementare lo SageMaker smart sifting nella classe Transformers. Trainer

Nota

Se usi uno dei form PyTorch con DLCs il pacchetto SageMaker smart sifting installato, tieni presente che devi installare la libreria. transformers Puoi installare pacchetti aggiuntivi estendendo DLCs o passando requirements.txt alla classe training job launcher for PyTorch (sagemaker.pytorch.PyTorch) nell'SDK AI SageMaker Python.

Configurazione semplice

Il modo più semplice per implementare lo SageMaker smart sifting nella Trainer classe Transformers consiste nell'utilizzare la funzione. enable_sifting Questa funzione accetta un Trainer oggetto esistente e lo avvolge con. DataLoader SiftingDataloader È possibile continuare a utilizzare lo stesso oggetto di addestramento. Vedi il seguente esempio di utilizzo.

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

La SiftingDataloader classe è un caricatore di dati iterabile. La dimensione esatta del set di dati risultante non è nota in anticipo a causa del campionamento casuale durante il setacciamento. Di conseguenza, l'Hugging Face Trainer si aspetta l'argomento dell'allenamento. max_steps Nota che questo argomento ha la precedenza sul parametro di configurazione epoch. num_train_epochs Se anche il caricatore di dati originale era iterabile, o se si utilizzava l'addestramento max_steps e riguardava una singola epoca, allora le SiftingDataloader prestazioni sono le stesse del dataloader esistente. Se il dataloader originale non era iterabile o non max_steps è stato fornito, Hugging Face Trainer potrebbe generare un messaggio di errore simile al seguente.

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

Per risolvere questo problema, la funzione fornisce un parametro opzionaleenable_sifting. set_epochs Ciò consente l'addestramento con le epoche, utilizzando il numero di epoche fornito dall'argomento num_train_epochs della Trainer classe, e si imposta sul numero intero massimo di sistema, permettendo all'addestramento di progredire fino max_steps al completamento delle epoche specificate.

Configurazione personalizzata

Per un'integrazione personalizzata dello SageMaker smart sifting dataloader, puoi utilizzare una classe Hugging Face personalizzata. Trainer All'interno di qualsiasi sottoclasse diTrainer, la get_train_dataloader() funzione può essere sovrascritta per restituire invece un oggetto della classe. SiftingDataloader Nei casi con trainer personalizzati esistenti, questo approccio potrebbe essere meno intrusivo ma richiede modifiche al codice rispetto alla semplice opzione di configurazione. Di seguito è riportato un esempio di implementazione dello SageMaker smart sifting in una classe Hugging Face Trainer personalizzata.

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 la Trainer classe wrapped, creane un oggetto come segue.

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

trainer.train()