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. 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=True
můž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.
- 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.