Bagikan melalui

Menyempurnakan model Hugging Face untuk satu GPU

  • Artikel

Artikel ini menjelaskan cara menyempurnakan model Hugging Face dengan pustaka Hugging Face transformers pada satu GPU. Ini juga termasuk rekomendasi khusus Databricks untuk memuat data dari lakehouse dan model pengelogan ke MLflow, yang memungkinkan Anda menggunakan dan mengatur model Anda di Azure Databricks.

Pustaka Hugging Face transformers menyediakan utilitas Trainer dan kelas Model Otomatis yang memungkinkan pemuatan dan penyempurnaan model Transformers.

Alat-alat ini tersedia untuk tugas-tugas berikut dengan modifikasi sederhana:

  • Memuat model untuk menyempurnakan.
  • Membangun konfigurasi untuk utilitas Hugging Face Transformers Trainer.
  • Melakukan pelatihan pada satu GPU.

Lihat Apa itu Pelukan Transformer Wajah?

Persyaratan

Tokenisasi himpunan data Hugging Face

Memeluk model Face Transformers mengharapkan input token, bukan teks dalam data yang diunduh. Untuk memastikan kompatibilitas dengan model dasar, gunakan AutoTokenizer yang dimuat dari model dasar. Memeluk Wajah datasets memungkinkan Anda untuk langsung menerapkan tokenizer secara konsisten ke data pelatihan dan pengujian.

Contohnya:

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)

Menyiapkan konfigurasi pelatihan

Alat konfigurasi pelatihan Hugging Face dapat digunakan untuk mengonfigurasi Trainer. Kelas Trainer mengharuskan pengguna untuk menyediakan:

  • Metrik
  • Model dasar
  • Konfigurasi pelatihan

Anda dapat mengonfigurasi metrik evaluasi selain metrik default loss yang Trainer dihitung. Contoh berikut menunjukkan penambahan accuracy sebagai metrik:

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)

Gunakan kelas Model Otomatis untuk NLP untuk memuat model yang sesuai untuk tugas Anda.

Untuk klasifikasi teks, gunakan AutoModelForSequenceClassification untuk memuat model dasar untuk klasifikasi teks. Saat membuat model, berikan jumlah kelas dan pemetaan label yang dibuat selama persiapan himpunan data.

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

Selanjutnya, buat konfigurasi pelatihan. Kelas TrainingArguments memungkinkan Anda menentukan direktori output, strategi evaluasi, tingkat pembelajaran, dan parameter lainnya.

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

Menggunakan kolase data mengumpulkan input dalam himpunan data pelatihan dan evaluasi. DataCollatorWithPadding memberikan performa garis besar yang baik untuk klasifikasi teks.

from transformers import DataCollatorWithPadding
data_collator = DataCollatorWithPadding(tokenizer)

Dengan semua parameter ini dibangun, Anda sekarang dapat membuat 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,
)

Melatih dan masuk ke MLflow

Memeluk antarmuka Face dengan baik dengan MLflow dan secara otomatis mencatat metrik selama pelatihan model menggunakan MLflowCallback. Namun, Anda harus mencatat model terlatih sendiri.

Bungkus pelatihan dalam eksekusi MLflow. Ini membangun alur Transformers dari tokenizer dan model terlatih, dan menulisnya ke disk lokal. Terakhir, catat model ke MLflow dengan 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!",
    )

Jika Anda tidak perlu membuat alur, Anda dapat mengirimkan komponen yang digunakan dalam pelatihan ke dalam kamus:

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

Muat model untuk inferensi

Ketika model Anda dicatat dan siap, memuat model untuk inferensi sama dengan memuat model MLflow yang dibungkus sebelumnya.

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)

Lihat Model melayani dengan Azure Databricks untuk informasi selengkapnya.

Memecahkan masalah kesalahan CUDA umum

Bagian ini menjelaskan kesalahan dan panduan CUDA umum tentang cara mengatasinya.

OutOfMemoryError: CUDA kehabisan memori

Saat melatih model besar, kesalahan umum yang mungkin Anda temui adalah KESALAHAN CUDA kehabisan memori.

Contoh:

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.

Coba rekomendasi berikut untuk mengatasi kesalahan ini:

  • Kurangi ukuran batch untuk pelatihan. Anda dapat mengurangi per_device_train_batch_size nilai dalam TrainingArguments.

  • Gunakan pelatihan presisi yang lebih rendah. Anda dapat mengatur fp16=True di TrainingArguments.

  • Gunakan gradient_accumulation_steps dalam TrainingArguments untuk meningkatkan ukuran batch secara efektif.

  • Gunakan pengoptimal Adam 8-bit.

  • Bersihkan memori GPU sebelum pelatihan. Terkadang, memori GPU mungkin ditempati oleh beberapa kode yang tidak digunakan.

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

Kesalahan kernel CUDA

Saat menjalankan pelatihan, Anda mungkin mendapatkan kesalahan kernel CUDA.

Contoh:

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.

Pemecahan masalah:

  • Coba jalankan kode pada CPU untuk melihat apakah kesalahan dapat direproduksi.

  • Opsi lain adalah mendapatkan traceback yang lebih baik dengan mengatur CUDA_LAUNCH_BLOCKING=1:

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

Notebook: Menyempurnakan klasifikasi teks pada satu GPU

Untuk memulai dengan cepat dengan contoh kode, contoh buku catatan ini menyediakan contoh end-to-end untuk menyempurnakan model untuk klasifikasi teks. Bagian berikutnya dari artikel ini membahas lebih detail tentang menggunakan Hugging Face untuk penyempurnaan di Azure Databricks.

Menyempurnakan buku catatan model klasifikasi teks Wajah Pelukan

Dapatkan buku catatan

Sumber Daya Tambahan:

Pelajari selengkapnya tentang Memeluk Wajah di Azure Databricks.