BertForSequenceClassification fine-tunen
Cursisten laden een voorgetraind BERT-checkpoint, voegen een classificatiekop toe, maken een PyTorch DataLoader en fine-tunen twee epochs lang op een IMDB-dataset.
BertForSequenceClassification fine-tunen is een gratis Machine Learning Academy-les op CoddyKit. Dit is les 3 van 4. Je kunt de volledige les hieronder gratis lezen en daarna in de browser praktisch oefenen met een ingebouwde code-editor en een AI-begeleider die 24/7 beschikbaar is. Deze les maakt deel uit van het leertraject Machine Learning Academy. Je voortgang wordt gesynchroniseerd op het web en in de CoddyKit-app. De cursus Machine Learning Academy bevat in totaal 4 lessen.
Wat is fine-tuning?
Fine-tuning neemt een vooraf getraind model dat de structuur van taal al begrijpt en past dit aan voor een specifieke taak met een kleine gelabelde gegevensverzameling. BERT, dat vooraf is getraind op 3,3 miljard woorden, kent al grammatica, semantiek en wereldkennis. Fine-tuning voegt een taakspecifieke head toe (bijvoorbeeld een classificatielaag) en traint het volledige model end-to-end op je gelabelde gegevens gedurende enkele epochs. Zo bereik je resultaten van het hoogste niveau met veel minder gegevens en rekenkracht dan wanneer je vanaf nul traint.
Overzicht van BertForSequenceClassification
BertForSequenceClassification is een BERT-model met boven op de uiteindelijke verborgen toestand van de [CLS]-token een lineaire classificatie-head. Dit is de standaardklasse van Hugging Face voor sentimentanalyse, onderwerpclassificatie en elke taak waarbij één label aan een volledige tekst wordt toegekend. De head wordt willekeurig geïnitialiseerd en tijdens fine-tuning samen met de BERT-backbone getraind.
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)De IMDB-gegevensverzameling laden
De IMDB-gegevensverzameling bevat 50.000 filmrecensies met het label positief (1) of negatief (0). We gebruiken de bibliotheek datasets van Hugging Face om deze te downloaden en op te splitsen. Het gegevensverzamelingsobject gedraagt zich als een woordenboek met lijsten en kan worden doorlopen met een tokenisatiefunctie. We gebruiken de train/test-verdeling van 25.000/25.000 die door de oorspronkelijke auteurs van de gegevensverzameling wordt aangeboden.
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'])PyTorch-DataLoaders maken
Wikkel de Hugging Face-gegevensverzameling na de tokenisatie in PyTorch-DataLoader-objecten. De batch_size bepaalt hoeveel voorbeelden het model per voorwaartse doorgang verwerkt; 16 of 32 is gebruikelijk voor BERT vanwege beperkingen van het GPU-geheugen. Schud de trainingsset bij elke epoch, zodat het model niet overfit op de volgorde van de voorbeelden, maar houd de validatieset vast voor reproduceerbare evaluatie.
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))De optimizer instellen
Voor het finetunen van BERT gebruik je de optimizer AdamW met een kleine learning rate (doorgaans van 2e-5 tot 5e-5). Een grote learning rate vernietigt de vooraf getrainde representaties (catastrofaal vergeten). Weight decay (L2-regularisatie) wordt toegepast op parameters die geen bias zijn om overfitting te verminderen. De functie get_linear_schedule_with_warmup van Hugging Face wordt vaak gebruikt om de LR gedurende de eerste 10% van de stappen geleidelijk te verhogen en daarna lineair af te bouwen.
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
)De trainingslus voor finetuning
De PyTorch-trainingslus voor het finetunen van BERT volgt het standaardpatroon: loop door de batches, bereken de forward-pass, haal de loss uit de modeluitvoer (BertForSequenceClassification retourneert automatisch een loss wanneer je labels doorgeeft), roep loss.backward() aan, begrens de gradients om explosies te voorkomen en voer vervolgens een stap uit met de optimizer en scheduler. BERT gedurende 2 epochs trainen op IMDB levert doorgaans een nauwkeurigheid van ongeveer 92% op.
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}')Evalueren op de validatieset
Roep tijdens de evaluatie model.eval() aan om dropout uit te schakelen en gebruik torch.no_grad() om het berekenen van gradients over te slaan. Dat bespaart geheugen en versnelt inference. Haal de logits uit de modeluitvoer (ruwe scores vóór softmax), pas argmax toe om de indices van de voorspelde klassen te krijgen en vergelijk deze met de werkelijke labels om de nauwkeurigheid te berekenen.
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))Het gefinetunede model opslaan
Sla het model en de tokenizer na het finetunen samen op, zodat je ze voor inference opnieuw kunt laden zonder opnieuw te trainen. model.save_pretrained(path) slaat de modelgewichten en configuratie op; tokenizer.save_pretrained(path) slaat de woordenschat en tokenisatie-instellingen op. Laad ze opnieuw met from_pretrained(path) in elke nieuwe Python-sessie.
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)De Trainer-API gebruiken
De klasse Trainer van Hugging Face kapselt de trainingslus, evaluatie, het maken van checkpoints en logging in één high-level API. Definieer een object van TrainingArguments met de learning rate, batchgrootte en het aantal epochs en roep vervolgens trainer.train() aan. De Trainer handelt gradient clipping, LR-planning en training met gemengde precisie automatisch af, waardoor je aanzienlijk minder standaardcode nodig hebt.
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()Training monitoren met TensorBoard
Geef report_to='tensorboard' door in TrainingArguments om loss en metrieken automatisch naar TensorBoard te loggen. Start TensorBoard met tensorboard --logdir ./bert_trainer/runs in een terminal om realtime-losscurves, learning-rateplanningen en evaluatiemetrieken te bekijken. Door de trainingsloss met de validatieloss te vergelijken, kun je overfitting vroeg detecteren en de training op de juiste epoch stoppen.
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/runsBepalen hoeveel lagen je bevriest
Soms is de dataset te klein om alle 12 BERT-lagen te finetunen zonder overfitting. Een veelgebruikte strategie is om de onderste lagen te bevriezen (die algemene taalkundige kenmerken leren) en alleen de bovenste lagen bij te werken (die taakspecifieke kenmerken leren). Bevries lagen door requires_grad=False in te stellen voor geselecteerde parametergroepen. Houd de validatienauwkeurigheid in de gaten om voor jouw datasetgrootte de optimale bevriezingsdiepte te kiezen.
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:,}')Korte controle
Test je begrip van de concepten uit deze les over Machine Learning met Python.
Samenvatting van de les
In deze les heb je geleerd dat BertForSequenceClassification een lineaire kop op [CLS] toevoegt voor classificatietaken, dat finetuning AdamW met een zeer kleine learning rate gebruikt om catastrofaal vergeten te voorkomen en dat de Hugging Face Trainer-API de trainingslus vereenvoudigt met ingebouwde evaluatie en het maken van checkpoints. Hierna bekijken we hoe je voorspellingen uit logits haalt en het gefinetunede model evalueert met nauwkeurigheid en F1.
Leer Python met een AI-tutor — gratis
Schrijf echte code en voer die uit in je browser, krijg direct hulp van een AI-tutor die 24/7 beschikbaar is en ga verder waar je gebleven bent op het web of in de app.
- Cursussen
- 30
- Lessen
- 120
Veelgestelde vragen
Is de les “BertForSequenceClassification fine-tunen” gratis?
Ja — de volledige tekst van “BertForSequenceClassification fine-tunen” kun je hier gratis op het web lezen. Als je interactief wilt oefenen met een ingebouwde code-editor en een AI-begeleider die 24/7 beschikbaar is, en de rest van de cursus Machine Learning Academy wilt ontgrendelen, kun je upgraden naar CoddyKit PRO. De cursus Machine Learning Academy bevat in totaal 4 lessen.
Wat leer ik in “BertForSequenceClassification fine-tunen”?
Cursisten laden een voorgetraind BERT-checkpoint, voegen een classificatiekop toe, maken een PyTorch DataLoader en fine-tunen twee epochs lang op een IMDB-dataset. Je oefent met Machine Learning Academy door code rechtstreeks in de browser uit te voeren. Een AI-begeleider die 24/7 beschikbaar is beantwoordt je vragen terwijl je de les doorwerkt.
Heb ik ervaring nodig om met Machine Learning Academy te beginnen?
Ervaring vooraf is niet nodig. Machine Learning Academy op CoddyKit is opgebouwd voor beginners tot gevorderden, zodat je hier of bij het begin kunt starten en in je eigen tempo kunt leren. Dit is les 3 van 4.
Hoe lang duurt de les “BertForSequenceClassification fine-tunen”?
De meeste lessen van CoddyKit duren ongeveer 5–10 minuten. Elke les is kort en interactief, zodat je gestaag vooruitgaat en op het web en in de app precies verdergaat waar je was gebleven.
Kan ik code schrijven en uitvoeren in deze les over Machine Learning Academy?
Ja. Elke les over Machine Learning Academy bevat een ingebouwde code-editor, zodat je rechtstreeks in je browser echte code kunt schrijven en uitvoeren en direct feedback van AI krijgt — lokale installatie is niet nodig.
Alle lessen in deze cursus
- Transformerarchitectuur: attention, tokens en context
- Hugging Face-tokenizers: tekst coderen voor BERT
- BertForSequenceClassification fine-tunen
- Evaluatie en inferentie: van logits naar voorspelde labels