Las traducciones son generadas a través de traducción automática. En caso de conflicto entre la traducción y la version original de inglés, prevalecerá la version en inglés.

Aplica un tamizado SageMaker inteligente a tu guion de Hugging Face Transformers

Hay dos formas de implementar el tamizado SageMaker inteligente en la clase Transformers. Trainer

Configuración sencilla

La forma más sencilla de implementar el tamizado SageMaker inteligente en la Trainer clase Transformers es usar la enable_sifting función. Esta función acepta un Trainer objeto existente y lo envuelve con él. DataLoader SiftingDataloader Puedes seguir usando el mismo objeto de entrenamiento. Consulta el siguiente ejemplo de uso.

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 clase es un cargador de datos iterable. El tamaño exacto del conjunto de datos resultante no se conoce de antemano debido al muestreo aleatorio que se realiza durante la selección. Como resultado, Hugging Trainer Face espera max_stepsel argumento del entrenamiento. Tenga en cuenta que este argumento anula el parámetro de configuración epoch. num_train_epochs Si su cargador de datos original también era iterable, o si su entrenamiento utiliza max_steps una sola época, entonces SiftingDataloader funciona igual que el cargador de datos existente. Si el cargador de datos original no era iterable o no se max_steps proporcionaba, el Hugging Face Trainer podría arrojar un mensaje de error similar al siguiente.

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

Para solucionar este problema, la enable_sifting función proporciona un parámetro opcional. set_epochs Esto permite el entrenamiento con épocas, utilizando el número de épocas proporcionado por el argumento num_train_epochs de la Trainer clase, y se establece en el número entero máximo del sistema, lo max_steps que permite que el entrenamiento avance hasta completar las épocas especificadas.

Configuración personalizada

Para una integración personalizada del cargador de datos de cribado SageMaker inteligente, puedes utilizar una clase personalizada de Hugging Face. Trainer Dentro de cualquier subclase deTrainer, la get_train_dataloader() función se puede anular para devolver un objeto de la clase en su lugar. SiftingDataloader En el caso de los instructores personalizados existentes, este enfoque puede ser menos invasivo, pero requiere cambios de código, en comparación con la opción de configuración simple. El siguiente es un ejemplo de implementación de la SageMaker selección inteligente en una clase personalizada de Hugging Face. 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
        )

Con la Trainer clase comprimida, cree un objeto de la misma de la siguiente manera.

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

trainer.train()