Die vorliegende Übersetzung wurde maschinell erstellt. Im Falle eines Konflikts oder eines Widerspruchs zwischen dieser übersetzten Fassung und der englischen Fassung (einschließlich infolge von Verzögerungen bei der Übersetzung) ist die englische Fassung maßgeblich.

Anwenden von SageMaker Smart Sifting auf Ihr Skript von Hugging Face Transformers

Es gibt zwei Möglichkeiten, SageMaker Smart Sifting in die Trainer-Klasse von Transfomers zu implementieren.

Einfache Einrichtung

Die einfachste Methode, SageMaker Smart Sifting in die Trainer-Klasse von Transformers zu implementieren, ist die Verwendung der Funktion enable_sifting. Diese Funktion akzeptiert ein vorhandenes Trainer-Objekt und umschließt das bestehende DataLoader-Objekt mit SiftingDataloader. Sie können dasselbe Trainingsobjekt weiterhin verwenden. Sehen Sie sich das folgende Verwendungsbeispiel an.

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

Die SiftingDataloader-Klasse ist ein iterierbarer Datenlader. Die genaue Größe des resultierenden Datensatzes ist aufgrund des zufälligen Samplings während der Sichtung im Voraus nicht bekannt. Infolgedessen erwartet dar Hugging Face Trainer das max_steps-Trainingsargument. Beachten Sie, dass dieses Argument den Epochen-Konfigurationsparameter num_train_epochs außer Kraft setzt. Wenn Ihr ursprünglicher Datenlader auch iterierbar war oder Ihr Training max_steps und eine einzelne Epoche verwendet, dann funktioniert SiftingDataloader genauso wie der vorhandene Datenlader. Wenn der ursprüngliche Dataloader nicht iterierbar war oder max_steps nicht bereitgestellt wurde, gibt der Hugging Face Trainer möglicherweise eine Fehlermeldung ähnlich der folgenden aus.

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

Um dieses Problem zu beheben, stellt die enable_sifting-Funktion einen optionalen set_epochs-Parameter bereit. Dies ermöglicht das Training mit Epochen. Dabei wird die im Argument num_train_epochs der Trainer-Klasse bereitgestellte Anzahl der Epochen verwendet und max_steps auf die maximale System-Ganzzahl gesetzt, sodass das Training fortgesetzt werden kann, bis die angegebenen Epochen abgeschlossen sind.

Benutzerdefinierte Einrichtung

Für eine benutzerdefinierte Integration des Datenladers von SageMaker Smart Sifting können Sie eine benutzerdefinierte Trainer-Klasse von Hugging Face verwenden. Innerhalb jeder Unterklasse von Trainer kann die get_train_dataloader()-Funktion überschrieben werden, um stattdessen ein Objekt der SiftingDataloader-Klasse zurückzugeben. In Fällen, in denen bereits benutzerdefinierte Trainer vorhanden sind, ist dieser Ansatz möglicherweise weniger eingreifend, erfordert jedoch mehr Codeänderungen als die einfache Einrichtungsoption. Im Folgenden finden Sie eine Beispielimplementierung von SageMaker Smart Sifting in eine benutzerdefinierte Trainer-Klasse von Hugging Face.

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
        )

Erstellen Sie mithilfe der verpackten Trainer-Klasse wie folgt ein Objekt daraus.

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

trainer.train()