Apa itu Hugging Face Trainer Class

Kelas Trainer Hugging Face dirancang untuk menyederhanakan proses pelatihan dan penyetelan ulang model transformer, menyediakan antarmuka yang mudah dan efisien untuk mengoptimalkan kinerja model. Kelas Trainer mengemas langkah-langkah yang diperlukan, termasuk pengelolaan data, optimisasi, dan evaluasi, memungkinkan pengguna untuk fokus pada bereksperimen dengan model dan hyperparameter yang berbeda.

Kelas Trainer dilengkapi dengan berbagai fungsi bawaan untuk menangani tugas-tugas umum, seperti mengatur loop pelatihan, mengelola pengoptimal dan penjadwal laju pembelajaran, serta melacak kemajuan pelatihan. Kelas ini mudah disesuaikan, memungkinkan pengguna untuk menentukan logika pelatihan khusus, metrik evaluasi, dan callback untuk menangani kasus penggunaan tertentu.

Komponen Kelas Trainer

Komponen kunci dari kelas Trainer meliputi:

• Model
  Model jaringan saraf yang akan dilatih, biasanya merupakan contoh arsitektur berbasis transformer, seperti BERT, GPT-2, atau RoBERTa. Anda dapat menggunakan model yang telah dilatih sebelumnya yang disediakan oleh Hugging Face atau menginisialisasi model baru berdasarkan kebutuhan spesifik Anda.

• Argumen Pelatihan
  Sejumlah hyperparameter dan konfigurasi yang mengontrol proses pelatihan, seperti laju pembelajaran, ukuran batch, dan jumlah epoch. Argumen-argumen ini diteruskan ke kelas Trainer sebagai contoh dari kelas TrainingArguments.

• Datasets
  Contoh dari kelas Dataset yang berisi data pelatihan, validasi, dan pengujian. Dataset ini harus diproses dan diberi token menggunakan tokenizer yang sesuai untuk model transformer yang dipilih.

• Pengoptimal dan penjadwal laju pembelajaran
  Secara default, kelas Trainer menggunakan pengoptimal AdamW dan penjadwal laju pembelajaran linear dengan pemanasan awal. Namun, Anda dapat menyesuaikan pengoptimal dan penjadwal dengan mendefinisikan versi kustom dan meneruskannya ke kelas Trainer saat inisialisasi.

• Strategi evaluasi
  Kelas Trainer mendukung berbagai strategi evaluasi, seperti mengevaluasi model setelah sejumlah langkah atau di akhir setiap epoch. Anda dapat menentukan strategi yang diinginkan dengan menggunakan argumen evaluation_strategy di kelas TrainingArguments.

• Opsi Kustomisasi
  Kelas Trainer memungkinkan tingkat kustomisasi yang tinggi untuk menyesuaikan kebutuhan spesifik. Anda dapat menentukan langkah-langkah pelatihan kustom, metrik evaluasi, dan callback dengan memperluas kelas Trainer dasar atau mengganti metode tertentu.

Pelatihan Model Anda

Untuk memulai menggunakan kelas Trainer, Anda perlu mengimpor komponen yang diperlukan dari pustakaan Hugging Face Transformers, menginisialisasi model dan tokenizer, membuat dataset, dan mengonfigurasi argumen pelatihan. Setelah konfigurasi selesai, Anda dapat menginisialisasi kelas Trainer dan memanggil metode train() untuk memulai proses pelatihan.

Sebagai contoh, untuk menyetel ulang model BERT untuk tugas klasifikasi teks, Anda dapat mengikuti langkah-langkah berikut:

1, Impor komponen yang diperlukan:

from transformers import BertForSequenceClassification, BertTokenizerFast, Trainer, TrainingArguments

2. Muat model dan tokenizer BERT yang telah dilatih sebelumnya:

model = BertForSequenceClassification.from_pretrained('bert-base-uncased')
tokenizer = BertTokenizerFast.from_pretrained('bert-base-uncased')

3. Buat dataset menggunakan tokenizer:

train_dataset = ...
valid_dataset = ...

4. Konfigurasikan argumen pelatihan:

training_args = TrainingArguments(
    output_dir='./results',
    num_train_epochs=3,
    per_device_train_batch_size=16,
    per_device_eval_batch_size=64,
    warmup_steps=500,
    weight_decay=0.01,
    logging_dir='./logs',
)

5. Inisialisasi kelas Trainer:

trainer = Trainer(
    model=model,
    args=training_args,
    train_dataset=train_dataset,
    eval_dataset=valid_dataset,
)

6. Latih model:

trainer.train()

Dengan memanfaatkan kelas Trainer, Anda dapat dengan mudah menyetel ulang model transformer untuk berbagai tugas pemrosesan bahasa alami, seperti klasifikasi teks, analisis sentimen, pertanyaan-jawaban, dan lain sebagainya.

Menginstansiasi Model Baru secara Dinamis

Opsi model_init di kelas Trainer memungkinkan Anda untuk menginstansiasi model baru secara dinamis untuk setiap jalankan pencarian hyperparameter atau loop pelatihan. Ini memastikan bahwa bobot model diinisialisasi ulang untuk setiap jalankan, memberikan kesempatan baru untuk proses pelatihan. Opsi ini sangat berguna saat melakukan penyetelan hyperparameter atau menjalankan beberapa iterasi pelatihan dengan konfigurasi yang berbeda.

Untuk menggunakan opsi model_init dengan model kustom, Anda perlu mendefinisikan fungsi yang menginisialisasi dan mengembalikan instance baru dari model kustom Anda. Anda dapat menyelesaikan fungsi ini ke kelas Trainer saat membuat instance.

Berikut adalah contoh penggunaan opsi model_init dengan model BERT kustom untuk tugas klasifikasi teks:

# Step 1: Import the necessary components
from transformers import BertModel, BertTokenizerFast, Trainer, TrainingArguments
import torch.nn as nn

# Step 2: Define your custom model
class CustomBertForSequenceClassification(nn.Module):
    def __init__(self, num_labels):
        super(CustomBertForSequenceClassification, self).__init__()
        self.bert = BertModel.from_pretrained('bert-base-uncased')
        self.classifier = nn.Linear(self.bert.config.hidden_size, num_labels)

    def forward(self, input_ids, attention_mask, labels=None):
        outputs = self.bert(input_ids, attention_mask=attention_mask)
        logits = self.classifier(outputs.last_hidden_state[:, 0, :])

        if labels is not None:
            loss_fn = nn.CrossEntropyLoss()
            loss = loss_fn(logits, labels)
            return loss, logits
        else:
            return logits

# Step 3: Define a function to initialize the custom model
def model_init():
    return CustomBertForSequenceClassification(num_labels=2)

# Step 4: Load a tokenizer
tokenizer = BertTokenizerFast.from_pretrained('bert-base-uncased')

# Step 5: Create the datasets using the tokenizer
train_dataset = ...
valid_dataset = ...

# Step 6: Configure the training arguments
training_args = TrainingArguments(
    output_dir='./results',
    num_train_epochs=3,
    per_device_train_batch_size=16,
    per_device_eval_batch_size=64,
    warmup_steps=500,
    weight_decay=0.01,
    logging_dir='./logs',
    evaluation_strategy="epoch",
)

# Step 7: Instantiate the Trainer class with the model_init function
trainer = Trainer(
    model_init=model_init,
    args=training_args,
    train_dataset=train_dataset,
    eval_dataset=valid_dataset,
)

# Step 8: Train the custom model
trainer.train()

Dengan menggunakan opsi model_init dengan model kustom, Anda dapat memastikan bahwa setiap jalankan pelatihan dimulai dengan instance model yang diinisialisasi ulang. Ini sangat membantu untuk mencapai hasil yang konsisten di beberapa jalankan atau saat melakukan penyetelan hyperparameter.

Membuat Loop Pelatihan Kustom

Meskipun kelas Trainer dirancang untuk menangani sebagian besar skenario pelatihan, pengguna mungkin perlu membuat loop pelatihan kustom untuk mengatasi persyaratan atau batasan yang unik. Pada bagian ini, saya akan menjelajahi cara membuat loop pelatihan kustom menggunakan komponen Hugging Face.

Untuk membuat loop pelatihan kustom, pengguna perlu mendefinisikan fungsi langkah pelatihan mereka sendiri dan meneruskannya ke kelas Trainer. Fungsi ini harus menerima model, data, dan optimizer sebagai input dan mengeluarkan kerugian setelah proses maju dan mundur. Pengguna dapat memanfaatkan komponen bawaan Hugging Face, seperti AutoModel dan AutoTokenizer, untuk memproses data masukan dan menangani pembaruan model.

1. Impor komponen yang diperlukan:

from transformers import AutoModelForSequenceClassification, AutoTokenizer, AdamW
import torch
from torch.utils.data import DataLoader

2. Muat model dan tokenizer yang telah dilatih sebelumnya:

model = AutoModelForSequenceClassification.from_pretrained('bert-base-uncased')
tokenizer = AutoTokenizer.from_pretrained('bert-base-uncased')

3. Buat dataset menggunakan tokenizer:

train_dataset = ...
valid_dataset = ...

4. Siapkan DataLoader, optimizer, dan scheduler:

train_dataloader = DataLoader(train_dataset, batch_size=16, shuffle=True)
valid_dataloader = DataLoader(valid_dataset, batch_size=64)

optimizer = AdamW(model.parameters(), lr=5e-5)
scheduler = torch.optim.lr_scheduler.StepLR(optimizer, step_size=1000, gamma=0.1)

5. Tentukan loop pelatihan kustom:

device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
model.to(device)

for epoch in range(3):
    # Training
    model.train()
    for batch in train_dataloader:
        optimizer.zero_grad()
        input_ids = batch['input_ids'].to(device)
        attention_mask = batch['attention_mask'].to(device)
        labels = batch['labels'].to(device)

        outputs = model(input_ids, attention_mask=attention_mask, labels=labels)
        loss = outputs.loss
        loss.backward()
        optimizer.step()
        scheduler.step()

    # Validation
    model.eval()
    total_eval_loss = 0
    for batch in valid_dataloader:
        input_ids = batch['input_ids'].to(device)
        attention_mask = batch['attention_mask'].to(device)
        labels = batch['labels'].to(device)

        with torch.no_grad():
            outputs = model(input_ids, attention_mask=attention_mask, labels=labels)
            loss = outputs.loss
            total_eval_loss += loss.item()

    avg_eval_loss = total_eval_loss / len(valid_dataloader)
    print(f'Epoch: {epoch + 1}, Validation Loss: {avg_eval_loss}')

Pada contoh ini, kita mendefinisikan loop pelatihan kustom yang terdiri dari tiga epoch pelatihan, diikuti dengan fase evaluasi. Selama pelatihan, kita melintasi train_dataloader, melakukan proses maju dan mundur pada model, dan memperbarui parameter model menggunakan optimizer dan scheduler. Selama evaluasi, kita menghitung rata-rata kerugian pada dataset validasi.

Dengan membuat loop pelatihan kustom, pengguna dapat memiliki kontrol lebih besar atas proses pelatihan, memungkinkan mereka untuk menerapkan strategi canggih atau menyesuaikan batasan khusus yang mungkin tidak didukung oleh kelas Trainer standar.

Referensi

https://huggingface.co/docs/transformers/main_classes/trainer