Sdílet prostřednictvím

Vyladění modelů Hugging Face pro jeden GPU

  • Článek

Tento článek popisuje, jak doladit model Hugging Face s knihovnou Hugging Face transformers na jednom GPU. Zahrnuje také doporučení specifická pro Databricks pro načítání dat z modelu lakehouse a protokolování do MLflow, která umožňují používat a řídit vaše modely v Azure Databricks.

Knihovna Hugging Face transformers poskytuje nástroj Trainer a třídy automatického modelu , které umožňují načítání a vyladění modelů Transformers.

Tyto nástroje jsou k dispozici pro následující úlohy s jednoduchými úpravami:

  • Načítá se modely pro doladění.
  • Konstrukce konfigurace pro Hugging Face Transformers Trainer utility.
  • Trénování na jednom GPU

Podívejte se , co jsou Hugging Face Transformers?

Požadavky

Tokenizace datové sady Hugging Face

Modely Hugging Face Transformers očekávají tokenizovaný vstup místo textu ve stažených datech. Pokud chcete zajistit kompatibilitu se základním modelem, použijte autoTokenizer načtený ze základního modelu. Hugging Face datasets umožňuje přímo aplikovat tokenizátor konzistentně na trénovací i testovací data.

Příklad:

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)

Nastavení konfigurace trénování

Nástroje pro konfiguraci trénování tváře se dají použít ke konfiguraci trenéra. Třídy trenéra vyžadují, aby uživatel poskytl:

  • Metriky
  • Základní model
  • Konfigurace trénování

Kromě výchozí loss metriky, kterou Trainer vypočítá, můžete nakonfigurovat i metriky vyhodnocení. Následující příklad ukazuje přidání accuracy jako metriky:

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)

K načtení vhodného modelu pro vaši úlohu použijte třídy automatického modelu pro NLP.

Pro klasifikaci textu použijte autoModelForSequenceClassification k načtení základního modelu pro klasifikaci textu. Při vytváření modelu zadejte počet tříd a mapování popisků vytvořených během přípravy datové sady.

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

Dále vytvořte konfiguraci trénování. Třída TrainingArguments umožňuje zadat výstupní adresář, strategii vyhodnocení, rychlost učení a další parametry.

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

Použití vstupu kolace dat v trénovacích a vyhodnocovacích datových sadách. DataCollatorWithPadding poskytuje dobrý výkon standardních hodnot pro klasifikaci textu.

from transformers import DataCollatorWithPadding
data_collator = DataCollatorWithPadding(tokenizer)

Po sestavení všech těchto parametrů můžete nyní vytvořit Trainer.

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

Trénování a přihlášení do MLflow

Rozhraní hugging Face dobře s MLflow a automaticky protokoluje metriky během trénování modelu pomocí MLflowCallback. Vytrénovaný model ale musíte protokolovat sami.

Zabalte trénování do spuštění MLflow. Tím se vytvoří kanál Transformers z tokenizátoru a natrénovaného modelu a zapíše ho na místní disk. Nakonec protokolujte model do MLflow pomocí mlflow.transformers.log_model.

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!",
    )

Pokud nepotřebujete vytvořit kanál, můžete odeslat komponenty, které se používají při trénování, do slovníku:

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!"],
)

Načtení modelu pro odvozování

Při protokolování a připravenosti modelu je načtení modelu pro odvozování stejné jako načtení zabaleného předtrénovaného modelu MLflow.

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)

Další informace najdete v tématu Nasazení modelů pomocí služeb Mosaic AI Model Serving.

Řešení běžných chyb CUDA

Tato část popisuje běžné chyby CUDA a pokyny k jejich řešení.

OutOfMemoryError: Nedostatek paměti CUDA

Při trénování velkých modelů může dojít k běžné chybě CUDA kvůli nedostatku paměti.

Příklad:

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.

Pokud chcete tuto chybu vyřešit, vyzkoušejte následující doporučení:

  • Zmenšete velikost dávky pro trénování. Můžete snížit per_device_train_batch_size hodnotu v TrainingArguments.

  • Používejte trénování s nižší přesností. V TrainingArgumentsmůžete nastavit fp16=True.

  • Pomocí gradient_accumulation_steps v trénovacícharguments efektivně zvětšete celkovou velikost dávky.

  • Použijte 8bitový optimalizátor Adam.

  • Před trénováním vyčistěte paměť GPU. Někdy může být paměť GPU obsazená některým nepoužívaným kódem.

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

Chyby jádra CUDA

Při spuštění trénování se můžou zobrazit chyby jádra CUDA.

Příklad:

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.

Řešení problémů:

  • Zkuste spustit kód na procesoru, abyste zjistili, jestli je chyba reprodukovatelná.

  • Další možností je získat lepší zpětné trasování nastavením CUDA_LAUNCH_BLOCKING=1:

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

Poznámkový blok: Vyladění klasifikace textu na jednom GPU

Abyste mohli rychle začít s ukázkovým kódem, poskytuje tento ukázkový poznámkový blok ucelený příklad pro vyladění modelu pro klasifikaci textu. V dalších částech tohoto článku najdete podrobnější informace o používání Hugging Face pro vyladění Azure Databricks.

Poznámkový blok s modelem klasifikace textu pro rozpoznávání tváře s jemným laděním

Získejte poznámkový blok

Další materiály

Přečtěte si další informace o Hugging Face v Azure Databricks.