GPT2

GPT-2 (Generative Pre-trained Transformer 2) adalah model deep learning yang dibangun berdasarkan arsitektur Transformer. Mari kita bahas konsep-konsep matematis yang ada di balik GPT-2.

1.1. Mekanisme Attention

Arsitektur Transformer mengandalkan self-attention untuk memproses input secara efisien. Mekanisme self-attention memungkinkan model untuk memperhatikan hubungan antar kata (atau token) dalam kalimat, memungkinkan model untuk menangkap ketergantungan jangka panjang.

Operasi matematika utama dalam self-attention adalah dot-product attention, yang dapat dijelaskan dengan rumus berikut:

Di mana:

Proses ini memungkinkan model untuk memutuskan seberapa besar perhatian yang harus diberikan pada setiap kata berdasarkan konteks kalimat.

1.2. Positional Encoding

Karena Transformer tidak memproses data secara berurutan seperti halnya RNN (Recurrent Neural Networks), positional encoding ditambahkan untuk memberi tahu model tentang urutan token dalam kalimat. Positional encoding ini umumnya menggunakan fungsi sinusoidal.

1.3. Tujuan Pemodelan Bahasa

GPT-2 dilatih menggunakan tujuan pemodelan bahasa kausal, yaitu model ini belajar memprediksi token berikutnya dalam urutan teks berdasarkan token sebelumnya. Proses pelatihan ini menggunakan cross-entropy loss, yang dinyatakan dengan rumus:

Di mana:

1.4. Layer Transformer

GPT-2 terdiri dari beberapa blok Transformer, masing-masing mengandung:

• Multi-head self-attention: Memungkinkan model untuk memberi perhatian pada bagian-bagian berbeda dari input.
• Feed-forward layers: Ini adalah lapisan fully connected yang memproses output dari attention.
• Layer normalization: Digunakan untuk menormalkan aktivasi dan meningkatkan stabilitas pelatihan.

Output dari model ini digunakan untuk memprediksi token berikutnya berdasarkan input yang ada.

2. Implementasi Praktis: Langkah-langkah Pelatihan GPT-2

Sekarang mari kita bahas implementasi praktis dari kode yang kamu tulis, dari mempersiapkan dataset hingga melatih model GPT-2.

2.1. Memuat Dataset

Kamu menggunakan library datasets dari Hugging Face untuk memuat dataset Reuters articles. Dataset ini berisi artikel berita yang akan digunakan untuk melatih model GPT-2.

from datasets import load_dataset

dataset = load_dataset("ingeniumacademy/reuters_articles")

Setelah memuat dataset, kamu membuat kolom baru yang berisi artikel lengkap, dengan menggabungkan title dan body dari setiap artikel.

def create_full_article_col(example):
    return {
        'full article': f"TITLE: {example['title']}\n\nBody: {example['body']}"
    }
dataset = dataset.map(create_full_article_col)

2.2. Tokenisasi

Sebelum memberi data ke GPT-2, kamu perlu mengonversi teks menjadi token yang dapat dipahami oleh model. Di sini, kamu menggunakan AutoTokenizer dari Hugging Face untuk memuat tokenizer yang sudah dilatih khusus untuk dataset Reuters.

tokenizer = AutoTokenizer.from_pretrained("ingeniumacademy/gpt2-reuters-tokenizer")

CONTEXT_LENGTH = 512  # panjang maksimal input
def tokenize(element):
    outputs = tokenizer(
        element["full article"], 
        truncation=True, 
        max_length=CONTEXT_LENGTH,
        return_overflowing_tokens=False)
    return outputs 

tokenize_datasets = dataset.map(
    tokenize, batched=True, remove_columns=dataset['train'].column_names
)

Langkah ini melakukan tokenisasi setiap artikel dan memangkas artikel yang lebih panjang dari panjang maksimum yang ditentukan (CONTEXT_LENGTH), memastikan bahwa model menerima urutan yang konsisten dengan panjang yang sama.

2.3. Konfigurasi Model

Sekarang kamu membuat konfigurasi untuk GPT-2 dengan mendefinisikan beberapa parameter, seperti ukuran kosakata dan panjang konteks.

from transformers import AutoConfig

config = AutoConfig.from_pretrained(
    "gpt2",
    vocab_size=len(tokenizer),  # Ukuran kosakata sesuai tokenizer
    n_ctx=CONTEXT_LENGTH,  # Panjang konteks untuk GPT-2
    bos_token_id=tokenizer.bos_token_id,
    eos_token_id=tokenizer.eos_token_id,
)

Konfigurasi ini mengatur parameter-parameter penting seperti ukuran kosakata dan panjang konteks (maksimal token yang diterima oleh model).

2.4. Membuat Model

Setelah konfigurasi siap, kamu membuat model GPT-2 berdasarkan konfigurasi tersebut.

from transformers import GPT2LMHeadModel

model = GPT2LMHeadModel(config)

Model ini menggunakan kepala Language Modeling untuk memprediksi token berikutnya, yang merupakan tujuan dari pelatihan ini.

2.5. Pengumpulan Data (Data Collator)

Untuk menangani batching dan tokenisasi selama pelatihan, kamu menggunakan DataCollatorForLanguageModeling:

from transformers import DataCollatorForLanguageModeling

tokenizer.pad_token = tokenizer.eos_token  # Menetapkan token padding sebagai token EOS
data_collator = DataCollatorForLanguageModeling(tokenizer, mlm=False)

Kamu menetapkan pad token menjadi EOS token dan mengatur mlm=False karena model ini menggunakan causal language modeling (bukan masked language modeling seperti BERT).

2.6. Melatih Model

Sekarang, kamu mengonfigurasi Trainer untuk melatih model GPT-2 pada dataset yang sudah diproses.

from transformers import Trainer, TrainingArguments

training_args = TrainingArguments(
    output_dir="./reuters-gpt2-text-gen",  # Direktori untuk menyimpan checkpoint model
    hub_model_id="ingeniumacademy/reuters-gpt2-text-gen",  # Model akan dipush ke Hugging Face Hub
    evaluation_strategy="epoch",  # Evaluasi setiap epoch
    num_train_epochs=2,  # Melatih selama 2 epoch
    learning_rate=5e-5,  # Learning rate
    fp16=True,  # Menggunakan mixed precision untuk pelatihan lebih cepat di GPU
)

trainer = Trainer(
    model=model,
    tokenizer=tokenizer,
    args=training_args,
    data_collator=data_collator,
    train_dataset=tokenize_datasets["train"],
    eval_dataset=tokenize_datasets["test"],
)

trainer.train()  # Melatih model

Dalam bagian ini:

• TrainingArguments mengonfigurasi parameter pelatihan, seperti jumlah epoch, learning rate, dan penyimpanan model.
• Trainer adalah kelas yang menangani pelatihan, batching, dan logging.

2.7. Push Model ke Hub

Setelah pelatihan selesai, kamu dapat mempush model yang sudah dilatih ke Hugging Face Hub untuk berbagi atau digunakan kembali.

trainer.push_to_hub()

2.8. Inferensi dengan Model yang Dilatih

Setelah melatih model, kamu dapat menggunakannya untuk menghasilkan teks. Kamu memuat model dan tokenizer, lalu menggunakan pipeline untuk generasi teks.

from transformers import pipeline

pipe = pipeline(
    "text-generation", model="ingeniumacademy/reuters-gpt2-text-gen"
)

Sekarang, kamu bisa menghasilkan teks dengan memberi prompt:

output = pipe("Breaking news: ")
print(output)