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. Obsahuje také doporučení specifická pro Databricks pro načítání dat z lakehouse a protokolování modelů v MLflow, což vám umožňuje 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í.
  • Vytváření konfigurace pro nástroj Hugging Face Transformers Trainer.
  • Trénování na jednom GPU

Podívejte se , co jsou Hugging Face Transformers?

Požadavky

  • Cluster s jedním uzlem, s jedním GPU na ovladači.
  • Verze Databricks Runtime 13.0 ML a vyšší pro GPU.
    • Tento příklad pro vyladění vyžaduje balíčky 🤗 Transformers, 🤗 Datasets a 🤗 Evaluate, které jsou zahrnuty v Databricks Runtime 13.0 ML a vyšších verzích.
  • MLflow 2.3.
  • Data připravená a načtená pro vyladění modelu s transformátory.

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éninku od Hugging Face se dají použít ke konfiguraci Trainer. Třídy trenéra vyžadují, aby uživatel poskytl:

  • Ukazatele
  • 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í sběrače dat vytváří dávky vstupů 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

Hugging Face dobře spolupracuje s MLflow a automaticky protokoluje metriky během trénování modelu pomocí MLflowCallback. Trénovaný model si však musíte zaznamenat sami.

Zabalte školení do běhu 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 potrubí, můžete odeslat komponenty použité při tréninku 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í

Když je váš model zapsán a připraven, jeho načítání pro inference je stejné jako načítání předtrénovaného modelu zabaleného v 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 fp16=Truemůžete nastavit .

  • Pomocí gradient_accumulation_steps v TrainingArguments efektivně zvýšíte 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.

K ř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: Doladě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.

Notebook pro doladění modelů klasifikace textu Hugging Face

Získejte poznámkový blok

Další materiály

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