Delen via

Hugging Face-modellen verfijnen voor één GPU

In dit artikel wordt beschreven hoe u een Hugging Face-model kunt verfijnen met de bibliotheek Hugging Face transformers op één GPU. Het bevat ook databricks-specifieke aanbevelingen voor het laden van gegevens uit lakehouse- en logboekregistratiemodellen naar MLflow, waarmee u uw modellen in Azure Databricks kunt gebruiken en beheren.

De hugging Face-bibliotheek transformers biedt het trainerhulpprogramma en automodelklassen waarmee u transformersmodellen kunt laden en verfijnen.

Deze hulpprogramma's zijn beschikbaar voor de volgende taken met eenvoudige wijzigingen:

  • Modellen laden om fijn af te stemmen.
  • Het bouwen van de configuratie voor het hulpprogramma Hugging Face Transformers Trainer.
  • Training uitvoeren op één GPU.

Zie Wat zijn Hugging Face Transformers?

Vereisten

Gegevensset van Hugging Face tokeniseren

Hugging Face Transformers-modellen verwachten getokeniseerde invoer in plaats van de tekst in de gedownloade gegevens. Gebruik een AutoTokenizer die is geladen vanuit het basismodel om compatibiliteit met het basismodel te garanderen. Met Hugging Face datasets kunt u de tokenizer consistent toepassen op zowel de trainings- als de testgegevens.

Voorbeeld:

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)

De trainingsconfiguratie instellen

Hulpprogramma's voor de trainingconfiguratie van Hugging Face kunnen worden gebruikt om een Trainer te configureren. Voor de trainerklassen moet de gebruiker het volgende verstrekken:

  • Metrische gegevens
  • Een basismodel
  • Een trainingsconfiguratie

U kunt evaluatiemetrieken configureren naast de standaardmetriek loss die door Trainer wordt berekend. In het volgende voorbeeld wordt gedemonstreerd hoe u accuracy als een maatstaf toevoegt:

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)

Gebruik de klassen AutoModel voor NLP om het juiste model voor uw taak te laden.

Voor tekstclassificatie gebruikt u AutoModelForSequenceClassification om een basismodel voor tekstclassificatie te laden. Wanneer u het model maakt, geeft u het aantal klassen en de labeltoewijzingen op die tijdens de voorbereiding van de gegevensset zijn gemaakt.

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

Maak vervolgens de trainingsconfiguratie. Met de TrainingArguments klasse kunt u de uitvoermap, evaluatiestrategie, leersnelheid en andere parameters opgeven.

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

Het gebruik van een gegevensverzamelaar verzamelt invoer in trainings- en evaluatiegegevenssets. DataCollatorWithPadding biedt goede basislijnprestaties voor tekstclassificatie.

from transformers import DataCollatorWithPadding
data_collator = DataCollatorWithPadding(tokenizer)

Nu al deze parameters zijn gemaakt, kunt u nu een Trainermaken.

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

Trainen en aanmelden bij MLflow

Hugging Face werkt goed samen met MLflow en registreert automatisch meetgegevens tijdens het uitvoeren van modeltraining met behulp van de MLflowCallback. U moet het getrainde model echter zelf registreren.

Training verpakken in een MLflow-uitvoering. Hiermee wordt een transformatorpijplijn gemaakt van de tokenizer en het getrainde model en wordt deze naar de lokale schijf geschreven. Meld ten slotte het model aan bij MLflow met 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!",
    )

Als u geen pijplijn hoeft te maken, kunt u de onderdelen die in de training worden gebruikt, indienen in een woordenlijst:

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

Het model laden voor deductie

Wanneer uw model gelogd en gereed is, is het laden van het model voor inferentie hetzelfde als het laden van het vooraf getrainde MLflow-model.

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)

Zie Modellen implementeren met behulp van Mosaic AI Model Serving voor meer informatie.

Veelvoorkomende CUDA-fouten oplossen

In deze sectie worden veelvoorkomende CUDA-fouten en richtlijnen beschreven voor het oplossen van deze fouten.

OutOfMemoryError: CUDA geheugen op

Bij het trainen van grote modellen is een veelvoorkomende fout die u kunt tegenkomen de CUDA out of memory-fout.

Voorbeeld:

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.

Probeer de volgende aanbevelingen om deze fout op te lossen:

  • Verklein de batchgrootte voor training. U kunt de per_device_train_batch_size waarde in TrainingArguments verminderen.

  • Gebruik training met lagere precisie. U kunt fp16=True instellen in TrainingArguments.

  • Gebruik gradient_accumulation_steps in TrainingArguments om de totale batchgrootte effectief te vergroten.

  • Gebruik 8-bit Adam-optimizer.

  • Schoon het GPU-geheugen op voordat u traint. Soms kan GPU-geheugen worden bezet door een aantal ongebruikte code.

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

CUDA-kernelfouten

Bij het uitvoeren van de training kunnen CUDA-kernelfouten optreden.

Voorbeeld:

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.

Ga als volgt te werk om het probleem op te lossen:

  • Voer de code uit op de CPU om te zien of de fout reproduceerbaar is.

  • Een andere optie is om een betere tracering te krijgen door CUDA_LAUNCH_BLOCKING=1in te stellen:

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

Notebook: Tekstclassificatie verfijnen op één GPU

Om snel aan de slag te gaan met voorbeeldcode, biedt dit voorbeeldnotebook een end-to-end-voorbeeld voor het verfijnen van een model voor tekstclassificatie. In de volgende secties van dit artikel wordt dieper ingegaan op het gebruik van Hugging Face voor het verfijnen van Azure Databricks.

Fijnafstelling van Hugging Face tekstclassificatiemodellen in een notebook

Notitieblok ophalen

Aanvullende bronnen

Meer informatie over Hugging Face in Azure Databricks.

  • Last updated on