Setelah episode kemarin bicara data dan fitur, sekarang giliran pertanyaan yang dulu bikin saya berhenti membaca tutorial: sebenarnya “model” itu apa? Jawabannya ternyata jauh lebih sederhana dan lebih indah daripada yang saya bayangkan — terutama kalau kita memandangnya sebagai programmer.
Model = fungsi dengan parameter
Definisi teknisnya: model AI adalah fungsi matematis yang memetakan input menjadi output. Titik. Tidak ada sihir. Model prediksi harga rumah adalah fungsi yang menerima (luas, kamar, umur bangunan) dan mengembalikan angka. Model klasifikasi email adalah fungsi yang menerima teks dan mengembalikan probabilitas spam.
Beda model linear paling sederhana dengan aplikasi raksasa semacam chatbot bukan pada jenisnya — sama-sama fungsi — melainkan pada bentuk dan jumlah parameternya. Regresi linear punya beberapa parameter; model bahasa besar punya miliaran. Prinsip dasarnya identik.
Analogi programmer favorit saya: model itu seperti interface, dan tiap arsitektur adalah implementasinya. Yang membedakan satu implementasi dengan lainnya adalah parameter — variabel-variabel internal yang nilainya menentukan perilaku fungsi.
Parameter dan bobot
Ambil contoh regresi linear untuk harga rumah:
harga = w1 * luas + w2 * kamar + w3 * umur + b
w1, w2, w3 disebut bobot (weight) — angka yang menentukan seberapa besar tiap fitur memengaruhi hasil. b adalah bias, nilai dasar saat semua fitur nol. Bobot + bias = parameter. Sebelum training, isinya angka acak sehingga model menghasilkan omong kosong. Setelah training, bobot “menyimpan” pola dari data.
Cara pandang ini menjelaskan banyak hal yang dulu membingungkan:
- “Melatih model” = mencari nilai parameter terbaik, bukan menambah baris kode.
- “Model belajar” = parameter bergeser sedikit demi sedikit ke arah yang mengurangi kesalahan.
- File
.pklatau.safetensorsyang kita unduh = snapshot nilai parameter, plus definisi bentuk fungsinya. - Dua model dengan arsitektur sama tapi parameter beda = dua program yang perilakunya beda total.
Mencicipi langsung dengan scikit-learn
Supaya tidak abstrak, saya coba lihat parameter sebuah model sungguhan. Kode di bawah melatih regresi linear mini lalu mencetak bobotnya:
from sklearn.linear_model import LinearRegression X = [[50, 2], [80, 3], [120, 4], [60, 2]] # [luas_m2, kamar] y = [500, 750, 1100, 590] # harga dalam juta model = LinearRegression() model.fit(X, y) print(model.coef_) # bobot per fitur print(model.intercept_) # bias print(model.predict([[70, 3]]))
Yang saya suka dari eksperimen kecil ini: setelah fit(), atribut coef_ dan intercept_ persis seperti rumus di atas. Bisa dibaca sebagai “seberapa penting luas vs jumlah kamar” menurut model. Untuk model yang lebih kompleks, parameternya jutaan dan tidak bisa lagi ditafsirkan satu-satu — tapi strukturnya tetap sama: sekumpulan angka.
Melihat parameter model PyTorch
Penasaran berapa parameter di model yang lebih nyata? PyTorch menyediakan named_parameters() dan numel() untuk menghitung jumlahnya. Ini kode yang saya jalankan untuk memeriksa model sederhana:
import torch
import torch.nn as nn
model = nn.Sequential(
nn.Linear(10, 64),
nn.ReLU(),
nn.Linear(64, 1)
)
# Hitung total parameter
total = sum(p.numel() for p in model.parameters())
print(f"Total parameter: {total:,}") # 769
# Lihat nama + bentuk tiap parameter
for name, param in model.named_parameters():
print(f"{name:20s} {str(list(param.shape)):15s} {param.numel():,}")Hasilnya: model kecil dengan dua layer punya 769 parameter. Sekarang bayangkan GPT-2 yang punya 1,5 miliar, atau GPT-3 yang 175 miliar. Sama-sama sekumpulan angka — bedanya hanya pada jumlah dan strukturnya.
Perbandingan model kecil vs besar
Untuk memperjelas spektrum ini, saya susun tabel perbandingan dari berbagai jenis model:
| Model | Jumlah Parameter | Contoh Penggunaan |
|---|---|---|
| Linear Regression | 2 – 100 | Prediksi harga, penjualan |
| Decision Tree (scikit-learn) | Manual (kedalaman) | Klasifikasi tabular |
| CNN kecil (MNIST) | ~60 ribu | Pengenalan digit tulisan tangan |
| ResNet-50 | ~25 juta | Klasifikasi gambar ImageNet |
| BERT-base | ~110 juta | Pemahaman teks, QA |
| GPT-2 | ~1,5 miliar | Generasi teks |
| GPT-3 | ~175 miliar | Generasi teks serbaguna |
Yang menarik: dari linear regression ke GPT-3, semua tetap fungsi dengan parameter. Bedanya hanya pada kompleksitas fungsi dan jumlah “tuning knob” yang harus diatur. Ini seperti perbandingan antara kalkulator sederhana dan superkomputer — keduanya menghitung, tapi dengan kapasitas yang sangat berbeda.
Inference vs Training: kapan model “berpikir”?
Ini kebingungan yang pernah saya alami. Banyak yang bilang “AI sedang belajar” padahal sebenarnya model sedang melakukan inference — proses menjalankan fungsi dengan parameter yang sudah tetap. Berikut perbedaannya:
- Training: parameter diupdate berulang kali berdasarkan data. Bobot bergeser kecil demi kecil sampai fungsi menghasilkan output yang mendekati jawaban benar. Butuh waktu jam sampai minggu.
- Inference: parameter sudah tetap, model tinggal menjalankan fungsi: input masuk, output keluar. Tidak ada “belajar”, hanya menghitung. Butuh milidetik sampai detik.
Analogi sederhana: training seperti proses tuning gitar — menyetel tiap senar sampai menghasilkan nada yang tepat. Inference seperti memainkan lagu setelah senar sudah terpasang. Momen saat saya pahami ini, banyak yang jadi clear — model tidak “berpikir” atau “merasa” saat menjawab pertanyaan saya. Dia hanya menjalankan fungsi matematika yang parameternya sudah final.
Model capacity: underfit dan overfit
Kapasitas model — yaitu seberapa kompleks fungsi yang bisa diwakilinya — punya batas ideal. Terlalu sederhana = underfit, terlalu kompleks = overfit.
Underfit terjadi ketika model terlalu kecil untuk menangkap pola dalam data. Misalnya pakai regresi linear untuk data yang sebenarnya berbentuk kurva — model akan selalu meleset karena kapasitasnya tidak cukup. Overfit kebalikannya: model terlalu besar sehingga menghafal data training termasuk noise-nya, tapi gagal pada data baru. Bayangkan rumus yang persis melewati setiap titik data tapi memberikan prediksi aneh untuk titik di luar dataset.
Bagi programmer, analoginya seperti ini: underfit = kode yang terlalu generik tanpa menangkap edge case penting. Overfit = kode yang hardcode setiap input spesifik sampai tidak bisa handle input baru. Sweet spot-nya adalah model yang cukup kompleks untuk menangkap pola utama, tapi cukup sederhana untuk generalisasi.
Pre-trained vs from scratch: kapan pakai mana?
Pertanyaan praktis yang muncul begitu paham parameter: apakah harus melatih dari nol setiap kali? Jawabannya hampir selalu tidak.
- From scratch: melatih dari parameter acak. Dibutuhkan data dalam jumlah besar, waktu lama, dan komputasi mahal. Cocoknya untuk riset atau domain sangat spesifik yang belum punya model publik.
- Pre-trained: mengambil model yang sudah dilatih di dataset besar (misalnya Wikipedia + internet) lalu melakukan fine-tuning pada data spesifik kita. Parameter awal sudah “pintar”, kita tinggal menyesuaikan. Ini pendekatan paling umum saat ini.
Kembali ke analogi parameter: pre-trained = mulai dengan pengaturan pabrik yang sudah bagus, lalu sedikit tuning untuk kebutuhan khusus. From scratch = mulai dari nol total. Untuk sebagian besar kebutuhan developer, pre-trained jauh lebih praktis dan efisien.
Hyperparameter: pengaturan di luar model
Jangan tertukar dengan parameter. Hyperparameter adalah konfigurasi yang kita tentukan sebelum training: jumlah tetangga di KNN, kedalaman decision tree, learning rate. Analoginya: parameter adalah isi variabel saat runtime, hyperparameter adalah setting build-time. Parameter dipelajari mesin dari data; hyperparameter kita pilih sendiri (dan episode mendatang akan bahas cara memilihnya secara sistematis).
| Istilah | Siapa yang menentukan | Contoh |
|---|---|---|
| Parameter | Proses training (otomatis) | Bobot, bias |
| Hyperparameter | Kita, sebelum training | Learning rate, kedalaman tree |
Catatan untuk diri sendiri
Mental model “model = fungsi berparameter” adalah investasi konsep paling mahal sejauh seri ini. Saya ingat tepat momen saat konsep ini benar-benar “klik”: saya sedang debug model sklearn yang hasil prediksinya aneh, lalu saya sadar — cukup print koefisiennya, dan masalahnya langsung terlihat: satu fitur punya bobot yang terlalu dominan. Sejak saat itu, setiap kali mendengar “model AI”, saya langsung menerjemahkannya dalam kepala sebagai “fungsi dengan parameter-parameter tertentu” — dan semuanya jadi lebih mudah dipahami.
Semua istilah menakutkan di episode-episode selanjutnya — loss function, gradient descent, overfitting — akan terasa natural begitu kerangka ini melekat. Kalau ada satu hal yang saya sarankan dari catatan ini: jangan hafalkan istilahnya, gambar dulu fungsinya di kepala. Bayangkan model sebagai kalkulator raksasa yang parameter-parameter di dalamnya perlu disetel satu per satu sampai menghasilkan jawaban yang tepat.
Komentar Terbaru