Vyladění modelů Hugging Face pro jeden GPU
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
- Cluster s jedním uzlem s jedním GPU na ovladači.
- Verze GPU Databricks Runtime 13.0 ML a vyšší.
- Tento příklad pro vyladění vyžaduje 🤗 balíčky Transformers, 🤗 Datasets a 🤗 Evaluate, které jsou součástí Databricks Runtime 13.0 ML a vyšší.
- 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é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.
- Co jsou Hugging Face Transformers?
- Modely Hugging Face Transformers ve Sparku můžete použít k horizontálnímu navýšení kapacity dávkových aplikací NLP, viz Odvozování modelů pomocí Hugging Face Transformers pro NLP.