Share via

Optimieren von Hugging Face-Modellen für eine einzelne GPU

  • Artikel

In diesem Artikel wird beschrieben, wie Sie ein Hugging Face-Modell mit der Hugging Face-Bibliothek transformers auf einer einzelnen GPU optimieren. Es enthält auch Databricks-spezifische Empfehlungen zum Laden von Daten aus dem Lakehouse und aus Protokollierungsmodellen in MLflow, wodurch Sie Ihre Modelle in Azure Databricks verwenden und steuern können.

Die Bibliothek Hugging Face transformers bietet das Trainer-Hilfsprogramm und Automodell-Lektionen, die das Laden und Optimieren von Transformatorenmodellen ermöglichen.

Diese Tools stehen für die folgenden Aufgaben mit einfachen Änderungen zur Verfügung:

  • Laden von Modellen zur Optimierung.
  • Konstruieren der Konfiguration für das Hilfsprogramm Hugging Face Transformers Trainer.
  • Durchführen von Training auf einer einzelnen GPU.

Siehe Was sind Hugging Face Transformers?

Anforderungen

Tokenisieren eines Hugging Face-Datasets

Hugging Face Transformers-Modelle erwarten tokenisierte Eingaben anstelle des Texts in den heruntergeladenen Daten. Um die Kompatibilität mit dem Basismodell sicherzustellen, verwenden Sie einen AutoTokenizer, der aus dem Basismodell geladen wurde. Hugging Face datasets ermöglicht es Ihnen, den Tokenizer konsistent auf die Trainings- und Testdaten anzuwenden.

Beispiel:

from transformers import AutoTokenizer

tokenizer = AutoTokenizer.from_pretrained(base_model)
def tokenize_function(examples):
    return tokenizer(examples["text"], padding=False, truncation=True)

train_test_tokenized = train_test_dataset.map(tokenize_function, batched=True)

Einrichten der Trainingskonfiguration

Mit den Konfigurationstools für das Hugging Face Training kann ein Trainer konfiguriert werden. Die Trainerlektionen erfordern, dass der Benutzer Folgendes bereitstellt:

  • metrics
  • Ein Basismodell
  • Eine Trainingskonfiguration

Sie können Auswertungsmetriken zusätzlich zu den Standardmetriken loss konfigurieren, die von Trainer berechnet werden. Im folgenden Beispiel wird das Hinzufügen von accuracy als Metrik veranschaulicht:

import numpy as np
import evaluate
metric = evaluate.load("accuracy")
def compute_metrics(eval_pred):
    logits, labels = eval_pred
    predictions = np.argmax(logits, axis=-1)
    return metric.compute(predictions=predictions, references=labels)

Verwenden Sie die Automodell-Klassen für NLP, um das entsprechende Modell für Ihre Aufgabe zu laden.

Verwenden Sie für die Textklassifizierung AutoModelForSequenceClassification, um ein Basismodell für die Textklassifizierung zu laden. Stellen Sie beim Erstellen des Modells die Anzahl der Klassen und die Bezeichnungszuordnungen bereit, die während der Datasetvorbereitung erstellt wurden.

from transformers import AutoModelForSequenceClassification
model = AutoModelForSequenceClassification.from_pretrained(
        base_model,
        num_labels=len(label2id),
        label2id=label2id,
        id2label=id2label
        )

Erstellen Sie als Nächstes die Trainingskonfiguration. Mit der Lektion TrainingArguments können Sie das Ausgabeverzeichnis, die Auswertungsstrategie, die Lernrate und andere Parameter angeben.

from transformers import TrainingArguments, Trainer
training_args = TrainingArguments(output_dir=training_output_dir, evaluation_strategy="epoch")

Mit Hilfe eines Datensammlers werden die Eingaben in Trainings- und Auswertungsdatensätzen zusammengefasst. DataCollatorWithPadding bietet eine gute Basisleistung für die Textklassifizierung.

from transformers import DataCollatorWithPadding
data_collator = DataCollatorWithPadding(tokenizer)

Mit all diesen Parametern können Sie jetzt Trainer erstellen.

trainer = Trainer(
    model=model,
    args=training_args,
    train_dataset=train_test_dataset["train"],
    eval_dataset=train_test_dataset["test"],
    compute_metrics=compute_metrics,
    data_collator=data_collator,
)

Trainieren und Protokollieren bei MLflow

Hugging Face hat eine gute Schnittstelle zu MLflow und protokolliert automatisch Metriken während des Modelltrainings mit dem MLflowCallback. Sie müssen das trainierte Modell jedoch selbst protokollieren.

Verpacken Sie das Training in einen MLflow-Lauf. Dies konstruiert eine Transformers-Pipeline aus dem Tokenizer und dem trainierten Modell und schreibt sie auf die lokale Festplatte. Protokollieren Sie schließlich das Modell mit mlflow.transformers.log_model in MLflow.

from transformers import pipeline

with mlflow.start_run() as run:
  trainer.train()
  trainer.save_model(model_output_dir)
  pipe = pipeline("text-classification", model=AutoModelForSequenceClassification.from_pretrained(model_output_dir), batch_size=1, tokenizer=tokenizer)
  model_info = mlflow.transformers.log_model(
        transformers_model=pipe,
        artifact_path="classification",
        input_example="Hi there!",
    )

Wenn Sie keine Pipeline erstellen müssen, können Sie die Komponenten, die beim Training verwendet werden, in ein Wörterbuch übertragen:

model_info = mlflow.transformers.log_model(
  transformers_model={"model": trainer.model, "tokenizer": tokenizer},
  task="text-classification",
  artifact_path="text_classifier",
  input_example=["MLflow is great!", "MLflow on Databricks is awesome!"],
)

Laden des Modells für Rückschlüsse

Wenn Ihr Modell protokolliert und bereit ist, ist das Laden des Modells für das Rückschließen dasselbe wie das Laden des mit MLflow verpackten, vorab trainierten Modells.

logged_model = "runs:/{run_id}/{model_artifact_path}".format(run_id=run.info.run_id, model_artifact_path=model_artifact_path)

# Load model as a Spark UDF. Override result_type if the model does not return double values.
loaded_model_udf = mlflow.pyfunc.spark_udf(spark, model_uri=logged_model, result_type='string')

test = test.select(test.text, test.label, loaded_model_udf(test.text).alias("prediction"))
display(test)

Weitere Informationen finden Sie unter Modellbereitstellung unter Azure Databricks.

Problembehandlung häufiger CUDA-Fehler

In diesem Abschnitt werden allgemeine CUDA-Fehler und Anleitungen zur Behebung beschrieben.

OutOfMemoryError: Nicht genügend Arbeitsspeicher für CUDA

Beim Trainieren großer Modelle tritt häufig der Fehler „CUDA out of memory“ auf.

Beispiel:

OutOfMemoryError: CUDA out of memory. Tried to allocate 20.00 MiB (GPU 0; 14.76 GiB total capacity; 666.34 MiB already allocated; 17.75 MiB free; 720.00 MiB reserved in total by PyTorch) If reserved memory is >> allocated memory try setting max_split_size_mb to avoid fragmentation.  See documentation for Memory Management and PYTORCH_CUDA_ALLOC_CONF.

Probieren Sie die folgenden Empfehlungen aus, um diesen Fehler zu beheben:

  • Reduzieren Sie die für das Training zu verwendende Batchgröße. Sie können den per_device_train_batch_size-Wert in TrainingArguments reduzieren.

  • Verwenden Sie ein Training mit geringerer Genauigkeit. Sie können fp16=True in TrainingArgumentsfestlegen.

  • Verwenden Sie gradient_accumulation_steps in TrainingArguments, um die Gesamtbatchgröße effektiv zu erhöhen.

  • Verwenden Sie den 8-Bit-Adam-Optimierer.

  • Bereinigen Sie den GPU-Speicher vor dem Training. Manchmal wird der GPU-Speicher möglicherweise von einem nicht verwendeten Code belegt.

    from numba import cuda
device = cuda.get_current_device()
device.reset()

CUDA-Kernelfehler

Beim Ausführen des Trainings erhalten Sie möglicherweise CUDA-Kernelfehler.

Beispiel:

CUDA kernel errors might be asynchronously reported at some other API call, so the stacktrace below might be incorrect.

For debugging, consider passing CUDA_LAUNCH_BLOCKING=1.

Problembehandlung:

  • Versuchen Sie, den Code auf der CPU auszuführen, um festzustellen, ob der Fehler reproduzierbar ist.

  • Eine weitere Möglichkeit besteht darin, eine bessere Ablaufverfolgung zu erhalten, indem Sie CUDA_LAUNCH_BLOCKING=1 festlegen:

    import os
os.environ["CUDA_LAUNCH_BLOCKING"] = "1"

Notebook: Optimieren der Textklassifizierung auf einer einzelnen GPU

Um schnell mit Beispielcode zu beginnen, bietet dieses Beispielnotebook ein End-to-End-Beispiel für die Optimierung eines Modells für die Textklassifizierung. In den nachfolgenden Abschnitten dieses Artikels finden Sie ausführlichere Informationen zur Verwendung von Hugging Face zur Optimierung von Azure Databricks.

Optimierung von Textklassifizierungsmodellen für Hugging Face- Notebook

Notebook abrufen

Zusätzliche Ressourcen

Erfahren Sie mehr über Hugging Face auf Azure Databricks.