Delen via

Hugging Face-modellen verfijnen voor één GPU

  • Artikel

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 af te stemmen.
  • Het bouwen van de configuratie voor het hulpprogramma Hugging Face Transformers Trainer.
  • Training uitvoeren op één GPU.

Zie Wat zijn knuffelingsgezichttransformaties?

Vereisten

Een gegevensset met een hugging Face tokeniseren

Het knuffelen van Face Transformers-modellen verwacht tokenized 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 Face datasets hugging kunt u de tokenizer rechtstreeks toepassen op zowel de trainings- als 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 het knuffelen van face-training kunnen worden gebruikt om een Trainer te configureren. Voor de trainerklassen moet de gebruiker het volgende verstrekken:

  • Metrische gegevens voor
  • Een basismodel
  • Een trainingsconfiguratie

U kunt metrische evaluatiegegevens configureren naast de standaardmetrieken loss die door de Trainer berekeningen worden berekend. In het volgende voorbeeld ziet u hoe u het toevoegen als een metriek toevoegt accuracy :

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 klasse TrainingArguments 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 gegevenssorator batches 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 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,
)

Trainen en aanmelden bij MLflow

Face-interfaces goed knuffelen met MLflow en registreert automatisch metrische gegevens tijdens 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 is geregistreerd en gereed is, is het laden van het model voor deductie 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 Model dat wordt geleverd met Azure Databricks 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 onvoldoende geheugen

Bij het trainen van grote modellen is een veelvoorkomende fout die u kunt tegenkomen de CUDA uit het geheugen.

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 instellen fp16=True in TrainingArguments.

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

  • Gebruik 8-bits 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 het instellen CUDA_LAUNCH_BLOCKING=1van:

    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.

Notitieblok voor het opsnuffelen van face-tekstclassificatiemodellen afstemmen

Notebook downloaden

Aanvullende bronnen

Meer informatie over Hugging Face in Azure Databricks.