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 Trainer objet existant et l'enveloppe avecSiftingDataloader. DataLoader 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 SiftingDataloader classe est un chargeur de données itérable. La taille exacte de l'ensemble de données obtenu n'est pas connue à l'avance en raison de l'échantillonnage aléatoire lors du criblage. Par conséquent, le Hugging Trainer Face s'attend à un argument max_stepsd'entraînement. Notez que cet argument remplace le paramètre de configuration epoch. 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, il 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 n'max_stepsétait pas fourni, le 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 enable_sifting fonction fournit un set_epochs paramètre facultatif. Cela permet de s'entraîner avec des époques, en utilisant le nombre d'époques fourni par l'argument num_train_epochs de la Trainer classe, et le définit sur l'entier système maximal, permettant ainsi max_steps à 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 deTrainer, la get_train_dataloader() fonction peut être remplacée pour renvoyer un objet de la classe à la SiftingDataloader place. Dans les cas où des formateurs 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 Trainer classe encapsulé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()