Memahami BERT

Salah satu tantangan dari language model adalah kurangnya data latih. Karenanya dibuatlah model base Language Model seperti BERT, GPT dll. Researcher dari google memperkenalkan BERT di tahun 2019 papernya bisa klik aja. Lalu Bagaimana BERT bisa “paham” tentang kalimat dan kata.

Arsitektur BERT

BERT menggunakan arsitektur Transformer, yang memanfaatkan mekanisme perhatian (attention mechanism) untuk mempelajari hubungan kontekstual antara kata-kata (atau sub-kata) dalam teks. Berbeda dengan model sebelumnya yang membaca teks secara berurutan (kiri-ke-kanan atau kanan-ke-kiri), BERT membaca seluruh urutan kata sekaligus. Ini membuat BERT non-direksional, memungkinkan model untuk memahami konteks kata berdasarkan semua lingkungannya, baik di sebelah kiri maupun kanan kata tersebut

Anggap kita punya 2 kalimat seperti ini :

Saya yakin kamu bisa  
Bisa itu telah menyebar ke seluruh tubuh pasien

Dalam kalimat pertama, kata “bisa” merujuk pada kemampuan atau tindakan seseorang, sedangkan dalam kalimat kedua, “bisa” merujuk pada racun ular. BERT memahami perbedaan ini karena menganalisis konteks keseluruhan kalimat, bukan hanya kata-kata sebelum atau sesudah kata target. Untuk mencapai pemahaman konteks yang utuh, BERT menggunakan dua metode utama: Masked Language Modeling dan Next Sentence Prediction.

Masked Language Modeling

Biasanya, model bahasa hanya dapat dilatih dalam satu arah tertentu, baik dari kiri ke kanan atau dari kanan ke kiri. Namun, BERT mengatasi masalah ini dengan menggunakan teknik yang disebut Masked Language Modeling (MLM).

Pada pelatihan MLM, sejumlah kata dalam sebuah kalimat disembunyikan (atau “dimasking”) secara acak, dan model ditugaskan untuk memprediksi kata-kata yang tersembunyi tersebut berdasarkan konteks yang diberikan oleh kata-kata di sekitarnya. Secara khusus, BERT secara acak menyembunyikan 15% dari semua token WordPiece dalam setiap urutan saat proses pelatihan.

Dengan pendekatan ini, BERT dapat secara efektif mempelajari konteks dua arah, sehingga mampu memahami hubungan antara kata-kata dari kedua arah, yang meningkatkan kemampuannya dalam menangkap makna keseluruhan kalimat.

Next Sentence Prediction (NSP)

Banyak task seperti Question and Answer/QA) serta (Natural Language Inference/NLI), bergantung pada pemahaman hubungan antara dua kalimat. Hubungan ini tidak dapat ditangkap secara langsung melalui pelatihan language modeling biasa.

Dalam proses pelatihan BERT, model menerima sepasang kalimat sebagai masukan dan dilatih untuk memprediksi apakah kalimat kedua adalah kalimat yang mengikuti kalimat pertama. Proses ini merupakan klasifikasi biner dengan dua label: IsNext (adalah berikut) dan NotNext (tidak berikut).

Saat memilih kalimat A dan B untuk setiap contoh pre-training, 50% dari waktu kalimat B adalah kalimat nyata yang mengikuti kalimat A dan diberi label sebagai IsNext. Sedangkan 50% dari waktu kalimat B adalah kalimat acak dari korpus yang diberi label NotNext.

atau NSP bisa kita anggap MLM versi kalimat

Fine-Tuning with BERT

Setelah kita memiliki model BERT yang telah dilatih sebelumnya (pre-trained model), untuk membuatnya dapat melakukan tugas tertentu seperti penjawaban pertanyaan (question answering) atau klasifikasi teks, kita cukup menambahkan lapisan tambahan. Berikut adalah langkah-langkahnya:

1. Untuk Tugas Klasifikasi Teks:
— Tambahkan Lapisan Klasifikasi: Di atas output model BERT, kita menambahkan lapisan Fully Connected Network (FFN) atau lapisan klasifikasi. Output dari token [CLS] akan digunakan sebagai representasi teks secara keseluruhan, dan lapisan ini akan memproses informasi tersebut untuk memberikan prediksi kategori yang diinginkan.

2. Untuk Tugas Penjawaban Pertanyaan:
— Tambahkan Dua Vektor Output: Pada model BERT, kita perlu menambahkan dua vektor output yang bertanggung jawab untuk menentukan posisi awal dan akhir dari jawaban dalam teks. Model akan menghasilkan dua output: satu untuk prediksi posisi awal jawaban dan satu lagi untuk posisi akhir jawaban.

Dengan menambahkan lapisan-lapisan ini, model BERT yang telah dilatih sebelumnya dapat dengan cepat disesuaikan dan dioptimalkan untuk menyelesaikan tugas spesifik sesuai kebutuhan kita. Proses ini memungkinkan kita untuk memanfaatkan kekuatan BERT dalam memahami konteks bahasa tanpa perlu melatih model dari awal.

Lalu Bagaimana menggunakan BERT di Python, Biasanya kita menggunakan library nya huggingface Transformers.

pip install transformers torch

Ini contoh kode python kalau mau menggunakan BERT untuk klasifikasi Teks. sebenarnya kan BERT didesign untuk MAsked Language modeling dan next prediction sentence tapi bisa ditambahkan layer terakhir untuk klasifikasi teks. ini prosesnya

from transformers import BertTokenizer, BertForSequenceClassification
from torch.utils.data import DataLoader
from torch.optim import Adam
import torch

# Inisialisasi tokenizer dan model BERT untuk klasifikasi
tokenizer = BertTokenizer.from_pretrained('bert-base-uncased')
# Misalnya untuk 2 kelas (positif/negatif) / penambahan layer otomatis 
#ketika menggunakan BertForSequenceClassification
model = BertForSequenceClassification.from_pretrained('bert-base-uncased', num_labels=2)  

# Contoh data teks
texts = ["I love this!", "I hate this!"]
labels = [1, 0]  # Label 1 untuk positif, 0 untuk negatif

# Tokenisasi teks
inputs = tokenizer(texts, padding=True, truncation=True, return_tensors='pt')

# Tentukan DataLoader untuk batch
data = torch.utils.data.TensorDataset(inputs['input_ids'], torch.tensor(labels))
dataloader = DataLoader(data, batch_size=2)

# Optimizer
optimizer = Adam(model.parameters(), lr=1e-5)

# Latih model (satu langkah contoh)
model.train()
for batch in dataloader:
    input_ids, attention_masks, label_ids = batch
    optimizer.zero_grad()
    outputs = model(input_ids=input_ids, labels=label_ids)
    loss = outputs.loss
    print("Loss:", loss.item())
    loss.backward()
    optimizer.step()

Penambahan layer dilakukan saat kita menggunakan BertForSequenceClassification.from_pretrained(‘bert-base-uncased’, num_labels=2). Lalu gimana kalau untuk task lain

HuggingFace sudah menyediakan beberapa diantaranya

#######Contoh penggunaan Model#######

#BertForSequenceClassification
#Klasifikasi biner atau multi kelas Teks 
model = BertForSequenceClassification.from_pretrained('bert-base-uncased', num_labels=2)

#BertForTokenClassification
#Klasifikasi token (misalnya Named Entity Recognition)NER
model = BertForTokenClassification.from_pretrained('bert-base-uncased', num_labels=9)

#BertForQuestionAnswering
model = BertForQuestionAnswering.from_pretrained('bert-base-uncased')

#BertForMaskedLM
model = BertForMaskedLM.from_pretrained('bert-base-uncased')

#BertForNextSentencePrediction
model = BertForNextSentencePrediction.from_pretrained('bert-base-uncased')

#BertForPreTraining
model = BertForPreTraining.from_pretrained('bert-base-uncased')

Fine Tune BERT

import pandas as pd
# Membaca dataset dari URL CSV
df = pd.read_csv("https://raw.githubusercontent.com/laxmimerit/All-CSV-ML-Data-Files-Download/refs/heads/master/twitter_multi_class_sentiment.csv")

# Menambahkan kolom baru untuk menghitung jumlah kata per tweet
df['Words per tweet'] = df['text'].str.split().apply(len)
# Menampilkan 5 data teratas untuk memastikan kolom baru ditambahkan
df.head()

Dataset dari github dan kita perlu menambahkan kolom baru Words Per Tweet

from transformers import AutoTokenizer

model_name = 'bert-base-cased'
# Menggunakan tokenizer BERT dari model 'bert-base-cased'
tokenizer = AutoTokenizer.from_pretrained(model_name)

text = "i love this kind of situation"
# Meng-encode input teks menjadi format tensor yang dapat diterima BERT
encoded_input = tokenizer(text, return_tensors='pt')
encoded_input

• AutoTokenizer digunakan untuk memuat tokenizer dari model BERT yang sudah dilatih sebelumnya (bert-base-cased).
• tokenizer(text, return_tensors='pt') mengubah input teks menjadi format tensor (pytorch tensor, yang dibutuhkan untuk input ke model BERT).
• encoded_input adalah output yang berisi tokenisasi teks dan ID token yang sesuai, yang nantinya dapat digunakan dalam model.

from sklearn.model_selection import train_test_split

# Membagi data menjadi train (70%) dan test (30%) dengan stratifikasi untuk menjaga proporsi label yang seimbang
train, test = train_test_split(df, test_size=0.3, stratify=df['label_name'])

# Membagi data test menjadi 2 bagian: test (1/3) dan validation (2/3) dengan stratifikasi untuk menjaga proporsi label
test, validation = train_test_split(test, test_size=1/3, stratify=test['label_name'])

# Menampilkan ukuran dataset setelah pembagian
train.shape, test.shape, validation.shape

• train_test_split digunakan untuk membagi dataset menjadi data pelatihan dan pengujian.
• stratify=df['label_name'] memastikan bahwa pembagian data dilakukan dengan proporsi yang sama untuk setiap kelas yang ada di kolom label_name, yaitu memastikan distribusi kelas target yang serupa dalam dataset training, test, dan validation.
• Pembagian kedua dilakukan untuk memisahkan data test menjadi dua bagian: 1/3 untuk validation dan 2/3 untuk test.

from datasets import Dataset, DatasetDict

# Mengonversi dataframe pandas menjadi dataset Hugging Face
dataset = DatasetDict({
    'train': Dataset.from_pandas(train, preserve_index=False),
    'test': Dataset.from_pandas(test, preserve_index=False),
    'validation': Dataset.from_pandas(validation, preserve_index=False)
})

# Memeriksa contoh dataset
dataset

• HuggingFace Datasets digunakan untuk mengonversi DataFrame Pandas menjadi objek Dataset dari HuggingFace.
• Dataset.from_pandas() mengonversi DataFrame Pandas menjadi objek dataset yang kompatibel dengan framework HuggingFace, yang lebih mudah digunakan dalam pemodelan NLP dengan model-model pre-trained seperti BERT.
• preserve_index=False memastikan bahwa indeks Pandas tidak dibawa ke dalam dataset.
• Dataset yang dihasilkan dimasukkan dalam objek DatasetDict yang menyimpan data training, testing, dan validation secara terpisah.

from transformers import BertForSequenceClassification, Trainer, TrainingArguments

# Inisialisasi model BERT untuk klasifikasi
model = BertForSequenceClassification.from_pretrained('bert-base-cased', num_labels=len(df['label_name'].unique()))

# Menentukan argumen pelatihan
training_args = TrainingArguments(
    output_dir='./results',          # Direktori untuk menyimpan model dan hasil
    num_train_epochs=3,              # Jumlah epoch pelatihan
    per_device_train_batch_size=16,  # Ukuran batch per perangkat
    per_device_eval_batch_size=64,   # Ukuran batch evaluasi
    warmup_steps=500,                # Jumlah langkah untuk pemanasan
    weight_decay=0.01,               # Menggunakan pengurangan bobot
    logging_dir='./logs',            # Direktori untuk log
    logging_steps=10,
)

# Membuat trainer
trainer = Trainer(
    model=model,                         # Model yang akan dilatih
    args=training_args,                  # Argumen pelatihan
    train_dataset=dataset['train'],      # Dataset pelatihan
    eval_dataset=dataset['validation'],  # Dataset validasi
)

# Melatih model
trainer.train()

• BertForSequenceClassification digunakan untuk klasifikasi teks. Model BERT ini sudah dilatih sebelumnya, dan kita menambahkan layer klasifikasi pada bagian akhir untuk memprediksi label kelas.
• TrainingArguments digunakan untuk mendefinisikan berbagai parameter pelatihan seperti jumlah epoch, ukuran batch, dan lainnya.
• Trainer adalah kelas dari Hugging Face yang memudahkan pelatihan model dengan dataset yang sudah dipersiapkan.
• trainer.train() akan melatih model pada data yang telah disediakan.

Sebenarnya apa sih alurnya fine tune model BERT untuk klasifikasi Teks

1. Persiapan Data (pilih dataset : csv, xlsx, json, dsb)
2. Tokenisasi (Pakai AutoTokenizer utk mengubah teks jadi token)
3. Persiapan Label 
4. Split Data
5. Build Model bisa pakai (BertForSequenceClassification) 
6. Training Model
7. Evaluasi Model 
8. Hyperparameter Tuning
9. Simpan Model