Einleitung

In diesem Bericht behandeln wir Beispiele, bei denen mit der Early Stopping-Regulierung die Feineinstellung deines HuggingFace-Transformers vorgenommen werden. Behandelt wird der Gebrauch von Early Stopping mit nativem PyTorch und TensorFlow, gemeinsam mit der HuggingFace Trainer API (Schnittstelle zur Programmierung von Anwendungen).

Natives TensorFlow

Nimm die Feineinstellung des HuggingFace-Transformers durch den Gebrauch von TF in Colab vor $\to$

Wenn du TensorFlow (Keras) verwendest, um die Feineinstellung des HuggingFace-Transformers vorzunehmen, funktioniert das Einfügen von Early Stopping ganz unkompliziert mit tf.keras.callbacks.EarlyStopping Callback. Es nimmt den Namen des Maßes an, das du überwachst, und die Anzahl der Epochen, nach der das Training beendet wird, wenn sich keine Verbesserung zeigt.

early_stopper = tf.keras.callbacks.EarlyStopping(monitor='val_loss', 
                                                 patience=5, 
                                                 restore_best_weights=True)

Hier ist early_stopper der Callback, der mit modell.fit verwendet werden kann.

model.fit(trainloader, 
          epochs=10, 
          validation_data=validloader,
          callbacks=[early_stopper])

Beobachtungen

• Das Modell unterlag schnell einer Überanpassung an das Trainings-Datenset, was sich am Validationsverlust zeigt.

• Trainings-Modelle mit Early Stopping führen zu früher Beendigung des Trainingsprozesses. Das wiederum spart Rechenkosten und –zeit.

• Da der beste Fall des Modells (niedriger Validationsverlust) während des Gebrauchs des EarlyStopping Callbacks gespeichert wurde, indiziert die resultierende Testgenauigkeit ei pauschalisierteres Modell.

Natives PyTorch

Nimm die Feineinstellung des HuggingFace-Transformers durch den Gebrauch von PyTorch in Colab vor $\to$

Natives PyTorch hat keine gebrauchsfertige Early Stopping-Methode. Aber wenn du die Feineinstellung deines HuggingFace-Transformers durch den Gebrauch von PyTorch vornimmst, findest du hier eine GitHub-Kernaussage, die einen funktionierenden Early Stopping-Aufhänger bietet.

class EarlyStopping(object):
    def __init__(self, mode='min', min_delta=0, patience=10, percentage=False):
        self.mode = mode
        self.min_delta = min_delta
        self.patience = patience
        self.best = None
        self.num_bad_epochs = 0
        self.is_better = None
        self._init_is_better(mode, min_delta, percentage)

        if patience == 0:
            self.is_better = lambda a, b: True
            self.step = lambda a: False

    def step(self, metrics):
        if self.best is None:
            self.best = metrics
            return False

        if np.isnan(metrics):
            return True

        if self.is_better(metrics, self.best):
            self.num_bad_epochs = 0
            self.best = metrics
        else:
            self.num_bad_epochs += 1

        if self.num_bad_epochs >= self.patience:
            print('terminating because of early stopping!')
            return True

        return False

    def _init_is_better(self, mode, min_delta, percentage):
        if mode not in {'min', 'max'}:
            raise ValueError('mode ' + mode + ' is unknown!')
        if not percentage:
            if mode == 'min':
                self.is_better = lambda a, best: a < best - min_delta
            if mode == 'max':
                self.is_better = lambda a, best: a > best + min_delta
        else:
            if mode == 'min':
                self.is_better = lambda a, best: a < best - (
                            best * min_delta / 100)
            if mode == 'max':
                self.is_better = lambda a, best: a > best + (
                            best * min_delta / 100)

Informiere dich mit diesem Colab notebook, wie du Early Stopping in deiner Trainingsschleife verwenden kannst.

es = EarlyStopping(patience=5)

num_epochs = 100
for epoch in range(num_epochs):
      train_one_epoch(model, data_loader)  # train the model for one epoch.
      metric = eval(model, data_loader_dev)  # evalution on dev set.
      if es.step(metric):
          break  # early stop criterion is met, we can stop now

Ich empfehle sehr, deinen PyTorch-Code zu reorganisieren, indem du PyTorch Lightning verwendest. Es stellt Early Stopping and viele andere Techniken gebrauchsfertig zur Verfügung. Wenn du dich mit PyTorch Lightning noch nicht auskennst, sind hier einige Berichte, die dir beim Start helfen:

• Bild-Klassifizierung unter Verwendung von PyTorch Lightning

• Transfer-Lernen unter Verwendung von PyTorch Lightning

• Multi-GPU-Training unter Verwendung von PyTorch Lightning