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.

Appliquez un SageMaker filtrage intelligent à votre script Hugging Face Transformers

Il existe deux manières d'implémenter le tamisage SageMaker intelligent dans la classe Transformers. Trainer

Configuration simple

Le moyen le plus simple d'implémenter le criblage SageMaker intelligent dans la Trainer classe Transformers consiste à utiliser la enable_sifting fonction. 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 de tamisage SageMaker intelligent, vous pouvez utiliser une classe Hugging Face personnalisée. Trainer 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 du tamisage SageMaker intelligent dans une classe Hugging Face personnalisée. 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
        )

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