Machine Learning Academy · Pelajaran

Pertukaran Bias-Varians: Underfitting vs Overfitting

Peserta didik akan menggambar kurva galat pelatihan dan validasi, mengidentifikasi area underfitting dan overfitting, serta memahami konsep dekomposisi bias-varians.

Pelajaran 3 dari 413 langkah

Pertukaran Bias-Varians: Underfitting vs Overfitting adalah pelajaran Machine Learning Academy gratis di CoddyKit. Ini adalah pelajaran 3 dari 4. Kamu bisa membaca pelajaran lengkapnya di bawah secara gratis — lalu praktikkan langsung di browser dengan editor kode bawaan dan tutor AI 24/7. Ini adalah bagian dari jalur belajar Machine Learning Academy, dan progresmu tersinkronisasi di web dan aplikasi CoddyKit. Kursus Machine Learning Academy mencakup 4 pelajaran total.

Ketegangan Utama dalam ML

Setiap model pembelajaran mesin menghadapi ketegangan mendasar antara dua kekuatan yang saling bersaing: kemampuannya menangkap pola kompleks dalam data (fleksibilitas) dan kemampuannya menggeneralisasikan pola tersebut ke contoh baru (keteraturan). Fleksibilitas yang terlalu besar menyebabkan overfitting; fleksibilitas yang terlalu kecil menyebabkan underfitting. Menemukan titik keseimbangan merupakan tantangan utama dalam pemilihan model dan penyetelan hiperparameter.

Pertukaran bias-varians memberikan nama dan kerangka matematis untuk ketegangan ini. Memahaminya penting untuk mendiagnosis masalah pada model dan mengetahui cara memperbaikinya secara tepat.

Bias: Kesalahan Sistematis akibat Asumsi yang Keliru

Bias adalah galat yang berasal dari asumsi yang keliru dalam algoritme pembelajaran. Model dengan bias tinggi terlalu sederhana untuk menangkap hubungan sebenarnya antara fitur dan target—model tersebut membuat prediksi yang secara sistematis keliru, terlepas dari seberapa banyak data pelatihan yang diberikan.

Contoh klasiknya adalah mencoba menyesuaikan garis lurus pada data yang memiliki pola nonlinier (melengkung) yang jelas. Sebanyak apa pun data yang dimiliki, garis tersebut akan meleset dari kurva. Model ini mengalami underfitting—model memiliki bias tinggi karena asumsi linearitasnya tidak sesuai untuk masalah ini.

import numpy as np
from sklearn.linear_model import LinearRegression
from sklearn.metrics import mean_squared_error

# Non-linear data: y = sin(x) + noise
np.random.seed(42)
X = np.sort(np.random.uniform(0, 10, 200)).reshape(-1, 1)
y = np.sin(X.ravel()) + np.random.randn(200) * 0.2

# High-bias model: straight line on non-linear data
linear_model = LinearRegression()
linear_model.fit(X, y)
y_pred_linear = linear_model.predict(X)

print(f'Linear model train MSE: {mean_squared_error(y, y_pred_linear):.3f}')
# High error even on training data -- high bias

Varians: Sensitivitas terhadap Data Pelatihan

Varians adalah galat yang berasal dari sensitivitas terhadap perubahan kecil pada data pelatihan. Model dengan varians tinggi mempelajari data pelatihan dengan sangat tepat—termasuk derau di dalamnya—sehingga perubahan kecil pada kumpulan data pelatihan menghasilkan model yang sangat berbeda.

Contoh klasiknya adalah pohon keputusan dengan kedalaman tak terbatas yang menghafal setiap contoh pelatihan. Pada kumpulan data pelatihan acak yang berbeda tetapi diambil dari distribusi yang sama, model tersebut akan mempelajari pohon yang sepenuhnya berbeda. Varians tinggi berarti model mengalami overfitting—model menangkap derau, bukan sinyal, dan memiliki kemampuan generalisasi yang buruk terhadap data baru.

from sklearn.tree import DecisionTreeClassifier
from sklearn.datasets import make_classification
from sklearn.model_selection import train_test_split
import numpy as np

X, y = make_classification(n_samples=200, n_features=5, random_state=42)

# Demonstrate high variance: train on two different splits
for seed in [1, 2, 3]:
    X_train, X_test, y_train, y_test = train_test_split(X, y, random_state=seed)
    deep_tree = DecisionTreeClassifier()  # unlimited depth
    deep_tree.fit(X_train, y_train)
    print(f'seed={seed}: train={deep_tree.score(X_train, y_train):.2f} test={deep_tree.score(X_test, y_test):.2f}')
# Large variation in test scores across seeds = high variance

Dekomposisi Bias-Varians

Galat pengujian yang diharapkan dari model apa pun dapat diuraikan secara matematis menjadi tiga suku:

Expected Error = Bias² + Variance + Irreducible Noise

Bias²: galat sistematis kuadrat yang berasal dari asumsi yang keliru. Dapat dikurangi dengan menggunakan model yang lebih fleksibel.
Varians: perubahan yang berasal dari sensitivitas terhadap data pelatihan. Dapat dikurangi dengan menggunakan regularisasi, lebih banyak data, atau model yang lebih sederhana.
Derau yang Tidak Dapat Dikurangi: keacakan bawaan dalam data yang tidak dapat dihilangkan oleh model apa pun.

Anda hanya dapat mengendalikan bias dan varians. Tujuannya adalah menemukan kompleksitas model yang meminimalkan jumlah keduanya.

Underfitting: Gejala dan Penyebab

Underfitting terjadi ketika model terlalu sederhana untuk menangkap pola dalam data. Performa pada data pelatihan dan pengujian sama-sama buruk. Model tersebut memiliki bias tinggi.

Gejala underfitting:

Akurasi pelatihan rendah (model bahkan tidak dapat menyesuaikan data pelatihan dengan baik).
Galat pelatihan dan validasi sama-sama tinggi dan berdekatan (tidak ada kesenjangan besar).
Penambahan data pelatihan tidak banyak membantu.

Penyebabnya antara lain algoritme yang terlalu sederhana (misalnya model linear untuk data nonlinier), regularisasi yang terlalu kuat, terlalu sedikit fitur, atau terlalu sedikit parameter model.

from sklearn.tree import DecisionTreeClassifier
from sklearn.datasets import load_breast_cancer
from sklearn.model_selection import train_test_split

X, y = load_breast_cancer(return_X_y=True)
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)

# Underfitting: depth=1 is too shallow for 30-feature dataset
shallow = DecisionTreeClassifier(max_depth=1)
shallow.fit(X_train, y_train)
train_acc = shallow.score(X_train, y_train)
test_acc = shallow.score(X_test, y_test)

print(f'depth=1 (underfitting): train={train_acc:.3f} test={test_acc:.3f}')
print('Both low -- classic underfitting signature')

Overfitting: Gejala dan Penyebab

Overfitting terjadi ketika model mempelajari data pelatihan dengan terlalu tepat—termasuk derau—dan gagal melakukan generalisasi. Performa pelatihan sangat tinggi, tetapi performa pengujian jauh lebih rendah. Model tersebut memiliki varians tinggi.

Gejala overfitting:

Akurasi pelatihan sangat tinggi (mendekati 100%), sedangkan akurasi pengujian jauh lebih rendah.
Kesenjangan besar antara kurva galat pelatihan dan validasi.
Penambahan data pelatihan secara konsisten meningkatkan performa pengujian.

Penyebabnya antara lain model yang terlalu kompleks, terlalu sedikit contoh pelatihan, terlalu banyak fitur (kutukan dimensionalitas), atau regularisasi yang tidak memadai.

from sklearn.tree import DecisionTreeClassifier
from sklearn.datasets import load_breast_cancer
from sklearn.model_selection import train_test_split

X, y = load_breast_cancer(return_X_y=True)
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)

# Overfitting: unlimited depth memorises training data
deep = DecisionTreeClassifier()  # max_depth=None
deep.fit(X_train, y_train)
train_acc = deep.score(X_train, y_train)
test_acc = deep.score(X_test, y_test)

print(f'depth=None (overfitting): train={train_acc:.3f} test={test_acc:.3f}')
print(f'Overfit gap: {train_acc - test_acc:.3f} -- classic overfitting signature')

Menggambar Kurva Bias-Varians

Visualisasi yang paling membantu adalah menggambar galat pelatihan dan validasi sebagai fungsi dari kompleksitas model (misalnya, kedalaman pohon). Seiring meningkatnya kompleksitas:

Galat pelatihan menurun secara monoton (atau tetap rendah).
Galat validasi membentuk pola U: awalnya tinggi (underfitting), lalu turun hingga minimum pada kompleksitas optimal, kemudian naik lagi (overfitting).

Kompleksitas model yang optimal berada di dasar kurva U galat validasi.

import numpy as np
import matplotlib.pyplot as plt
from sklearn.tree import DecisionTreeClassifier
from sklearn.datasets import load_breast_cancer
from sklearn.model_selection import train_test_split

X, y = load_breast_cancer(return_X_y=True)
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)

train_errors, test_errors = [], []
depths = range(1, 20)
for d in depths:
    m = DecisionTreeClassifier(max_depth=d).fit(X_train, y_train)
    train_errors.append(1 - m.score(X_train, y_train))
    test_errors.append(1 - m.score(X_test, y_test))

plt.plot(depths, train_errors, label='Train Error')
plt.plot(depths, test_errors, label='Test Error')
plt.xlabel('Tree Depth (Model Complexity)')
plt.ylabel('Classification Error')
plt.legend()
plt.title('Bias-Variance Trade-off Curve')
plt.show()

Kurva Pembelajaran: Mendiagnosis dengan Ukuran Data

Kurva pembelajaran menggambarkan galat pelatihan dan validasi sebagai fungsi dari ukuran kumpulan data pelatihan (bukan kompleksitas model). Kurva pembelajaran membantu mendiagnosis apakah model Anda akan memperoleh manfaat dari lebih banyak data:

Jika kedua kurva bertemu pada galat tinggi yang sama: bias tinggi—lebih banyak data tidak akan membantu; Anda memerlukan model yang lebih baik.
Jika galat pelatihan rendah tetapi galat validasi tinggi, dan kesenjangannya menyempit saat data bertambah: varians tinggi—lebih banyak data akan membantu; lanjutkan pengumpulan data.

import numpy as np
import matplotlib.pyplot as plt
from sklearn.model_selection import learning_curve
from sklearn.tree import DecisionTreeClassifier
from sklearn.datasets import load_breast_cancer

X, y = load_breast_cancer(return_X_y=True)

train_sizes, train_scores, val_scores = learning_curve(
    DecisionTreeClassifier(max_depth=None),  # overfitting model
    X, y, cv=5, train_sizes=np.linspace(0.1, 1.0, 10)
)

plt.plot(train_sizes, train_scores.mean(axis=1), label='Train')
plt.plot(train_sizes, val_scores.mean(axis=1), label='Validation')
plt.fill_between(train_sizes,
    val_scores.mean(axis=1) - val_scores.std(axis=1),
    val_scores.mean(axis=1) + val_scores.std(axis=1), alpha=0.2)
plt.xlabel('Training Set Size')
plt.ylabel('Accuracy')
plt.legend()
plt.title('Learning Curve')
plt.show()

Regularisasi: Mengendalikan Varians

Regularisasi adalah teknik utama untuk mengurangi varians (overfitting) tanpa mengubah keluarga model secara mendasar. Teknik ini menambahkan penalti untuk kompleksitas model ke fungsi kerugian, sehingga model tidak terdorong untuk menyesuaikan derau.

Teknik regularisasi yang umum:

Batas kedalaman pohon (max_depth): mencegah pohon tumbuh cukup dalam untuk menghafal data pelatihan.
Penalti L2 (Ridge): mengecilkan bobot menuju nol.
Penalti L1 (Lasso): membuat beberapa bobot tepat menjadi nol (pemilihan fitur).
Dropout (jaringan saraf): mengubah aktivasi menjadi nol secara acak selama pelatihan.

from sklearn.tree import DecisionTreeClassifier
from sklearn.datasets import load_breast_cancer
from sklearn.model_selection import cross_val_score
import numpy as np

X, y = load_breast_cancer(return_X_y=True)

# Compare regularised vs non-regularised tree
for max_depth in [None, 10, 5, 3, 2]:
    model = DecisionTreeClassifier(max_depth=max_depth, random_state=42)
    cv = cross_val_score(model, X, y, cv=5, scoring='accuracy')
    print(f'max_depth={max_depth}: CV acc = {cv.mean():.3f} (+/- {cv.std():.3f})')

Titik Optimal: Kompleksitas Model yang Optimal

Kompleksitas model yang optimal berada pada titik minimum kurva galat pengujian/validasi. Untuk menemukannya secara sistematis:

Tentukan rentang nilai kompleksitas (misalnya, kedalaman pohon 1 hingga 20, atau parameter regularisasi C dari 0,001 hingga 100).
Untuk setiap nilai, latih model pada lipatan pelatihan dan evaluasi pada lipatan validasi (gunakan validasi silang untuk memperoleh hasil yang stabil).
Pilih kompleksitas yang menghasilkan skor validasi silang terbaik.
Latih ulang model akhir pada seluruh data pelatihan menggunakan kompleksitas optimal tersebut.

Proses ini disebut penyetelan hiperparameter, dan Anda akan mengotomatiskannya dengan GridSearchCV pada pelajaran berikutnya.

from sklearn.tree import DecisionTreeClassifier
from sklearn.model_selection import cross_val_score
from sklearn.datasets import load_breast_cancer
import numpy as np

X, y = load_breast_cancer(return_X_y=True)

best_score, best_depth = 0, 1
for depth in range(1, 25):
    model = DecisionTreeClassifier(max_depth=depth, random_state=42)
    score = cross_val_score(model, X, y, cv=5).mean()
    if score > best_score:
        best_score, best_depth = score, depth
    print(f'depth={depth:2d}: CV acc = {score:.3f}')

print(f'\nOptimal depth: {best_depth} with CV acc: {best_score:.3f}')

Ringkasan Praktis Bias-Varians

Panduan referensi cepat untuk mendiagnosis dan memperbaiki masalah bias-varians:

Perbaikan bias tinggi (underfitting): gunakan model yang lebih kompleks, tambahkan lebih banyak fitur, kurangi kekuatan regularisasi, buat fitur polinomial atau fitur interaksi.
Perbaikan varians tinggi (overfitting): kumpulkan lebih banyak data pelatihan, terapkan regularisasi yang lebih kuat, kurangi kompleksitas model, gunakan metode ensemble (bagging), terapkan dropout (jaringan saraf), lakukan pemilihan fitur untuk menghapus fitur yang mengandung derau.
Tidak yakin masalahnya yang mana: gambar kurva pembelajaran—jika galat pelatihan dan validasi sama-sama tinggi → bias; jika kesenjangannya besar → varians.

Pemeriksaan Singkat

Uji pemahaman Anda tentang konsep Pembelajaran Mesin dengan Python dari pelajaran ini.

Jawab di pelajaran interaktif

Ringkasan Pelajaran

Dalam pelajaran ini Anda mempelajari bahwa: bias adalah galat sistematis dari model yang terlalu sederhana sehingga mengalami underfitting terhadap data, varians adalah sensitivitas terhadap data pelatihan yang menyebabkan overfitting dan generalisasi yang buruk, dan kompleksitas model yang optimal meminimalkan jumlah bias dan varians, yang dapat ditemukan dengan memeriksa kurva galat validasi berbentuk U atau menggunakan kurva pembelajaran untuk membedakan kedua masalah tersebut. Berikutnya, kita akan membuat dasar pembanding dengan DummyClassifier dan menetapkan ambang performa minimum yang harus dilampaui oleh setiap model nyata.

Gratis untuk memulai

Belajar Python dengan tutor AI — gratis

Tulis dan jalankan kode asli di browser kamu, dapatkan bantuan instan dari tutor AI 24/7, dan lanjutkan di mana kamu tinggalkan di web atau aplikasi.

Kursus: 30
Pelajaran: 120

Mulai belajar gratis Lihat kursus lengkapnya

Pertanyaan yang Sering Diajukan

Apakah pelajaran “Pertukaran Bias-Varians: Underfitting vs Overfitting” gratis?

Ya — teks lengkap “Pertukaran Bias-Varians: Underfitting vs Overfitting” gratis dibaca di sini di web. Untuk praktiknya secara interaktif (editor kode bawaan dan tutor AI 24/7) dan buka sisa kursus Machine Learning Academy, upgrade ke CoddyKit PRO. Kursus Machine Learning Academy mencakup 4 pelajaran total.

Apa yang akan aku pelajari di “Pertukaran Bias-Varians: Underfitting vs Overfitting”?

Peserta didik akan menggambar kurva galat pelatihan dan validasi, mengidentifikasi area underfitting dan overfitting, serta memahami konsep dekomposisi bias-varians. Kamu berlatih Machine Learning Academy dengan kode praktik yang langsung kamu jalankan di browser, dan tutor AI 24/7 menjawab pertanyaanmu saat kamu mengerjakan pelajaran ini.

Apakah aku perlu pengalaman untuk memulai Machine Learning Academy?

Tidak diperlukan pengalaman sebelumnya. Machine Learning Academy di CoddyKit dirancang untuk pemula hingga pelajar tingkat lanjut, jadi kamu bisa memulai di sini atau dari awal dan belajar sesuai kecepatan kamu sendiri. Ini adalah pelajaran 3 dari 4.

Berapa lama pelajaran “Pertukaran Bias-Varians: Underfitting vs Overfitting” memakan waktu?

Sebagian besar pelajaran CoddyKit memakan waktu sekitar 5–10 menit. Setiap pelajaran ringkas dan interaktif, jadi kamu membuat kemajuan stabil dan melanjutkan dari tempat kamu tinggalkan di web dan aplikasi.

Bisakah aku menulis dan menjalankan kode dalam pelajaran Machine Learning Academy ini?

Ya. Setiap pelajaran Machine Learning Academy menyertakan editor kode bawaan, jadi kamu menulis dan menjalankan kode nyata langsung di browser dan mendapatkan umpan balik AI instan — tidak diperlukan penyiapan lokal.

Semua pelajaran dalam kursus ini

Alasan Evaluasi Tidak Boleh Dilakukan pada Data Pelatihan
train_test_split: Rasio, Benih, dan Stratifikasi
Pertukaran Bias-Varians: Underfitting vs Overfitting
Model Dasar: Selalu Kalahkan DummyClassifier

← Kembali ke Machine Learning Academy