Last chance! 50% off DataCamp Premium
Sale ends in
Ada dua penyebab utama galat pada model machine learning:
- Bias menggambarkan model yang membuat asumsi yang disederhanakan agar fungsi target lebih mudah diaproksimasi; sebuah model mungkin mempelajari bahwa setiap pria dengan tinggi 5'9 di dunia memakai atasan ukuran medium — ini jelas bias.
- Varians menggambarkan keragaman pada prediksi model; seberapa banyak prediksi model berubah ketika kita mengubah data yang digunakan untuk melatihnya.
Untuk memperoleh solusi yang lebih akurat, kita berupaya mengurangi jumlah bias dan varians dalam model. Ini bukan tugas yang mudah. Bias dan varians saling berlawanan — mengurangi yang satu akan meningkatkan yang lain karena adanya konsep yang dikenal sebagai bias-variance tradeoff.
Dalam artikel ini Anda akan mempelajari:
- Cara mendeteksi apakah sebuah model mengalami bias tinggi atau varians tinggi
- Cara mendiagnosis model yang menderita salah satu gejala
- Cara membangun model dengan kecocokan yang baik
Sebelum masuk ke deteksi gejala galat, mari terlebih dahulu membahas lebih dalam mengenai bias-variance tradeoff.
Melihat bias-variance tradeoff
Semua algoritma pembelajaran terawasi berupaya mencapai tujuan yang sama: mengestimasi fungsi pemetaan (f_hat) untuk variabel target (y) berdasarkan beberapa data masukan (X). Kita menyebut fungsi yang diupayakan model machine learning untuk diaproksimasi sebagai fungsi target.
Mengubah data masukan yang digunakan untuk mengaproksimasi variabel target kemungkinan akan menghasilkan fungsi target yang berbeda, yang dapat memengaruhi keluaran yang diprediksi model. Seberapa besar fungsi target kita berubah saat data pelatihan diubah disebut varians. Kita tidak menginginkan model dengan varians tinggi karena meskipun algoritme mungkin berkinerja sempurna saat pelatihan, ia gagal melakukan generalisasi ke instance yang belum pernah dilihat.
Pada gambar di atas, fungsi target teraproksimasi adalah garis hijau dan garis regresi terbaik berwarna hitam. Perhatikan betapa baiknya model mempelajari data pelatihan dengan garis hijau. Model berupaya sebaik mungkin memastikan semua observasi merah dan biru terpisah. Jika kita melatih model ini pada observasi baru, ia akan mempelajari fungsi target yang sama sekali baru dan mencoba menerapkan perilaku yang sama.
Pertimbangkan skenario ketika kita menggunakan metode linear seperti regresi linear untuk mengaproksimasi fungsi target. Hal pertama yang perlu dicatat tentang regresi linear adalah ia mengasumsikan hubungan linear antara data masukan dan target yang ingin kita prediksi. Kejadian di dunia nyata jauh lebih kompleks. Dengan mengorbankan sebagian fleksibilitas, asumsi sederhana ini membuat fungsi target jauh lebih cepat dipelajari dan lebih mudah dipahami. Paradigma ini kita sebut sebagai Bias.
Pada gambar di atas, garis merah merepresentasikan fungsi target yang dipelajari. Banyak observasi berada jauh dari nilai yang diprediksi model.
Kita dapat mengurangi bias pada model dengan membuatnya lebih fleksibel, namun hal ini akan memperkenalkan varians. Sebaliknya, kita bisa mengurangi varians model dengan menyederhanakannya, tetapi ini akan memperkenalkan bias. Tidak ada cara untuk lepas dari hubungan ini. Alternatif terbaik adalah memilih model dan mengonfigurasinya sedemikian rupa sehingga menyeimbangkan tradeoff antara bias dan varians.
Akibat faktor tak diketahui yang memengaruhi fungsi target, akan selalu ada sebagian galat pada model, yang dikenal sebagai irreducible error. Ini dapat diamati pada gambar di atas dengan mencermati besarnya galat yang terjadi di bawah titik terendah pada plot Total Error. Untuk membangun model ideal, kita harus menemukan keseimbangan antara bias dan varians sehingga total galat diminimalkan. Hal ini diilustrasikan dengan garis putus-putus bernama Optimum Model Complexity.
Mari kita perluas pembahasan bias dan varians menggunakan learning curve.
Anatomi sebuah learning curve
Learning curve adalah plot yang digunakan untuk menunjukkan kinerja model seiring bertambahnya ukuran himpunan pelatihan. Cara lain penggunaannya adalah untuk menunjukkan kinerja model selama periode waktu tertentu. Biasanya kita menggunakannya untuk mendiagnosis algoritme yang belajar secara inkremental dari data. Caranya adalah dengan mengevaluasi model pada dataset pelatihan dan validasi, lalu memplot kinerja yang terukur.
Misalnya, bayangkan kita telah memodelkan hubungan antara beberapa masukan dan keluaran menggunakan algoritme machine learning. Kita mulai dengan melatih model pada satu instance dan memvalidasinya terhadap seratus instance. Apa yang akan terjadi? Jika Anda menjawab model akan mempelajari data pelatihan dengan sempurna maka Anda benar — tidak akan ada galat.
Tidak sulit memodelkan hubungan satu masukan ke satu keluaran; yang perlu dilakukan hanyalah mengingat hubungan itu. Bagian sulitnya adalah membuat prediksi akurat ketika dihadapkan pada instance baru yang belum pernah dilihat. Karena model kita sangat mahir mempelajari data pelatihan, ia akan kesulitan melakukan generalisasi ke data yang belum pernah dilihat sebelumnya. Akibatnya, model akan berkinerja buruk pada data validasi. Ini berarti akan ada perbedaan besar antara kinerja model pada data pelatihan dan data validasi. Kita menyebut perbedaan ini sebagai generalization error.
Jika algoritme kita ingin berpeluang membuat prediksi yang lebih baik pada dataset validasi, kita perlu menambahkan lebih banyak data. Memasukkan instance baru ke data pelatihan pada akhirnya akan mengubah fungsi target model kita. Bagaimana kinerja model saat kita menambah dataset pelatihan dapat dipantau dan diplot untuk menunjukkan evolusi skor galat pelatihan dan validasi.
Ini berarti grafik akan menampilkan dua hasil berbeda:
- Kurva pelatihan: Kurva yang dihitung dari data pelatihan; digunakan untuk memberi tahu seberapa baik model belajar.
- Kurva validasi: Kurva yang dihitung dari data validasi; digunakan untuk memberi tahu seberapa baik model melakukan generalisasi ke instance yang belum terlihat.
Kurva-kurva ini menunjukkan seberapa baik kinerja model saat data bertambah, karenanya disebut learning curves.
Catatan: Proses yang sama dapat digunakan untuk memberi tahu kita bagaimana model belajar seiring waktu. Alih-alih memantau kinerja model saat data semakin besar, kita memantau seberapa baik model belajar dari waktu ke waktu. Misalnya, Anda memutuskan untuk belajar bahasa baru. Penguasaan Anda atas bahasa tersebut dapat dievaluasi dan diberi skor numerik untuk menunjukkan bagaimana kemajuan Anda selama 52 minggu.
Sekarang Anda telah mempelajari anatomi learning curve; mari mempraktikkannya dengan dataset dunia nyata agar Anda mendapatkan pemahaman visual.
Use case: Memprediksi valuasi real estat
Kita akan menggunakan dataset: data historis pasar untuk valuasi real estat. Data ini dikumpulkan dari Sindian Dist., New Taipei, Taiwan dan terdiri dari data historis pasar.
Tugas kita adalah memprediksi valuasi real estat berdasarkan fitur-fitur berikut:
- X1=tanggal transaksi (misalnya, 2013.250=2013 Maret, 2013.500=2013 Juni, dst.)
- X2=usia rumah (satuan: tahun)
- X3=jarak ke stasiun MRT terdekat (satuan: meter)
- X4=jumlah minimarket dalam radius berjalan kaki (bilangan bulat)
- X5=koordinat geografis, lintang. (satuan: derajat)
- X6=koordinat geografis, bujur. (satuan: derajat)
Variabel target didefinisikan sebagai:
- Y= harga rumah per satuan area (10000 Dolar Taiwan Baru/Ping, di mana Ping adalah satuan lokal, 1 Ping = 3,3 meter persegi)
Target yang kita prediksi bersifat kontinu, sehingga masalah ini memerlukan teknik regresi.
Mari mulai dengan mengintip datanya:
import pandas as pd
data = pd.read_excel("/content/gdrive/MyDrive/real_estate_valuation_data.xlsx")
print(data.info())
data.head()
>>>>
<class 'pandas.core.frame.DataFrame'>
RangeIndex: 414 entries, 0 to 413
Data columns (total 8 columns):
# Column Non-Null Count Dtype
--- ------ -------------- -----
0 No 414 non-null int64
1 X1 transaction date 414 non-null float64
2 X2 house age 414 non-null float64
3 X3 distance to the nearest MRT station 414 non-null float64
4 X4 number of convenience stores 414 non-null int64
5 X5 latitude 414 non-null float64
6 X6 longitude 414 non-null float64
7 Y house price of unit area 414 non-null float64
dtypes: float64(6), int64(2)
memory usage: 26.0 KB
None
No X1 transaction date X2 house age X3 distance to the nearest MRT station X4 number of convenience stores X5 latitude X6 longitude Y house price of unit area
0 1 2012.916667 32.0 84.87882 10 24.98298 121.54024 37.9
1 2 2012.916667 19.5 306.59470 9 24.98034 121.53951 42.2
2 3 2013.583333 13.3 561.98450 5 24.98746 121.54391 47.3
3 4 2013.500000 13.3 561.98450 5 24.98746 121.54391 54.8
4 5 2012.833333 5.0 390.56840 5 24.97937 121.54245 43.1
Ada fitur tambahan bernama No yang tidak dirujuk dalam dokumentasi data. Mungkin ini merujuk ke indeks, tetapi demi kesederhanaan akan kita hapus. Selain itu, nama fitur tidak mencerminkan apa yang tercantum dalam dokumentasi sehingga akan kita rapikan.
# rename the columns
renamed_columns = [col.split()[0] for col in data.columns]
renamed_columns_map = {data.columns[i]:renamed_columns[i] for i in range(len(data.columns))}
data.rename(renamed_columns_map, axis=1, inplace=True)
# remove No column
data.drop("No", axis=1, inplace=True)
print(data.head())
# separate features and target data
features, target = data.columns[:-1], data.columns[-1]
X = data[features]
y = data[target]
Beginilah tampilan dataset final sebelum kita memisahkan fitur dan label target:
X1 X2 X3 X4 X5 X6 Y
0 2012.916667 32.0 84.87882 10 24.98298 121.54024 37.9
1 2012.916667 19.5 306.59470 9 24.98034 121.53951 42.2
2 2013.583333 13.3 561.98450 5 24.98746 121.54391 47.3
3 2013.500000 13.3 561.98450 5 24.98746 121.54391 54.8
4 2012.833333 5.0 390.56840 5 24.97937 121.54245 43.1
Untuk mendemonstrasikan bias, varians, dan solusi dengan kecocokan baik, kita akan membangun tiga model: decision tree regressor, support vector machine untuk regresi, dan random forest regressor. Setelah membangun model, kita akan memplot learning curve untuk masing-masing dan membagikan beberapa teknik diagnostik.
Mendiagnosis learning curve
Learning curve ditafsirkan dengan menilai bentuknya. Setelah bentuk dan dinamika ditafsirkan, kita dapat menggunakannya untuk mendiagnosis masalah dalam perilaku model machine learning.
Fungsi learning_curve() di Scikit-learn memudahkan kita memantau skor pelatihan dan validasi, yang diperlukan untuk memplot learning curve.
Parameter yang kita berikan ke fungsi learning_curve() adalah sebagai berikut:
- estimator: model yang digunakan untuk mengaproksimasi fungsi target
- X: data masukan
- y: target
- cv: strategi pembagian cross-validation
- scoring: metrik yang digunakan untuk mengevaluasi kinerja model
- train_sizes: jumlah absolut contoh pelatihan yang akan digunakan untuk menghasilkan learning curve; nilai yang kita gunakan sepenuhnya acak.
Model 1: Decision tree regressor
Model dengan varians tinggi disebut overfit. Ia mempelajari data pelatihan dan noise acak dengan sangat baik, sehingga menghasilkan model yang berkinerja baik pada data pelatihan tetapi gagal melakukan generalisasi ke instance yang belum terlihat. Kita mengamati perilaku tersebut ketika algoritme yang digunakan terlalu fleksibel untuk masalah yang diselesaikan, atau ketika model dilatih terlalu lama.
Contohnya, decision tree regressor adalah algoritme machine learning non-linear. Algoritme non-linear biasanya memiliki bias rendah dan varians tinggi. Ini menyiratkan bahwa perubahan pada dataset akan menyebabkan variasi besar pada fungsi target.
Mari mendemonstrasikan varians tinggi dengan decision tree regressor kita:
from sklearn.model_selection import learning_curve
from sklearn.tree import DecisionTreeRegressor
import matplotlib.pyplot as plt
# overfitting
decision_tree = DecisionTreeRegressor()
train_sizes, train_scores, test_scores = learning_curve(
estimator=decision_tree,
X=X,
y=y,
cv=5,
scoring="neg_root_mean_squared_error",
train_sizes = [1, 75, 165, 270, 331]
)
train_mean = -train_scores.mean(axis=1)
test_mean = -test_scores.mean(axis=1)
plt.subplots(figsize=(10,8))
plt.plot(train_sizes, train_mean, label="train")
plt.plot(train_sizes, test_mean, label="validation")
plt.title("Learning Curve")
plt.xlabel("Training Set Size")
plt.ylabel("RMSE")
plt.legend(loc="best")
plt.show()
Model membuat sangat sedikit kesalahan ketika diminta memprediksi instance yang telah dilihat saat pelatihan, namun berkinerja buruk pada instance baru yang belum pernah dipaparkan. Anda dapat mengamati perilaku ini dengan memperhatikan betapa besarnya generalization error antara kurva pelatihan dan kurva validasi. Salah satu solusi untuk memperbaiki perilaku ini adalah menambahkan lebih banyak instance ke dataset pelatihan yang akan memperkenalkan bias. Solusi lain adalah menambahkan regularisasi pada model (mis. membatasi pertumbuhan pohon hingga kedalaman maksimum tertentu).
Model 2: Support Vector Machine
Model dengan bias tinggi disebut underfit. Ia membuat asumsi sederhana tentang data pelatihan, sehingga sulit mempelajari pola yang mendasarinya. Akibatnya, model memiliki galat tinggi pada dataset pelatihan dan validasi. Kita dapat mengamati perilaku tersebut ketika model yang digunakan terlalu sederhana untuk masalah yang diselesaikan, atau ketika model tidak dilatih cukup lama.
Misalnya, support vector machine adalah algoritme machine learning linear. Algoritme linear biasanya memiliki bias tinggi dan varians rendah. Ini menyiratkan lebih banyak asumsi dibuat mengenai bentuk fungsi target. Untuk memperkenalkan lebih banyak bias ke model, kita menambahkan regularisasi dengan mengatur parameter C pada model.
Mari mendemonstrasikan bias tinggi dengan support vector machine kita:
from sklearn.svm import SVR
from sklearn.preprocessing import StandardScaler
# Underfitting
scaler = StandardScaler()
X_scaled = scaler.fit_transform(X)
svm = SVR(C=0.25)
train_sizes, train_scores, test_scores = learning_curve(
estimator=svm,
X=X_scaled,
y=y,
cv=5,
scoring="neg_root_mean_squared_error",
train_sizes = [1, 75, 150, 270, 331]
)
train_mean = -train_scores.mean(axis=1)
test_mean = -test_scores.mean(axis=1)
plt.subplots(figsize=(10,8))
plt.plot(train_sizes, train_mean, label="train")
plt.plot(train_sizes, test_mean, label="validation")
plt.title("Learning Curve")
plt.xlabel("Training Set Size")
plt.ylabel("RMSE")
plt.legend(loc="best")
plt.show()
Kesenjangan generalisasi untuk kurva pelatihan dan validasi menjadi sangat kecil seiring bertambahnya ukuran dataset pelatihan. Ini menunjukkan bahwa menambahkan lebih banyak contoh ke model tidak akan meningkatkan kinerjanya. Solusi untuk masalah ini bisa berupa membuat lebih banyak fitur atau membuat model lebih fleksibel untuk mengurangi jumlah asumsi yang dibuat.
Model 3: Random Forest Regressor
Model dengan kecocokan baik berada di area abu-abu antara model underfit dan overfit. Model mungkin tidak sebaik pada data pelatihan seperti pada kasus overfit, tetapi akan membuat jauh lebih sedikit kesalahan saat menghadapi instance yang belum terlihat. Perilaku ini dapat diamati ketika galat pelatihan meningkat, tetapi hanya sampai titik stabil, sementara galat validasi menurun hingga titik stabil.
Untuk mendemonstrasikan hal ini kita akan menggunakan random forest yang merupakan ansambel decision tree. Ini berarti model juga non-linear, tetapi bias ditambahkan ke model dengan membuat beberapa model yang beragam dan menggabungkan prediksi mereka.
Kita juga menambahkan regularisasi dengan mengatur max_depth, yang mengontrol kedalaman maksimum setiap pohon, ke nilai tiga.
Mari lihat bagaimana tampilannya dalam kode:
from sklearn.ensemble import RandomForestRegressor
# better
random_forest = RandomForestRegressor(max_depth=3)
train_sizes, train_scores, test_scores = learning_curve(
estimator=random_forest,
X=X,
y=y,
cv=5,
scoring="neg_root_mean_squared_error",
train_sizes = [1, 75, 150, 270, 331]
)
train_mean = -train_scores.mean(axis=1)
test_mean = -test_scores.mean(axis=1)
plt.subplots(figsize=(10,8))
plt.plot(train_sizes, train_mean, label="train")
plt.plot(train_sizes, test_mean, label="validation")
plt.title("Learning Curve")
plt.xlabel("Training Set Size")
plt.ylabel("RMSE")
plt.legend(loc="best")
plt.show()
Sekarang Anda dapat melihat kita telah mengurangi galat pada data validasi. Ini datang dengan konsekuensi kinerja yang melemah pada data pelatihan, tetapi secara keseluruhan modelnya lebih baik.
Generalization error jauh lebih kecil, dengan jumlah kesalahan yang rendah. Selain itu, kedua kurva stabil setelah ukuran himpunan pelatihan 250, yang menyiratkan bahwa menambahkan lebih banyak instance mungkin tidak banyak meningkatkan model ini.
Singkatnya, perilaku model dapat diamati menggunakan learning curve. Skenario ideal saat membangun model machine learning adalah menjaga galat serendah mungkin. Dua faktor yang mengakibatkan galat tinggi adalah bias dan varians, dan mampu menyeimbangkan keduanya akan menghasilkan model yang berkinerja lebih baik.
Topik
