Share via

Dostrajanie modeli rozpoznawania twarzy dla pojedynczego procesora GPU

  • Artykuł

W tym artykule opisano, jak dostosować model hugging Face przy użyciu biblioteki Hugging Face transformers na jednym procesorze GPU. Zawiera również zalecenia specyficzne dla usługi Databricks dotyczące ładowania danych z usługi Lakehouse i modeli rejestrowania do platformy MLflow, co umożliwia korzystanie z modeli i zarządzanie nimi w usłudze Azure Databricks.

Biblioteka Hugging Face transformers udostępnia klasy Narzędzia trenera i Auto Model , które umożliwiają ładowanie i dostrajanie modeli Transformers.

Te narzędzia są dostępne dla następujących zadań z prostymi modyfikacjami:

  • Ładowanie modeli w celu dostosowania.
  • Konstruowanie konfiguracji narzędzia Hugging Face Transformers Trainer.
  • Trenowanie na jednym procesorze GPU.

Zobacz Co to są przytulanie transformatorów twarzy?

Wymagania

Tokenizowanie zestawu danych przytulania twarzy

Przytulanie modeli przekształcania twarzy oczekuje tokenizowanych danych wejściowych, a nie tekstu w pobranych danych. Aby zapewnić zgodność z modelem podstawowym, użyj narzędzia AutoTokenizer załadowanego z modelu podstawowego. Przytulanie twarzy datasets umożliwia bezpośrednie stosowanie tokenizatora zarówno do danych treningowych, jak i testowych.

Na przykład:

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)

Konfigurowanie konfiguracji trenowania

Przytulanie narzędzi konfiguracji trenowania twarzy może służyć do konfigurowania trenera. Klasy trenera wymagają od użytkownika podania następujących elementów:

  • Metryki
  • Model podstawowy
  • Konfiguracja trenowania

Oprócz domyślnej loss metryki obliczeniowej Trainer można skonfigurować metryki oceny. W poniższym przykładzie pokazano dodawanie accuracy jako metryki:

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)

Użyj klas automatycznego modelu dla równoważenia obciążenia sieciowego, aby załadować odpowiedni model dla zadania.

W przypadku klasyfikacji tekstu użyj funkcji AutoModelForSequenceClassification , aby załadować model podstawowy na potrzeby klasyfikacji tekstu. Podczas tworzenia modelu podaj liczbę klas i mapowania etykiet utworzone podczas przygotowywania zestawu danych.

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

Następnie utwórz konfigurację trenowania. Klasa TrainingArguments umożliwia określenie katalogu wyjściowego, strategii oceny, szybkości nauki i innych parametrów.

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

Użycie modułu sortowania danych wsaduje dane wejściowe w zestawach danych szkoleniowych i ewaluacyjnych. Funkcja DataCollatorWithPadding zapewnia dobrą wydajność punktu odniesienia klasyfikacji tekstu.

from transformers import DataCollatorWithPadding
data_collator = DataCollatorWithPadding(tokenizer)

Po utworzeniu wszystkich tych parametrów można teraz utworzyć element 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,
)

Trenowanie i logowanie do biblioteki MLflow

Przytulanie interfejsów twarzy dobrze za pomocą biblioteki MLflow i automatyczne rejestrowanie metryk podczas trenowania modelu przy użyciu MLflowCallback. Należy jednak samodzielnie zarejestrować wytrenowany model.

Zawijanie trenowania w przebiegu MLflow. Tworzy potok Transformers z tokenizatora i wytrenowanego modelu oraz zapisuje go na dysku lokalnym. Na koniec zarejestruj model w usłudze MLflow przy użyciu 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!",
    )

Jeśli nie musisz tworzyć potoku, możesz przesłać składniki używane podczas trenowania do słownika:

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

Ładowanie modelu na potrzeby wnioskowania

Gdy model jest rejestrowany i gotowy, ładowanie modelu do wnioskowania jest takie samo jak ładowanie wstępnie wytrenowanego 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)

Aby uzyskać więcej informacji, zobacz Obsługa modelu w usłudze Azure Databricks .

Rozwiązywanie typowych błędów CUDA

W tej sekcji opisano typowe błędy CUDA i wskazówki dotyczące sposobu ich rozwiązywania.

OutOfMemoryError: CUDA — brak pamięci

Podczas trenowania dużych modeli typowy błąd, który może wystąpić, to błąd CUDA braku pamięci.

Przykład:

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.

Spróbuj wykonać następujące zalecenia, aby rozwiązać ten błąd:

  • Zmniejsz rozmiar partii na potrzeby trenowania. Możesz zmniejszyć per_device_train_batch_size wartość w obszarze TrainingArguments.

  • Użyj trenowania o mniejszej precyzji. Możesz ustawić fp16=True w obszarze TrainingArguments.

  • Użyj gradient_accumulation_steps w obszarze TrainingArguments, aby skutecznie zwiększyć całkowity rozmiar partii.

  • Użyj 8-bitowego optymalizatora Adama.

  • Wyczyść pamięć procesora GPU przed rozpoczęciem trenowania. Czasami pamięć procesora GPU może być zajęta przez jakiś nieużywany kod.

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

Błędy jądra CUDA

Podczas uruchamiania trenowania mogą wystąpić błędy jądra CUDA.

Przykład:

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.

Aby rozwiązać problem:

  • Spróbuj uruchomić kod na procesorze CPU, aby sprawdzić, czy błąd jest powtarzalny.

  • Inną opcją jest uzyskanie lepszego śledzenia poprzez ustawienie :CUDA_LAUNCH_BLOCKING=1

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

Notes: dostrajanie klasyfikacji tekstu na jednym procesorze GPU

Aby szybko rozpocząć pracę z przykładowym kodem, ten przykładowy notes zawiera kompleksowe przykładowe dostrajanie modelu klasyfikacji tekstu. W kolejnych sekcjach tego artykułu bardziej szczegółowo o korzystaniu z funkcji Hugging Face w celu dostrajania w usłudze Azure Databricks.

Dostrajanie notesu modeli klasyfikacji tekstu rozpoznawania twarzy

Pobierz notes

Dodatkowe zasoby

Dowiedz się więcej o hugging Face w usłudze Azure Databricks.