Belajar ML Engineer - Transformers & LLM Fundamentals

#Pendahuluan

Setelah di episode 12 kalian menguasai training loop PyTorch, sekarang kita naik satu level yang paling relevan dengan industri 2026: model transformer dan LLM. Hampir semua produk AI modern — chatbot, summarization, code assistant, RAG — dibangun di atas arsitektur ini. Sebagai MLE, kalian tidak perlu membangun transformer dari nol, tetapi wajib memahami: mengapa ia bekerja, bagaimana Hugging Face menyeragamkan aksesnya, dan bagaimana fine-tuning dasar dilakukan.

Episode ini menjembatani pengetahuan training loop kalian dengan ekosistem LLM. Semua skill yang sudah dipelajari — evaluasi, tracking, versioning, serving — tetap berlaku, hanya dengan komponen baru: tokenizer, model, dan dataset yang jauh lebih besar.

#Arsitektur Transformer: Attention Menyatukan Konteks

Transformer (diperkenalkan lewat paper "Attention Is All You Need", 2017) mengatasi kelemahan arsitektur sebelumnya: RNN memproses kata berurutan sehingga lambat dan mudah kehilangan konteks jauh. Transformer memproses semua token secara paralel dan memakai self-attention untuk menghitung hubungan antar-token.

Konsep kunci self-attention: setiap token membuat tiga vektor — Query (apa yang dicari), Key (identitas token), Value (isi token). Skor attention = kecocokan Query terhadap Key, lalu bobot dipakai untuk mengambil Value. Dalam satu kalimat, "bunga" akan memberi attention tinggi pada "menyirami" di kalimat "Andi menyirami bunga".

Dua varian yang menentukan arsitektur model:

Model yang kita pakai sehari-hari (ChatGPT, Claude, dsb) hampir semuanya decoder-only — memprediksi token berikutnya satu per satu.

#Tokenizer: Pintu Masuk Teks

Model tidak membaca teks; ia membaca token — potongan kata/karakter yang di-encode menjadi integer. Tokenizer yang sama harus dipakai saat training dan inference (satu keluarga model = satu tokenizer):

from transformers import AutoTokenizer
 
tokenizer = AutoTokenizer.from_pretrained("Qwen/Qwen2.5-0.5B-Instruct")
tokens = tokenizer.encode("Belajar ML Engineer itu seru")
print(tokens)
print(tokenizer.decode(tokens))

Perhatikan bahwa 1 kata ≠ 1 token: kata umum menjadi 1 token, kata langka dipecah menjadi beberapa. Konteks model (misal "8K", "128K tokens") diukur dalam token, bukan kata — dan token juga yang menentukan context window yang akan menjadi kunci saat kita bahas RAG di episode 16.

#Hugging Face: Satu API untuk Semua Model

Hugging Face menyeragamkan akses ke ribuan model lewat API konsisten. pipeline adalah cara tercepat mencoba:

from transformers import pipeline
 
pipe = pipeline("text-generation", model="Qwen/Qwen2.5-0.5B-Instruct")
print(pipe("Teknologi AI di 2026", max_new_tokens=50)[0]["generated_text"])

Empat komponen yang akan menemani kalian terus:

#Fine-tuning Dasar dengan Hugging Face

Fine-tuning = melanjutkan training model pre-trained pada data khusus. Pendekatan paling ringan untuk memahami mekanismenya adalah dengan Trainer Hugging Face, yang membungkus training loop PyTorch yang sudah kita pelajari di episode 12:

from transformers import (
    AutoModelForSequenceClassification,
    AutoTokenizer,
    Trainer,
    TrainingArguments,
)
 
model_id = "Qwen/Qwen2.5-0.5B"
tokenizer = AutoTokenizer.from_pretrained(model_id)
model = AutoModelForSequenceClassification.from_pretrained(
    model_id, num_labels=2
)
 
def tokenize(batch):
    return tokenizer(batch["text"], truncation=True, padding=True, max_length=128)
 
dataset = dataset.map(tokenize, batched=True)
 
training_args = TrainingArguments(
    output_dir="./ft-output",
    learning_rate=2e-5,
    per_device_train_batch_size=8,
    num_train_epochs=3,
    evaluation_strategy="epoch",
    logging_steps=50,
)
 
trainer = Trainer(
    model=model,
    args=training_args,
    train_dataset=dataset["train"],
    eval_dataset=dataset["val"],
)
trainer.train()

Di sinilah semua disiplin episode 5-8 berperan: split yang benar, evaluasi terpisah, tracking dengan MLflow (via mlflow.transformers), dan versioning model.

#Kapan Fine-tune, Kapan Tidak

Keputusan penting yang membedakan MLE matang: fine-tuning bukan jawaban untuk segalanya. Keputusan ini menghemat biaya dan waktu:

Aturan emasnya: coba solusi termurah dulu — prompt engineering → RAG → fine-tune ringan → fine-tune penuh. Setiap langkah naik biaya; hanya naik saat manfaatnya terukur.

#Common Pitfalls

#Penutup

Pada episode 13 ini, kalian telah menguasai dasar LLM:

• Attention memproses semua token paralel dan menangkap konteks jauh.
• Decoder-only (GPT, Llama, Qwen) adalah arsitektur di balik model generatif.
• Tokenizer mengubah teks → token; satu keluarga model = satu tokenizer.
• Hugging Face menyeragamkan model, dataset, dan pipeline.
• Fine-tuning dasar dengan Trainer; dan keputusan "kapan fine-tune" yang hemat biaya.

Di episode 14 selanjutnya kita akan membahas Efficient Fine-tuning (LoRA/QLoRA) — parameter-efficient fine-tuning yang hanya melatih sebagian kecil parameter, kuantisasi untuk hemat memori, serta gambaran RLHF dan DPO untuk menyelaraskan model. Sampai jumpa di episode 14!