Apa itu Underfitting? Cara Mendeteksi dan Mengatasi Bias Tinggi pada Model ML

Saat kita membangun model untuk memprediksi hasil atau menemukan pola, kita akan menghadapi berbagai tantangan. Salah satu hambatan umum adalah membuat model yang akurat menangkap tren mendasar dalam data Anda. Terkadang, model terlalu sederhana dan gagal mempelajari kompleksitasnya, sehingga kinerjanya buruk. Fenomena ini dikenal sebagai Underfitting.

Model yang underfitting tidak hanya berkinerja buruk pada data pelatihan, tetapi juga gagal melakukan generalisasi ke data baru yang belum pernah dilihat. Ini berarti prediksi Anda bisa tidak andal dalam skenario dunia nyata. Mengenali dan mengatasi underfitting adalah langkah penting menuju pembangunan model machine learning yang tangguh dan efektif. 

Gambar oleh Penulis

Dalam artikel ini, kita akan melihat apa itu underfitting, mengapa hal itu terjadi, cara mengenalinya, dan yang terpenting, cara memperbaiki underfitting. Jika Anda ingin langsung praktik machine learning, pastikan untuk melihat Machine Learning Fundamentals in Python track kami. 

Apa itu Underfitting?

Mari kita menilik lebih dalam konsep underfitting dan bagaimana kebalikannya, overfitting. Memahami pembedaan ini sangat mendasar untuk diagnosis dan peningkatan model.

Gambar oleh Penulis

Secara sederhana, Underfitting terjadi ketika model machine learning terlalu sederhana untuk menangkap pola mendasar dalam data pelatihan. Bayangkan mencoba memasangkan garis lurus pada titik-titik data yang jelas mengikuti kurva, dan garis (model kita) tidak cukup kompleks. Model yang underfitting mengalami bias tinggi, artinya membuat asumsi kuat tentang data (misalnya, mengasumsikan hubungan linear padahal tidak).

Karena gagal mempelajari data dengan baik, kinerjanya buruk tidak hanya pada data pelatihan tetapi juga pada data baru yang tidak terlihat (data uji). Namun, model seperti ini cenderung memiliki varians rendah, artinya prediksinya tidak banyak berubah jika Anda melatihnya pada subset data yang berbeda. Kesederhanaannya membuatnya konsisten, meski konsisten salah.

Secara matematis, ini terkait dengan dekomposisi bias-varians dari galat ekspektasi model. Galat ekspektasi sebuah model dapat diuraikan menjadi tiga komponen: kuadrat bias, varians, dan galat tak tereduksi:

Di mana:

• E[(y - f̂(x))²] adalah galat kuadrat ekspektasi dari prediksi.

• Bias(f̂(x)) mengukur galat yang diperkenalkan oleh pendekatan fungsi nyata f(x) dengan model.

• Var(f̂(x)) adalah variabilitas prediksi model untuk dataset pelatihan yang berbeda.

• σ² merepresentasikan galat tak tereduksi — noise bawaan pada data yang tidak dapat diprediksi.

Pada underfitting, suku Bias(f̂(x)) mendominasi galat. Model terlalu sederhana, sehingga menimbulkan galat sistematis dan gagal menangkap hubungan data yang sebenarnya.

Membandingkan underfitting vs overfitting

Memahami underfitting menjadi lebih jelas ketika dibandingkan dengan overfitting. Sementara model yang underfitting terlalu sederhana, model yang overfitting terlalu kompleks. Mereka mempelajari data pelatihan terlalu baik, menangkap bukan hanya pola mendasar tetapi juga noise dan fluktuasi acak.

Bias Variance Trade-off - Gambar oleh Penulis

Mari lihat perbedaan utama antara Underfitting dan Overfitting:

Ini mengarah pada konsep krusial trade-off bias-varians.

• Bias Tinggi (Underfitting): Model sederhana memiliki bias tinggi tetapi varians rendah. Mereka konsisten salah namun tidak banyak berubah dengan data pelatihan yang berbeda.
• Varians Tinggi (Overfitting): Model kompleks memiliki bias rendah tetapi varians tinggi. Mereka sangat pas dengan data pelatihan (bias rendah) namun sangat sensitif terhadap data pelatihan yang digunakan, sehingga generalisasi ke data baru buruk. Anda dapat mempelajari lebih lanjut di artikel kami What is Overfitting?.

Tujuannya adalah menemukan titik manis: model yang cukup kompleks untuk menangkap pola sebenarnya (bias rendah) tetapi tidak terlalu kompleks sehingga mempelajari noise (varians rendah).

Contoh:

• Contoh Underfitting: Mencoba memprediksi harga rumah, yang bergantung pada ukuran, lokasi, usia, dll., hanya menggunakan jumlah kamar. Modelnya terlalu sederhana (bias tinggi) dan kemungkinan besar menghasilkan prediksi buruk untuk sebagian besar rumah.
• Contoh Overfitting: Membuat model regresi polinomial yang sangat kompleks yang tepat melewati setiap titik data dalam set pelatihan harga rumah Anda. Model ini mungkin memiliki galat nyaris nol pada data pelatihan, tetapi akan berkinerja buruk pada rumah baru karena telah mempelajari noise spesifik dari set pelatihan (varians tinggi).

Memahami di mana posisi model Anda pada spektrum ini penting untuk mengembangkan solusi machine learning yang efektif, seperti yang akan kita lihat pada bagian berikut tentang mendeteksi dan mengatasi underfitting.

Penyebab Underfitting dan Indikator Diagnostik

Sekarang kita memahami apa itu underfitting, mari lihat mengapa hal itu terjadi dan bagaimana Anda dapat mendeteksinya dalam proyek Anda sendiri. Mengidentifikasi akar penyebab sangat penting untuk memilih strategi mitigasi yang tepat. 

Penyebab utama underfitting

Beberapa faktor dapat menyebabkan model underfitting:

Kompleksitas model tidak memadai

Algoritme yang dipilih mungkin terlalu sederhana untuk struktur mendasar data. Misalnya, menggunakan model regresi linear saat hubungan antara fitur dan variabel target sangat non-linear. Model secara inheren kurang kapasitas untuk menangkap kompleksitas.

Pelatihan tidak memadai

Model mungkin belum dilatih cukup lama (misalnya, terlalu sedikit epoch pada neural network) atau dengan parameter pembelajaran yang sesuai. Jika proses pelatihan berhenti terlalu dini, model tidak punya kesempatan cukup untuk mempelajari pola, meskipun memiliki kapasitas.

Representasi fitur yang buruk 

Fitur yang digunakan untuk melatih model mungkin tidak cukup merepresentasikan faktor-faktor yang memengaruhi variabel target. Ini bisa berarti:

• Fitur penting hilang: Prediktor kunci tidak disertakan dalam dataset.
• Fitur tidak relevan: Dataset mengandung noise atau fitur yang tidak berkorelasi dengan hasil, berpotensi menyesatkan model sederhana.
• Fitur perlu transformasi: Fitur mungkin memerlukan penskalaan, normalisasi, atau pengodean (misalnya, variabel kategorikal) agar berguna bagi model.

Regularisasi berlebihan

Teknik regularisasi (seperti penalti L1 atau L2) terutama digunakan untuk mencegah overfitting dengan menambah penalti atas kompleksitas. Namun, jika kekuatan regularisasi (misalnya parameter lambda) disetel terlalu tinggi, ini dapat terlalu menghukum model, memaksanya menjadi terlalu sederhana dan menyebabkan underfitting. Pelajari lebih lanjut tentang regularisasi di Towards Preventing Overfitting in Machine Learning: Regularization.

Data berkualitas rendah atau tidak cukup

• Data tidak cukup: Jika dataset pelatihan terlalu kecil, model mungkin tidak memiliki cukup contoh untuk mempelajari pola mendasar secara efektif.
• Noise tinggi: Jika data sangat ber-noise, model mungkin kesulitan membedakan sinyal dari noise, terutama jika modelnya sederhana.
• Nilai hilang: Banyaknya data hilang dapat menghambat kemampuan model untuk belajar, khususnya jika tidak ditangani dengan tepat. Teknik menanganinya dibahas dalam Handling Missing Data with Imputations in R.

Metode deteksi

Bagaimana Anda tahu jika model Anda underfitting? Berikut beberapa teknik diagnosis umum:

Menganalisis metrik kinerja 

Indikator paling langsung adalah kinerja buruk pada baik set pelatihan maupun validasi/uji. Jika model Anda menghasilkan galat tinggi (atau akurasi rendah, R-squared rendah, dll.) pada data yang dilatih, ini tanda kuat bahwa model belum mempelajari pola secara efektif. Berbeda dengan overfitting, di mana kinerja pelatihan sangat baik tetapi kinerja uji buruk, underfitting menunjukkan kinerja buruk di semua sisi.

Kurva pembelajaran

Memplot kinerja model (misalnya, galat atau akurasi) pada set pelatihan dan validasi sebagai fungsi waktu pelatihan atau ukuran dataset bisa sangat informatif. Untuk model underfitting, kurva pembelajaran biasanya menunjukkan:

• Galat pelatihan tinggi yang cepat mencapai plateau.
• Galat validasi tinggi yang mendekati galat pelatihan dan juga plateau.
• Kedua kurva berkumpul pada tingkat galat tinggi, menandakan model tidak meningkat signifikan meski dengan lebih banyak data atau pelatihan.

Analisis fitur

Tinjau fitur yang digunakan. Apakah relevan? Apakah ada interaksi yang belum Anda tangkap? Apakah fitur numerik telah diskalakan? Apakah fitur kategorikal dikodekan dengan tepat? 

Terkadang, meninjau kembali rekayasa fitur dapat mengungkap alasan model kesulitan. Konsep dasar dibahas dalam Machine Learning Fundamentals in R. Untuk wawasan lebih dalam tentang hubungan statistik, pertimbangkan sumber daya seperti Statistical Inference in R.

Pemodelan komparatif

Latih model yang lebih kompleks (misalnya, decision tree atau gradient boosting machine jika awalnya Anda menggunakan regresi linear) pada data yang sama. Jika model yang lebih kompleks secara signifikan mengungguli model awal Anda pada set pelatihan dan validasi, ini menyiratkan model asli Anda kemungkinan underfitting karena kompleksitas yang tidak memadai. 

Anda dapat melacak perbandingan seperti itu menggunakan alat yang dibahas dalam Machine Learning Experimentation: An Introduction to Weights & Biases.

Dengan memahami penyebab dan metode deteksi ini, Anda dapat mendiagnosis model yang underfitting secara efektif dan mengambil langkah untuk meningkatkan kinerjanya.

Strategi Mitigasi Underfitting dan Praktik Terbaik

Setelah Anda mengidentifikasi underfitting, langkah berikutnya adalah mengetahui cara memperbaikinya. Untungnya, ada beberapa strategi efektif yang dapat membantu meningkatkan kemampuan model untuk mempelajari pola mendasar dalam data. Mari kita lihat beberapa di antaranya:

Meningkatkan kompleksitas model

Jika model Anda terlalu sederhana (bias tinggi), membuatnya lebih kompleks sering kali dapat mengatasi underfitting. Kita bisa melakukannya dengan cara berikut:

Pemilihan algoritme

Beralih ke model yang lebih kuat. Jika regresi linear underfitting, coba regresi polinomial, decision tree, random forest, gradient boosting machines (seperti XGBoost atau LightGBM), atau support vector machines (SVM) dengan kernel non-linear. Model-model ini secara inheren memiliki kapasitas lebih untuk menangkap hubungan kompleks.

Ekspansi fitur polinomial

Untuk masalah regresi, Anda dapat membuat fitur polinomial dari fitur numerik yang ada. Ini memungkinkan model linear menyesuaikan hubungan melengkung yang lebih kompleks. Misalnya, jika Anda memiliki fitur x, Anda dapat menambahkan x2, x3, dll., sebagai fitur baru. Scikit-learn menyediakan PolynomialFeatures untuk ini.

Penyetelan hiperparameter

Banyak model kompleks memiliki hiperparameter yang mengendalikan kompleksitasnya (misalnya, kedalaman decision tree, jumlah neuron dalam lapisan neural network, parameter C pada SVM). Menyetel hiperparameter ini agar mengizinkan lebih banyak kompleksitas dapat mengurangi bias. 

Teknik seperti Grid Search atau Randomized Search sangat penting di sini. Pelajari lebih lanjut dengan kursus seperti Hyperparameter Tuning in Python atau Hyperparameter Tuning in R. Lihat juga tutorial kami tentang Hyperparameter Optimization in Machine Learning Models.

Rekayasa fitur dan augmentasi data

Terkadang, masalahnya bukan pada model, melainkan representasi data. Meningkatkan fitur dapat sangat membantu. Kita bisa melakukannya melalui cara-cara berikut:

Pembuatan fitur khusus domain

Gunakan pengetahuan Anda tentang domain masalah untuk membuat fitur baru yang mungkin lebih informatif. Misalnya, dalam memprediksi harga rumah, menggabungkan 'jumlah kamar tidur' dan 'jumlah kamar mandi' menjadi fitur 'total kamar', atau menghitung 'usia rumah' dari 'tahun dibangun'.

Fitur interaksi

Buat fitur yang merepresentasikan interaksi antarfitur yang ada (misalnya, mengalikan dua fitur). Ini dapat membantu model menangkap efek sinergis.

Pemerkayaan data

Perkaya dataset Anda dengan sumber data eksternal jika memungkinkan. Misalnya, menambahkan data demografis ke informasi pelanggan atau data cuaca ke prediksi penjualan.

Augmentasi data (terutama untuk data tidak terstruktur)

Untuk data gambar atau teks, teknik seperti memutar/membalik gambar atau mengganti sinonim pada teks dapat secara artifisial meningkatkan ukuran dan keragaman set pelatihan, berpotensi membantu model mempelajari pola yang lebih tangguh.

Penyesuaian regularisasi

Jika underfitting disebabkan oleh regularisasi berlebihan yang dimaksudkan untuk mencegah overfitting, Anda perlu menguranginya. Turunkan nilai parameter regularisasi (misalnya, alpha pada Ridge/Lasso, C pada SVM — perhatikan bahwa untuk SVM, C yang lebih kecil berarti regularisasi lebih kuat, jadi Anda perlu meningkatkan C).

Jika menggunakan dropout, kurangi laju dropout (persentase neuron yang dijatuhkan saat pelatihan). Laju yang lebih rendah mempertahankan lebih banyak kapasitas jaringan.

Menemukan keseimbangan yang tepat sering kali memerlukan penyetelan cermat, sekali lagi menyoroti pentingnya optimisasi hiperparameter.

Metode ensemble

Metode ensemble menggabungkan prediksi dari beberapa model individual (weak learner) untuk menghasilkan prediksi akhir yang lebih kuat dan tangguh. Metode ini sering sangat efektif mengurangi bias dan varians. Beberapa metode ensemble adalah sebagai berikut:

• Bagging (mis., Random Forests): Melatih banyak model (misalnya, decision tree) secara independen pada sampel bootstrap data yang berbeda dan merata-ratakan prediksinya. Ini terutama mengurangi varians tetapi juga dapat membantu jika learner dasar sedikit bias. Lihat tutorial Bagging kami untuk info selengkapnya.
• Boosting (mis., AdaBoost, Gradient Boosting): Melatih model secara berurutan, dengan setiap model baru berfokus memperbaiki kesalahan model sebelumnya. Boosting sangat efektif mengurangi bias dan mengubah weak learner menjadi strong learner, menjadikannya alat yang ampuh melawan underfitting. Kami memiliki panduan Boosting untuk penjelasan lebih lanjut. 
• Stacking: Melatih beberapa jenis model yang berbeda lalu menggunakan model lain (meta-learner) untuk mempelajari cara terbaik menggabungkan prediksi mereka.

Dengan menerapkan strategi-strategi ini, sering kali secara kombinasi, Anda dapat secara efektif mengatasi underfitting dan membangun model yang lebih baik menangkap kompleksitas data Anda.

Aplikasi Praktis dan Studi Kasus

Melihat underfitting secara langsung dengan dataset dan kode dapat sangat memperjelas konsep. Mari lihat contoh praktis untuk menunjukkan bagaimana perilaku model yang underfitting dan bagaimana kinerjanya dapat ditingkatkan.

Contoh underfitting regresi linear

Skenario umum underfitting terjadi saat model linear sederhana digunakan untuk menggambarkan hubungan non-linear. Mari ilustrasikan ini dengan mencoba memasangkan model regresi linear pada data yang mengikuti pola kuadratik.

Kita akan menghasilkan data sintetis di mana variabel target y memiliki hubungan kuadratik dengan fitur X. Pertama, kita akan memasangkan model regresi linear sederhana. Kita akan mengamati kinerjanya yang buruk (Mean Squared Error - MSE tinggi) dan memvisualisasikan bagaimana model gagal menangkap kurva data. 

Kemudian, kita akan memperluas fitur dengan menambahkan suku polinomial dan memasangkan model regresi polinomial. Ini akan menunjukkan bagaimana meningkatkan kompleksitas model dapat mengurangi bias dan secara signifikan meningkatkan akurasi model.

Mari mulai dengan mengimpor pustaka yang diperlukan sebagai berikut:

# Import necessary libraries
import numpy as np
import matplotlib.pyplot as plt
from sklearn.linear_model import LinearRegression
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import make_pipeline
from sklearn.metrics import mean_squared_errorDidukung oleh

Mari kita hasilkan data non-linear sintetis. Kita akan membuat data dengan hubungan kuadratik: y = 0.5*X^2 + X + 2 + noise.

np.random.seed(42) # for reproducibility
num_samples = 100
X = np.sort(10 * np.random.rand(num_samples, 1) - 5, axis=0) # Feature X (sorted for plotting)
y_true = 0.5 * X**2 + X + 2 # True quadratic relationship
y = y_true + np.random.randn(num_samples, 1) * 5 # Add some noise to make it realisticDidukung oleh

Sekarang, kita akan memasangkan model regresi linear sederhana (Model Underfitting) seperti di bawah ini:

linear_model = LinearRegression()
linear_model.fit(X, y)
y_pred_linear = linear_model.predict(X)
mse_linear = mean_squared_error(y, y_pred_linear)

print(f"--- Simple Linear Regression (Potential Underfitting Model) ---")
print(f"Mean Squared Error (MSE): {mse_linear:.2f}")
print(f"Model Coefficients (slope): {linear_model.coef_[0][0]:.2f}")
print(f"Model Intercept: {linear_model.intercept_[0]:.2f}")Didukung oleh

Keluaran:

--- Simple Linear Regression (Potential Underfitting Model) ---

Mean Squared Error (MSE): 34.03

Model Coefficients (slope): 1.00

Model Intercept: 6.42Didukung oleh

Sekarang, kita akan memasangkan model regresi polinomial (Model yang Ditingkatkan). Untuk itu, kita membuat fitur polinomial (derajat 2) lalu memasangkan model linear pada fitur-fitur ini. Langkah PolynomialFeatures menambahkan fitur baru. Langkah LinearRegression memiliki koefisien untuk masing-masing.

Untuk derajat 2, kita mengharapkan koefisien untuk X dan X^2. Pipeline membuat proses ini lebih rapi. Atribut named_steps dari pipeline memungkinkan akses ke setiap langkah seperti di bawah ini:

polynomial_model = make_pipeline(PolynomialFeatures(degree=2, include_bias=False), LinearRegression())
polynomial_model.fit(X, y)
y_pred_poly = polynomial_model.predict(X)
mse_poly = mean_squared_error(y, y_pred_poly)

print(f"\n--- Polynomial Regression (Degree 2) ---")
print(f"Mean Squared Error (MSE): {mse_poly:.2f}")
poly_reg_coeffs = polynomial_model.named_steps['linearregression'].coef_[0]
poly_reg_intercept = polynomial_model.named_steps['linearregression'].intercept_[0]
print(f"Model Coefficients (for X, X^2): {poly_reg_coeffs[0]:.2f}, {poly_reg_coeffs[1]:.2f}")
print(f"Model Intercept: {poly_reg_intercept:.2f}")Didukung oleh

Keluaran:

--- Polynomial Regression (Degree 2) ---

Mean Squared Error (MSE): 20.48

Model Coefficients (for X, X^2): 1.13, 0.50

Model Intercept: 2.04Didukung oleh

Sekarang mari memvisualisasikan pemfittingan model seperti diperlihatkan di bawah:

# Visualization
plt.figure(figsize=(10, 4))
plt.scatter(X, y, s=30, label="Actual Data Points", alpha=0.7, edgecolors='k')
plt.plot(X, y_pred_linear, color='red', linewidth=2, label=f'Linear Fit (Underfitting)\nMSE: {mse_linear:.2f}')
plt.plot(X, y_pred_poly, color='green', linewidth=2, label=f'Polynomial Fit (Degree 2)\nMSE: {mse_poly:.2f}')
plt.title('Demonstrating Underfitting with Linear vs. Polynomial Regression', fontsize=16)
plt.xlabel('Feature X', fontsize=14)
plt.ylabel('Target y', fontsize=14)
plt.legend(fontsize=12)
plt.grid(True, linestyle='--', alpha=0.7)
plt.show()Didukung oleh

Keluaran:

Plot ini secara visual menegaskan underfitting pada model linear sederhana. Model gagal menangkap kurva pada data. Model regresi polinomial, dengan memasukkan suku X^2, memberikan kecocokan yang jauh lebih baik, seperti ditunjukkan oleh MSE yang lebih rendah.

Ini menunjukkan bagaimana memperluas fitur (meningkatkan kompleksitas model) dapat mengurangi bias dan meningkatkan akurasi ketika hubungan mendasarnya non-linear. Selanjutnya, mari lihat studi kasus diagnosis medis.

Studi kasus diagnosis medis

Mari mensimulasikan skenario diagnosis medis menggunakan dataset terkenal Breast Cancer Wisconsin (Diagnostic) yang tersedia di scikit-learn.

Pertama kita akan mencoba membangun model klasifikasi menggunakan hanya subset fitur yang sangat terbatas, yang mungkin menyebabkan underfitting. Lalu, kita akan menggunakan set fitur yang lebih komprehensif dan berpotensi algoritme yang lebih kompleks untuk menunjukkan peningkatan.

Mari mulai dengan mengimpor pustaka yang diperlukan sebagai berikut:

# Import necessary libraries
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
from sklearn.datasets import load_breast_cancer
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression
from sklearn.ensemble import RandomForestClassifier
from sklearn.metrics import accuracy_score, roc_auc_score, confusion_matrix, ConfusionMatrixDisplayDidukung oleh

Sekarang, mari memuat dan menyiapkan data:

cancer = load_breast_cancer()
X = pd.DataFrame(cancer.data, columns=cancer.feature_names)
y = cancer.target # 0 for malignant, 1 for benignDidukung oleh

Untuk demonstrasi, mari pilih subset fitur yang sangat terbatas untuk skenario underfitting. Ini mungkin bukan yang paling prediktif jika berdiri sendiri:

features_limited = ['mean texture', 'mean symmetry']
X_limited = X[features_limited]Didukung oleh

Untuk model yang ditingkatkan, kita akan menggunakan subset yang lebih besar (atau semua fitur). Mari pilih 10 fitur pertama untuk set yang lebih komprehensif:

features_comprehensive = cancer.feature_names[:10]
X_comprehensive = X[features_comprehensive]Didukung oleh

Mari bagi data. Kita akan melakukannya secara terpisah untuk tiap set fitur agar jelas:

X_train_lim, X_test_lim, y_train, y_test = train_test_split(X_limited, y, test_size=0.3, random_state=42, stratify=y)
X_train_comp, X_test_comp, _, _ = train_test_split(X_comprehensive, y, test_size=0.3, random_state=42, stratify=y) # y_train and y_test are the sameDidukung oleh

Mari skala fitur karena ini penting untuk regresi logistik dan banyak algoritme lain:

scaler_lim = StandardScaler().fit(X_train_lim)
X_train_lim_scaled = scaler_lim.transform(X_train_lim)
X_test_lim_scaled = scaler_lim.transform(X_test_lim)

scaler_comp = StandardScaler().fit(X_train_comp)
X_train_comp_scaled = scaler_comp.transform(X_train_comp)
X_test_comp_scaled = scaler_comp.transform(X_test_comp)Didukung oleh

Sekarang, mari pasang regresi logistik dengan fitur terbatas:

print("Scenario 1: Logistic Regression (Limited Features - Potential Underfitting)")
log_reg_limited = LogisticRegression(random_state=42, solver='liblinear') # liblinear is good for small datasets
log_reg_limited.fit(X_train_lim_scaled, y_train)
y_pred_lim = log_reg_limited.predict(X_test_lim_scaled)
y_proba_lim = log_reg_limited.predict_proba(X_test_lim_scaled)[:, 1]

acc_lim = accuracy_score(y_test, y_pred_lim)
auc_lim = roc_auc_score(y_test, y_proba_lim)
print(f"Features used: {features_limited}")
print(f"Accuracy: {acc_lim:.4f}")
print(f"AUC: {auc_lim:.4f}")Didukung oleh

Keluaran:

Scenario 1: Logistic Regression (Limited Features - Potential Underfitting)

Features used: ['mean texture', 'mean symmetry']

Accuracy: 0.7544

AUC: 0.8151Didukung oleh

Mari terapkan strategi mitigasi. Kita akan memasangkan model regresi logistik dengan lebih banyak fitur:

print("Scenario 2: Logistic Regression (Comprehensive Features)")
log_reg_comp = LogisticRegression(random_state=42, solver='liblinear')
log_reg_comp.fit(X_train_comp_scaled, y_train)
y_pred_comp_lr = log_reg_comp.predict(X_test_comp_scaled)
y_proba_comp_lr = log_reg_comp.predict_proba(X_test_comp_scaled)[:, 1]

acc_comp_lr = accuracy_score(y_test, y_pred_comp_lr)
auc_comp_lr = roc_auc_score(y_test, y_proba_comp_lr)
print(f"Features used: First 10 features") # For brevity
print(f"Accuracy: {acc_comp_lr:.4f}")
print(f"AUC: {auc_comp_lr:.4f}")Didukung oleh

Keluaran:

Scenario 2: Logistic Regression (Comprehensive Features)

Features used: First 10 features

Accuracy: 0.9181

AUC: 0.9831Didukung oleh

Sekarang, mari pasang model yang lebih kompleks seperti Random Forest dengan lebih banyak fitur:

print("Scenario 3: Random Forest (Comprehensive Features)")
rf_comp = RandomForestClassifier(random_state=42, n_estimators=100) # n_estimators is a key hyperparameter
rf_comp.fit(X_train_comp_scaled, y_train) # RF can also benefit from scaled data, though less sensitive
y_pred_comp_rf = rf_comp.predict(X_test_comp_scaled)
y_proba_comp_rf = rf_comp.predict_proba(X_test_comp_scaled)[:, 1]

acc_comp_rf = accuracy_score(y_test, y_pred_comp_rf)
auc_comp_rf = roc_auc_score(y_test, y_proba_comp_rf)
print(f"Features used: First 10 features")
print(f"Accuracy: {acc_comp_rf:.4f}")
print(f"AUC: {auc_comp_rf:.4f}")Didukung oleh

Keluaran:

Scenario 3: Random Forest (Comprehensive Features)

Features used: First 10 features

Accuracy: 0.9415

AUC: 0.9878Didukung oleh

Mari plot dan bandingkan confusion matrix untuk setiap kasus:

fig, axes = plt.subplots(1, 3, figsize=(20, 5))
fig.suptitle('Comparison of Model Performance (Confusion Matrices on Test Set)', fontsize=16)

# Model 1: Logistic Regression (Limited Features)
cm_lim = confusion_matrix(y_test, y_pred_lim)
disp_lim = ConfusionMatrixDisplay(confusion_matrix=cm_lim, display_labels=cancer.target_names)
disp_lim.plot(ax=axes[0], cmap='Blues')
axes[0].set_title(f'LogReg (Limited Features)\nAcc: {acc_lim:.2f}, AUC: {auc_lim:.2f}')

# Model 2: Logistic Regression (Comprehensive Features)
cm_comp_lr = confusion_matrix(y_test, y_pred_comp_lr)
disp_comp_lr = ConfusionMatrixDisplay(confusion_matrix=cm_comp_lr, display_labels=cancer.target_names)
disp_comp_lr.plot(ax=axes[1], cmap='Greens')
axes[1].set_title(f'LogReg (Comprehensive Features)\nAcc: {acc_comp_lr:.2f}, AUC: {auc_comp_lr:.2f}')

# Model 3: Random Forest (Comprehensive Features)
cm_comp_rf = confusion_matrix(y_test, y_pred_comp_rf)
disp_comp_rf = ConfusionMatrixDisplay(confusion_matrix=cm_comp_rf, display_labels=cancer.target_names)
disp_comp_rf.plot(ax=axes[2], cmap='Oranges')
axes[2].set_title(f'Random Forest (Comprehensive Features)\nAcc: {acc_comp_rf:.2f}, AUC: {auc_comp_rf:.2f}')

plt.tight_layout(rect=[0, 0, 1, 0.96]) # Adjust layout to make space for suptitle
plt.show()Didukung oleh

Keluaran:

Dalam studi kasus ini, model LogisticRegression awal yang dilatih hanya pada dua fitur (Skenario 1) diperkirakan underfitting karena informasi yang tidak memadai, menghasilkan akurasi dan AUC yang buruk. 

Kinerja biasanya meningkat ketika algoritme yang sama diberi set fitur yang lebih komprehensif (Skenario 2), karena memiliki lebih banyak data untuk dipelajari, sehingga mengurangi bias.

Peningkatan lebih lanjut sering terlihat dengan menggunakan algoritme yang lebih kompleks seperti RandomForestClassifier dengan set fitur komprehensif (Skenario 3), karena dapat menangkap non-linearitas dan interaksi fitur dengan lebih efektif, lebih lanjut mengurangi bias dan meningkatkan kecocokan model terhadap data.

Topik Lanjutan dan Arah Masa Depan

Meskipun kita telah membahas hal-hal mendasar, lanskap machine learning selalu berkembang. Berikut sekilas bagaimana underfitting berkaitan dengan area yang lebih maju.

Peran deep learning

Model deep learning, khususnya deep neural network dengan banyak lapisan, dikenal memiliki kapasitas tinggi, artinya secara teoritis dapat mendekati fungsi yang sangat kompleks.

Karena kompleksitasnya yang melekat, model deep learning umumnya lebih jarang mengalami underfitting dibanding model yang lebih sederhana, asalkan dilatih dengan benar pada data yang memadai. Strukturnya memungkinkan mereka secara otomatis mempelajari representasi fitur yang rumit dari data mentah (seperti piksel pada gambar atau kata pada teks).

Namun, deep learning tidak kebal terhadap masalah yang terlihat seperti underfitting. Jika jaringan dirancang buruk (misalnya, kedalaman/lebar tidak memadai untuk tugas), tidak dilatih cukup lama, atau menggunakan fungsi aktivasi atau algoritme optimisasi yang tidak sesuai, jaringan bisa gagal konvergen dan menunjukkan galat pelatihan tinggi.

Inovasi arsitektural seperti residual connection (ResNet) dan teknik normalisasi (Batch Normalization) membantu melatih jaringan yang sangat dalam secara efektif, mengurangi masalah gradien hilang/meledak dan memungkinkan mencapai kapasitas penuh, sehingga menghindari masalah konvergensi yang menyerupai underfitting.

Automated machine learning (AutoML)

Menemukan model, fitur, dan hiperparameter yang tepat untuk menghindari underfitting dan overfitting bisa memakan waktu. AutoML bertujuan mengotomatisasi proses ini.

Kerangka kerja AutoML dapat secara otomatis mengeksplorasi berbagai jenis model (dari model linear hingga ensemble dan neural network yang kompleks), melakukan rekayasa dan seleksi fitur, serta mengoptimalkan hiperparameter. Dengan secara sistematis menelusuri ruang kemungkinan yang luas, AutoML dapat mengidentifikasi konfigurasi model yang memiliki kompleksitas cukup untuk menghindari underfitting pada data.

Metode seperti Neural Architecture Search (NAS) secara otomatis merancang arsitektur jaringan, sementara teknik optimisasi hiperparameter canggih (mis., Bayesian Optimization) secara efisien menemukan pengaturan hiperparameter yang baik. Alat-alat ini dapat mempercepat proses menemukan model yang pas, mengurangi upaya manual untuk mendiagnosis dan memperbaiki model yang underfitting.

Kesimpulan

Memahami dilema underfitting vs overfitting merupakan dasar bagi machine learning yang sukses. Kita telah melihat bahwa underfitting muncul ketika model terlalu sederhana (bias tinggi) untuk menangkap tren mendasar dalam data, sehingga kinerjanya buruk pada data pelatihan maupun data yang belum terlihat. Penyebab kunci termasuk kompleksitas model yang tidak memadai, fitur yang buruk, pelatihan yang tidak memadai, dan regularisasi berlebihan.

Mendiagnosis underfitting melibatkan pemeriksaan metrik kinerja, memplot kurva pembelajaran, dan membandingkan model, sering kali dibantu dengan kode. Untungnya, kita memiliki beberapa strategi untuk memperbaiki underfitting: meningkatkan kompleksitas model (memilih algoritme yang lebih baik, ekspansi fitur, penyetelan hiperparameter), memperbaiki fitur (rekayasa fitur, pemerkayaan data), menyesuaikan regularisasi, dan menerapkan metode ensemble yang kuat, seperti yang ditunjukkan dalam contoh kode kami.

Untuk mempelajari teknik-teknik ini dan lainnya dengan contoh praktis, lihat Machine Learning Fundamentals in Python skill track kami.