Penalaan Halus BertForSequenceClassification
Pelajar akan memuatkan titik semak BERT terlatih awal, menambah kepala pengelasan, mencipta PyTorch DataLoader, dan melakukan penalaan halus selama dua epoch pada set data IMDB.
Penalaan Halus BertForSequenceClassification ialah pelajaran Machine Learning Academy percuma di CoddyKit. Ini ialah pelajaran 3 daripada 4. Anda boleh membaca keseluruhan pelajaran di bawah secara percuma — kemudian berlatih secara praktikal dalam pelayar menggunakan penyunting kod terbina dalam dan tutor kecerdasan buatan 24/7. Pelajaran ini merupakan sebahagian daripada laluan pembelajaran Machine Learning Academy, dan kemajuan anda disegerakkan merentas web serta aplikasi CoddyKit. Kursus Machine Learning Academy merangkumi sejumlah 4 pelajaran.
Apakah Penalaan Halus?
Penalaan halus mengambil model terlatih yang sudah memahami struktur bahasa lalu menyesuaikannya dengan tugasan tertentu menggunakan set data berlabel yang kecil. BERT yang dipra-latih menggunakan 3.3 bilion perkataan sudah mengetahui tatabahasa, semantik dan pengetahuan dunia. Penalaan halus menambahkan kepala khusus tugasan (contohnya, lapisan pengelasan) dan melatih keseluruhan model dari hujung ke hujung pada data berlabel anda selama beberapa epok, lalu mencapai hasil tercanggih dengan data dan pengiraan yang jauh lebih sedikit berbanding latihan dari awal.
Gambaran Keseluruhan BertForSequenceClassification
BertForSequenceClassification ialah model BERT dengan kepala pengelasan linear di atas keadaan tersembunyi terakhir token [CLS]. Ini ialah kelas Hugging Face standard untuk analisis sentimen, pengelasan topik dan sebarang tugasan yang memberikan satu label kepada keseluruhan teks. Kepala tersebut dimulakan secara rawak dan dilatih bersama tulang belakang BERT semasa penalaan halus.
from transformers import BertForSequenceClassification
import torch
# 2 classes: negative (0) and positive (1)
model = BertForSequenceClassification.from_pretrained(
'bert-base-uncased',
num_labels=2
)
print(model.config.num_labels) # 2
print(model.classifier) # Linear(in=768, out=2)Memuatkan Set Data IMDB
Set data IMDB mengandungi 50,000 ulasan filem yang dilabel sebagai positif (1) atau negatif (0). Kami menggunakan pustaka datasets Hugging Face untuk memuat turun dan membahagikannya. Objek set data berkelakuan seperti kamus senarai dan boleh dipetakan menggunakan fungsi pembahagian token. Kami menggunakan pembahagian latihan 25 ribu / ujian 25 ribu yang disediakan oleh pengarang asal set data tersebut.
from datasets import load_dataset
from transformers import BertTokenizer
dataset = load_dataset('imdb')
print(dataset) # DatasetDict with train/test splits
tokenizer = BertTokenizer.from_pretrained('bert-base-uncased')
def tokenize_fn(examples):
return tokenizer(
examples['text'],
truncation=True,
padding='max_length',
max_length=256
)
tokenized = dataset.map(tokenize_fn, batched=True)
tokenized.set_format('torch', columns=['input_ids', 'attention_mask', 'label'])Mencipta DataLoaders PyTorch
Selepas pembahagian token, bungkus set data Hugging Face dalam objek DataLoader PyTorch. batch_size mengawal bilangan contoh yang diproses oleh model bagi setiap hantaran ke hadapan; 16 atau 32 biasanya sesuai untuk BERT berdasarkan kekangan memori GPU. Kocok set latihan pada setiap epok supaya model tidak terlebih sesuai dengan susunan contoh, tetapi kekalkan set pengesahan tanpa perubahan untuk penilaian yang boleh diulang.
from torch.utils.data import DataLoader
train_dataset = tokenized['train'].select(range(2000)) # small subset for demo
test_dataset = tokenized['test'].select(range(500))
train_loader = DataLoader(train_dataset, batch_size=16, shuffle=True)
test_loader = DataLoader(test_dataset, batch_size=32, shuffle=False)
print('Train batches:', len(train_loader))
print('Test batches:', len(test_loader))Menyediakan Pengoptimum
Penalaan halus BERT menggunakan pengoptimum AdamW dengan kadar pembelajaran kecil (biasanya daripada 2e-5 hingga 5e-5). Penggunaan kadar pembelajaran yang besar memusnahkan perwakilan terlatih (lupa secara malapetaka). Pereputan pemberat (regularisasi L2) digunakan pada parameter bukan bias untuk mengurangkan terlebih padan. get_linear_schedule_with_warmup daripada Hugging Face lazimnya digunakan untuk meningkatkan LR secara beransur-ansur sepanjang 10% langkah pertama, kemudian menurunkannya secara linear.
from torch.optim import AdamW
from transformers import get_linear_schedule_with_warmup
optimizer = AdamW(model.parameters(), lr=2e-5, weight_decay=0.01)
num_epochs = 2
num_steps = len(train_loader) * num_epochs
warmup_steps = int(0.1 * num_steps)
scheduler = get_linear_schedule_with_warmup(
optimizer,
num_warmup_steps=warmup_steps,
num_training_steps=num_steps
)Gelung Latihan Penalaan Halus
Gelung latihan PyTorch untuk penalaan halus BERT mengikut corak standard: lakukan lelaran merentasi kelompok, kira hantaran ke hadapan, ekstrak kerugian daripada output model (BertForSequenceClassification mengembalikan kerugian secara automatik apabila label diberikan), panggil loss.backward(), pangkas kecerunan untuk mengelakkan letusan, kemudian laksanakan langkah pengoptimum dan penjadual. Melatih BERT selama 2 epok pada IMDB biasanya menghasilkan ketepatan kira-kira 92%.
import torch
device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
model = model.to(device)
for epoch in range(2):
model.train()
total_loss = 0
for batch in train_loader:
optimizer.zero_grad()
input_ids = batch['input_ids'].to(device)
attention_mask = batch['attention_mask'].to(device)
labels = batch['label'].to(device)
outputs = model(input_ids=input_ids,
attention_mask=attention_mask,
labels=labels)
loss = outputs.loss
loss.backward()
torch.nn.utils.clip_grad_norm_(model.parameters(), 1.0)
optimizer.step()
scheduler.step()
total_loss += loss.item()
print(f'Epoch {epoch+1} loss: {total_loss/len(train_loader):.4f}')Menilai pada Set Pengesahan
Semasa penilaian, panggil model.eval() untuk menyahaktifkan dropout dan gunakan torch.no_grad() untuk melangkau pengiraan kecerunan, sekali gus menjimatkan memori dan mempercepat inferens. Ekstrak logit daripada output model (skor mentah sebelum softmax), gunakan argmax untuk mendapatkan indeks kelas yang diramal, kemudian bandingkan dengan label sebenar untuk mengira ketepatan.
import torch
from sklearn.metrics import accuracy_score
model.eval()
all_preds, all_labels = [], []
with torch.no_grad():
for batch in test_loader:
input_ids = batch['input_ids'].to(device)
attention_mask = batch['attention_mask'].to(device)
labels = batch['label'].to(device)
outputs = model(input_ids=input_ids,
attention_mask=attention_mask)
preds = torch.argmax(outputs.logits, dim=1)
all_preds.extend(preds.cpu().numpy())
all_labels.extend(labels.cpu().numpy())
print('Accuracy:', accuracy_score(all_labels, all_preds))Menyimpan Model yang Ditala Halus
Selepas penalaan halus, simpan model dan tokenizer bersama-sama supaya kedua-duanya boleh dimuatkan semula untuk inferens tanpa latihan semula. model.save_pretrained(path) menyimpan pemberat dan konfigurasi model; tokenizer.save_pretrained(path) menyimpan kosa kata dan tetapan tokenisasi. Muatkan semula dengan from_pretrained(path) dalam mana-mana sesi Python baharu.
import os
save_dir = './bert_imdb_finetuned'
os.makedirs(save_dir, exist_ok=True)
model.save_pretrained(save_dir)
tokenizer.save_pretrained(save_dir)
print('Model saved to', save_dir)
# Reload in a new session:
# from transformers import BertForSequenceClassification, BertTokenizer
# model = BertForSequenceClassification.from_pretrained(save_dir)
# tokenizer = BertTokenizer.from_pretrained(save_dir)Menggunakan API Trainer
Kelas Trainer Hugging Face merangkumi gelung latihan, penilaian, penjanaan titik semak dan pencatatan dalam satu API peringkat tinggi. Takrifkan objek TrainingArguments dengan kadar pembelajaran, saiz kelompok dan bilangan epok, kemudian panggil trainer.train(). Trainer mengendalikan pemangkasan kecerunan, penjadualan LR dan latihan ketepatan campuran secara automatik, sekali gus mengurangkan kod sokongan dengan ketara.
from transformers import Trainer, TrainingArguments
import numpy as np
from sklearn.metrics import accuracy_score
def compute_metrics(eval_pred):
logits, labels = eval_pred
preds = np.argmax(logits, axis=1)
return {'accuracy': accuracy_score(labels, preds)}
training_args = TrainingArguments(
output_dir='./bert_trainer',
num_train_epochs=2,
per_device_train_batch_size=16,
per_device_eval_batch_size=32,
learning_rate=2e-5,
evaluation_strategy='epoch',
save_strategy='epoch',
load_best_model_at_end=True
)
trainer = Trainer(
model=model,
args=training_args,
train_dataset=train_dataset,
eval_dataset=test_dataset,
compute_metrics=compute_metrics
)
trainer.train()Memantau Latihan dengan TensorBoard
Hantar report_to='tensorboard' dalam TrainingArguments untuk mencatat kerugian dan metrik ke TensorBoard secara automatik. Lancarkan TensorBoard dengan tensorboard --logdir ./bert_trainer/runs dalam terminal untuk melihat lengkung kerugian masa nyata, jadual kadar pembelajaran dan metrik penilaian. Memantau kerugian latihan berbanding kerugian pengesahan membantu anda mengesan terlebih padan lebih awal dan menghentikan latihan pada epok yang sesuai.
from transformers import TrainingArguments
training_args = TrainingArguments(
output_dir='./bert_trainer',
num_train_epochs=3,
per_device_train_batch_size=16,
learning_rate=2e-5,
evaluation_strategy='steps',
eval_steps=100,
logging_steps=50,
report_to='tensorboard', # enable TensorBoard logging
logging_dir='./bert_trainer/runs'
)
# Then: tensorboard --logdir ./bert_trainer/runsMemilih Bilangan Lapisan untuk Dibekukan
Kadang-kadang set data terlalu kecil untuk menala halus kesemua 12 lapisan BERT tanpa terlebih padan. Strategi yang lazim ialah membekukan lapisan bawah (yang mempelajari ciri linguistik umum) dan hanya mengemas kini lapisan atas (yang mempelajari ciri khusus tugasan). Bekukan lapisan dengan menetapkan requires_grad=False pada kumpulan parameter terpilih. Pantau ketepatan pengesahan untuk memilih kedalaman pembekuan yang optimum berdasarkan saiz set data anda.
from transformers import BertForSequenceClassification
model = BertForSequenceClassification.from_pretrained('bert-base-uncased', num_labels=2)
# Freeze embedding layer and first 6 encoder layers
for name, param in model.named_parameters():
if 'embeddings' in name or 'encoder.layer.0' in name or \
'encoder.layer.1' in name or 'encoder.layer.2' in name:
param.requires_grad = False
# Count trainable parameters
trainable = sum(p.numel() for p in model.parameters() if p.requires_grad)
print(f'Trainable parameters: {trainable:,}')Semakan Pantas
Uji pemahaman anda tentang konsep Pembelajaran Mesin dengan Python daripada pelajaran ini.
Imbas Kembali Pelajaran
Dalam pelajaran ini anda telah mempelajari bahawa: BertForSequenceClassification menambahkan kepala linear pada [CLS] untuk tugasan pengelasan, penalaan halus menggunakan AdamW dengan kadar pembelajaran yang sangat kecil untuk mengelakkan lupa secara malapetaka, dan API Trainer Hugging Face memudahkan gelung latihan dengan penilaian serta titik semak terbina dalam. Seterusnya, kita akan melihat cara mengekstrak ramalan daripada logit dan menilai model yang ditala halus dengan ketepatan dan F1.
Pelajari Python dengan tutor kecerdasan buatan — percuma
Tulis dan jalankan kod sebenar dalam pelayar anda, dapatkan bantuan segera daripada tutor kecerdasan buatan yang tersedia 24/7, dan sambung semula dari tempat anda berhenti di web atau dalam aplikasi.
- Kursus
- 30
- Pelajaran
- 120
Soalan Lazim
Adakah pelajaran “Penalaan Halus BertForSequenceClassification” percuma?
Ya — teks penuh “Penalaan Halus BertForSequenceClassification” boleh dibaca secara percuma di web ini. Untuk berlatih secara interaktif menggunakan penyunting kod terbina dalam dan tutor kecerdasan buatan 24/7, serta membuka kunci baki kursus Machine Learning Academy, tingkat taraf kepada CoddyKit PRO. Kursus Machine Learning Academy merangkumi sejumlah 4 pelajaran.
Apakah yang akan saya pelajari dalam “Penalaan Halus BertForSequenceClassification”?
Pelajar akan memuatkan titik semak BERT terlatih awal, menambah kepala pengelasan, mencipta PyTorch DataLoader, dan melakukan penalaan halus selama dua epoch pada set data IMDB. Anda berlatih Machine Learning Academy menggunakan kod praktikal yang dijalankan terus dalam pelayar, manakala tutor kecerdasan buatan 24/7 menjawab soalan anda semasa anda mengikuti pelajaran.
Adakah saya memerlukan pengalaman untuk memulakan Machine Learning Academy?
Tiada pengalaman terdahulu diperlukan. Pembelajaran Machine Learning Academy di CoddyKit disusun untuk pelajar daripada peringkat pemula hingga lanjutan, jadi anda boleh bermula di sini atau dari awal dan belajar mengikut kadar anda sendiri. Ini ialah pelajaran 3 daripada 4.
Berapa lamakah pelajaran “Penalaan Halus BertForSequenceClassification” diambil?
Kebanyakan pelajaran CoddyKit mengambil masa kira-kira 5–10 minit. Setiap pelajaran ringkas dan interaktif, jadi anda boleh membuat kemajuan secara berterusan dan menyambung tepat dari tempat anda berhenti di web atau aplikasi.
Bolehkah saya menulis dan menjalankan kod dalam pelajaran Machine Learning Academy ini?
Ya. Setiap pelajaran Machine Learning Academy menyertakan penyunting kod terbina dalam, jadi anda boleh menulis dan menjalankan kod sebenar terus dalam pelayar serta menerima maklum balas kecerdasan buatan serta-merta — tanpa memerlukan persediaan setempat.
Semua pelajaran dalam kursus ini
- Seni Bina Transformer: Perhatian, Token dan Konteks
- Tokenizer Hugging Face: Mengekod Teks untuk BERT
- Penalaan Halus BertForSequenceClassification
- Penilaian dan Inferens: daripada Logit kepada Label Ramalan