Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.

Application de l’analyse intelligente SageMaker sur votre script Transformeurs Hugging Face

Il existe deux manières d’implémenter l’analyse intelligente SageMaker dans la classe Trainer de Transformers.

Configuration simple

La méthode la plus simple pour implémenter l’analyse intelligente SageMaker dans la classe TrainerTransformers consiste à utiliser la fonction enable_sifting. Cette fonction accepte un objet Trainer existant et enveloppe l’objet DataLoader avec SiftingDataloader. Vous pouvez continuer à utiliser le même objet d’entraînement. Consultez l’exemple d’utilisation suivant.

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 classe SiftingDataloader est un chargeur de données itérable. La taille exacte du jeu de données obtenu n’est pas connue à l’avance en raison de l’échantillonnage aléatoire lors de l’analyse. Par conséquent, le Trainer Hugging Face s’attend à un argument d’entraînement max_steps. Notez que cet argument remplace le paramètre de configuration d’époque num_train_epochs. Si votre chargeur de données d’origine était également itérable, ou si votre entraînement utilise max_steps une seule époque, le SiftingDataloader fonctionne de la même manière que le chargeur de données existant. Si le chargeur de données d’origine n’était pas itérable ou si max_steps n’était pas fourni, Hugging Face Trainer peut générer un message d’erreur similaire au suivant.

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

Pour résoudre ce problème, la fonction enable_sifting fournit un paramètre set_epochs facultatif. Cela permet l’entraînement avec des époques, en utilisant le nombre d’époques fourni par l’argument num_train_epochs de la classe Trainer et définit max_steps sur l’entier système maximal, permettant ainsi à l’entraînement de progresser jusqu’à ce que les époques spécifiées soient terminées.

Configuration personnalisée

Pour une intégration personnalisée du chargeur de données d’analyse intelligente SageMaker, vous pouvez utiliser une classe Trainer Hugging Face personnalisée. Dans n’importe quelle sous-classe de Trainer, la fonction get_train_dataloader() peut être remplacée pour renvoyer un objet de la classe SiftingDataloader à la place. Dans les cas où des entraîneurs personnalisés existent déjà, cette approche peut être moins intrusive mais nécessite des modifications de code par rapport à l’option de configuration simple. Voici un exemple d’implémentation de l’analyse intelligente SageMaker dans une classe Trainer Hugging Face personnalisée.

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
        )

À l’aide de la classe Trainer enveloppée, créez-en un objet comme suit.

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

trainer.train()