Kapan Menggunakan Deep Learning

Enam chapter sebelumnya membangun jaringan saraf lengkap dari nol: neuron, aktivasi, backpropagation terverifikasi, optimizer dengan momentum, hingga regularisasi. Mesinnya kini siap dipakai — tetapi justru karena sudah siap, pertanyaan terakhir Section ini menjadi pertanyaan paling mahal: haruskah dipakai? Deep learning unggul pada gambar, teks, dan audio, tetapi pada data tabular berukuran wajar gradient boosting dan random forest dari Section Ensemble Learning masih sangat sulit dikalahkan, dengan biaya pengembangan yang jauh lebih rendah. Chapter penutup ini merangkum pertukaran tersebut menjadi kerangka keputusan yang bisa dipertanggungjawabkan di depan tim maupun manajemen, lalu mengujinya dengan perbandingan jujur tiga model pada data tabular yang sama.

Empat Sumbu Keputusan #

Keputusan memilih deep learning hampir selalu bisa diurai menjadi empat sumbu berikut.

Ukuran dan jenis data. Data tabular di bawah sekitar 100 ribu baris adalah wilayah kandang tree ensemble; gradient boosting menang tanpa perlu penskalaan fitur dan tahan campuran fitur numerik-kategorikal. Deep learning mulai menunjukkan keunggulan ketika data berbentuk piksel, sinyal, atau urutan kata — jenis data yang strukturnya bertingkat dan mustahil dirancang fiturnya secara manual, sebagaimana dibahas pada Chapter Dari Machine Learning ke Deep Learning. Semakin besar dan berhiyerarki datanya, semakin kuat kasusnya untuk kedalaman.

Anggaran komputasi. Melatih jaringan besar membutuhkan GPU dan waktu eksperimen yang panjang; random forest dan gradient boosting berlatih dalam hitungan detik hingga menit pada data berukuran sama. Anggaran inferensi juga ikut dihitung: model yang harus merespons dalam milidetik di perangkat terbatas sering lebih baik memakai model kecil hasil distilling atau model klasik.

Kebutuhan interpretasi. Koefisien regresi logistik bisa dibaca langsung; tree ensemble dibantu SHAP dan permutation importance dari Section Interpretabilitas dan Explainable AI (Chapter Konsep Interpretabilitas). Jaringan bersimbusi ribuan parameter jauh lebih sulit ditafsir, dan penjelasan pasca-hoc untuk jaringan dalam masih lebih rapuh. Ketika regulator atau tim hukum menuntut penjelasan per keputusan, model sederhana sering satu-satunya pilihan yang bisa diterima.

Biaya pemeliharaan. Model yang masuk produksi harus dipantau: data berubah (drift), akurasinya melorot, model perlu dilatih ulang. Section Deployment dan Operasional membahas rantai ini tuntas; cukup dikatakan di sini bahwa pipeline deep learning menambah titik kegagalan baru — dependensi framework yang berubah cepat, kebutuhan hardware khusus, dan hyperparameter yang harus disetel ulang tiap pelatihan. Biaya ini nyata meski jarang muncul di diagram presentasi.

Prinsip Mulai Sederhana #

Aturan kerja paling hemat anggaran di industri: baseline dulu, selalu. Mulai dari model paling sederhana yang masuk akal — aturan ambang, regresi linier dari Chapter Regresi Linier Sederhana, atau DummyClassifier sebagai lantai — lalu naik bertahap: model linier, tree ensemble, baru pertimbangkan jaringan saraf jika sisa galatnya benar-benar membutuhkan representasi terpelajari. Setiap kenaikan kompleksitas harus membawa perbaikan yang jelas pada metrik validasi; jika tidak, kompleksitas tersebut hanya memindahkan biaya ke masa depan. Prinsip ini juga yang kita jalankan sepanjang Section evaluasi: skor model rumit selalu dibandingkan terhadap pembanding sederhana, bukan terhadap nol.

Demo: Tiga Model pada Data Tabular yang Sama #

Skenario ujinya sengaja dibuat menyerupai tabel bisnis sehari-hari: 600 baris, 20 fitur (hanya 6 informatif, 10 redundan), dan 5% label yang salah — kekotoran yang lazim pada data berlabel manual. Tiga model berbeda kompleksitas dilatih pada pemisahan data identik, semuanya random_state=42:

# Perbandingan jujur pada data tabular sintetis: regresi logistik vs random
# forest vs MLP, semuanya random_state=42 pada data dan pemisahan identik.
# Lima persen label sengaja diacak (flip_y) meniru label kotor dunia nyata.

from sklearn.datasets import make_classification
from sklearn.ensemble import RandomForestClassifier
from sklearn.linear_model import LogisticRegression
from sklearn.metrics import accuracy_score
from sklearn.model_selection import train_test_split
from sklearn.neural_network import MLPClassifier
from sklearn.pipeline import make_pipeline
from sklearn.preprocessing import StandardScaler

# Data tabular sintetis: 600 baris, 20 fitur (6 informatif, 10 redundan),
# 5% label diacak sehingga akurasi sempurna mustahil dicapai.
X, y = make_classification(
    n_samples=600, n_features=20, n_informative=6, n_redundant=10,
    flip_y=0.05, random_state=42,
)
X_latih, X_uji, y_latih, y_uji = train_test_split(
    X, y, test_size=0.3, random_state=42, stratify=y
)

# Rantai scaler + model di sini dirangkai make_pipeline; section berikutnya
# (Pipeline dan Produktivitas) merapikan pola ini menjadi objek Pipeline.
model_daftar = (
    ("LogisticRegression", make_pipeline(
        StandardScaler(), LogisticRegression(max_iter=2000, random_state=42))),
    ("RandomForest (200 pohon)", RandomForestClassifier(
        n_estimators=200, random_state=42, n_jobs=1)),
    ("MLP (64, 32)", make_pipeline(
        StandardScaler(),
        MLPClassifier(hidden_layer_sizes=(64, 32), max_iter=800,
                      random_state=42))),
)


def jumlah_parameter(model):
    """Kompleksitas model: koefisien + intersep untuk model linier dan MLP."""
    if hasattr(model, "coefs_"):
        return sum(koef.size + intersep.size
                   for koef, intersep in zip(model.coefs_, model.intercepts_))
    if hasattr(model, "coef_"):
        return model.coef_.size + model.intercept_.size
    return 0


print(f"{'model':<26}{'akurasi latih':>14}{'akurasi uji':>13}{'kompleksitas':>16}")
for nama, model in model_daftar:
    model.fit(X_latih, y_latih)
    ak_latih = accuracy_score(y_latih, model.predict(X_latih))
    ak_uji = accuracy_score(y_uji, model.predict(X_uji))
    if nama.startswith("RandomForest"):
        simpul = sum(pohon.tree_.node_count for pohon in model.estimators_)
        kompleksitas = f"{simpul} simpul"
    else:
        kompleksitas = f"{jumlah_parameter(model.steps[-1][1])} parameter"
    print(f"{nama:<26}{ak_latih:>14.4f}{ak_uji:>13.4f}{kompleksitas:>16}")

print("\nlabel 5% diacak -> plafon akurasi jujur sekitar 0.95")
print("akurasi latih 1.0000 = model ikut menghafal label yang salah")

Output yang Dihasilkan:

model                      akurasi latih  akurasi uji    kompleksitas
LogisticRegression                0.8095       0.8611    21 parameter
RandomForest (200 pohon)          1.0000       0.9222    16648 simpul
MLP (64, 32)                      1.0000       0.9056  3457 parameter

label 5% diacak -> plafon akurasi jujur sekitar 0.95
akurasi latih 1.0000 = model ikut menghafal label yang salah

Bacaan jujur atas tabel tersebut:

1. RandomForest menang: akurasi uji 0,9222 melampaui MLP (0,9056) yang justru membawa 3.457 parameter dan membutuhkan penskalaan fitur. Pada data tabular 600 baris ini, prediksi Section Ensemble Learning terbukti: struktur tabel tidak membutuhkan representasi terpelajari.
2. MLP dan RandomForest sama-sama mencapai akurasi latih 1,0000 — padahal 5% label latih memang salah. Kedua model berkapasitas besar menghafal label yang salah itu; selisih mereka murni di kemampuan generalisasi. Inilah kembali pelajaran overfitting Chapter Regularisasi Neural Network, kini pada data sungguhan pola.
3. LogisticRegression underfitting dengan anggun: akurasi latih dan uji hampir sama (0,8095 dan 0,8611) dengan hanya 21 parameter. Model linier ini kalah 6 poin dari random forest, tetapi hampir bebas biaya — baseline yang layak sebelum investasi apa pun.
4. Baris 24–25 (komentar): rantai StandardScaler + model yang dirangkai make_pipeline adalah pola sementara; kebocoran data preprocessing dan kerapian alur kerja akan diselesaikan Section berikutnya.

Rangkuman Skenario #

Kerangka ini menutup Section Pengantar Deep Learning dengan posisi yang seimbang: jaringan saraf bukan puncak yang otomatis lebih tinggi, melainkan satu alat dalam kotak — terkuat pada data bertingkat dan berskala besar, boros di luar wilayah itu. Keputusan akhirnya tidak diambil oleh framework favorit, tetapi oleh data, anggaran, dan kebutuhan penjelasan di lapangan.

Setelah model dipilih, pekerjaan justru baru dimulai: alur preprocessing dan pelatihan yang selama ini kita rangkai ad-hoc per contoh perlu dirapikan menjadi satu rantai yang aman dari kebocoran data dan siap diuji ulang kapan pun. Konsep pipeline inilah yang akan kita bangun secara sistematis mulai dari Chapter Pipeline scikit-learn: Dasar, pembuka Section Pipeline dan Produktivitas.

Referensi Resmi #

• MLPClassifier — scikit-learn API — referensi resmi model MLP beserta seluruh parameternya.
• Ensemble methods — scikit-learn User Guide — panduan resmi random forest dan keluarganya.
• make_classification — scikit-learn API — dokumentasi generator data sintetis termasuk flip_y.