Dela via

Finjustera Hugging Face-modeller för en enda GPU

  • Artikel

Den här artikeln beskriver hur du finjusterar en Hugging Face-modell med biblioteket Hugging Face transformers på en enda GPU. Den innehåller även Databricks-specifika rekommendationer för att läsa in data från lakehouse- och loggningsmodellerna till MLflow, vilket gör att du kan använda och styra dina modeller på Azure Databricks.

Biblioteket Hugging Face transformers tillhandahåller träningsverktyget och automodellklasser som möjliggör inläsning och finjustering av Transformers-modeller.

De här verktygen är tillgängliga för följande uppgifter med enkla ändringar:

  • Läser in modeller för att finjustera.
  • Konstruera konfigurationen för verktyget Hugging Face Transformers Trainer.
  • Utföra träning på en enda GPU.

Se Vad är huggande ansiktstransformatorer?

Krav

Tokenisera en datauppsättning för kramande ansikte

Hugging Face Transformers-modeller förväntar sig tokeniserade indata i stället för texten i de nedladdade data. För att säkerställa kompatibilitet med basmodellen använder du en AutoTokenizer som lästs in från basmodellen. Med Hugging Face datasets kan du tillämpa tokenizern direkt på både tränings- och testdata.

Till exempel:

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)

Konfigurera träningskonfigurationen

Konfigurationsverktyg för att krama ansiktsträning kan användas för att konfigurera en tränare. Tränarklasserna kräver att användaren anger:

  • Mått
  • En basmodell
  • En träningskonfiguration

Du kan konfigurera utvärderingsmått utöver standardmåttet loss Trainer som beräknas. I följande exempel visas hur du lägger till accuracy som ett mått:

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)

Använd automodellklasserna för NLP för att läsa in lämplig modell för din uppgift.

För textklassificering använder du AutoModelForSequenceClassification för att läsa in en basmodell för textklassificering. När du skapar modellen anger du antalet klasser och de etikettmappningar som skapades under förberedelsen av datamängden.

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

Skapa sedan träningskonfigurationen. Med klassen TrainingArguments kan du ange utdatakatalogen, utvärderingsstrategin, inlärningshastigheten och andra parametrar.

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

Med hjälp av en datasortering batchar indata i tränings- och utvärderingsdatauppsättningar. DataCollatorWithPadding ger bra baslinjeprestanda för textklassificering.

from transformers import DataCollatorWithPadding
data_collator = DataCollatorWithPadding(tokenizer)

När alla dessa parametrar har skapats kan du nu skapa en 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äna och logga in på MLflow

Krama ansiktsgränssnitt väl med MLflow och loggar automatiskt mått under modellträning med hjälp av MLflowCallback. Du måste dock logga den tränade modellen själv.

Omslut träningen i en MLflow-körning. Detta konstruerar en Transformers-pipeline från tokenizern och den tränade modellen och skriver den till en lokal disk. Logga slutligen modellen till MLflow med 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!",
    )

Om du inte behöver skapa en pipeline kan du skicka de komponenter som används i träning till en ordlista:

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

Läs in modellen för slutsatsdragning

När din modell är inloggad och klar är inläsning av modellen för slutsatsdragning samma sak som att läsa in den förtränade MLflow-modellen.

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)

Mer information finns i Modellservering med Azure Databricks .

Felsöka vanliga CUDA-fel

I det här avsnittet beskrivs vanliga CUDA-fel och vägledning om hur du löser dem.

OutOfMemoryError: CUDA har slut på minne

När du tränar stora modeller kan det uppstå ett vanligt fel med att CUDA har slut på minne.

Exempel:

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.

Prova följande rekommendationer för att lösa det här felet:

  • Minska batchstorleken för träning. Du kan minska värdet per_device_train_batch_size i TrainingArguments.

  • Använd träning med lägre precision. Du kan ange fp16=True i TrainingArguments.

  • Använd gradient_accumulation_steps i TrainingArguments för att effektivt öka den totala batchstorleken.

  • Använd 8-bitars Adam-optimerare.

  • Rensa GPU-minnet före träningen. Ibland kan GPU-minne upptas av någon oanvänd kod.

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

CUDA-kernelfel

När du kör träningen kan du få CUDA-kernelfel.

Exempel:

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.

För att felsöka:

  • Prova att köra koden på CPU för att se om felet är reproducerbart.

  • Ett annat alternativ är att få en bättre spårning genom att ange CUDA_LAUNCH_BLOCKING=1:

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

Notebook: Finjustera textklassificering på en enda GPU

För att komma igång snabbt med exempelkod tillhandahåller den här exempelanteckningsboken ett exempel från slutpunkt till slutpunkt för finjustering av en modell för textklassificering. De efterföljande avsnitten i den här artikeln går in mer detaljerat på hur du använder Hugging Face för finjustering på Azure Databricks.

Finjustering av notebook-filen huggande ansiktstextklassificeringsmodeller

Hämta notebook-fil

Ytterligare resurser

Läs mer om Hugging Face på Azure Databricks.