Regresi Nonlinier: Ilustrasi Pemodelan dan Evaluasi Model
Dalam dunia nyata, tidak semua hubungan antar variabel bersifat linier. Banyak fenomena alam, sosial, maupun ekonomi menunjukkan pola hubungan yang melengkung (nonlinier), sehingga tidak dapat dimodelkan secara akurat menggunakan regresi linier biasa. Untuk menangkap kompleksitas tersebut, regresi nonlinier menjadi alternatif yang lebih fleksibel dan representatif.
Secara umum, regresi nonlinier adalah pendekatan pemodelan statistik yang menggambarkan hubungan antara variabel prediktor dan respons melalui fungsi nonlinier, misalnya fungsi polinomial, eksponensial, logaritmik, trigonometri, ataupun fungsi potongan (step function). Bentuk umum model nonlinier dapat dituliskan sebagai:
\[ Y = f(X, \beta) + \varepsilon \]
di mana \(f(X, \beta)\) adalah fungsi nonlinier terhadap prediktor \(X\) dan parameter \(\beta\), sedangkan \(\varepsilon\) merupakan galat.
Tujuan dari model ini tetap sama seperti regresi linier: meminimalkan jumlah kuadrat galat (sum of squared errors) agar model dapat memprediksi nilai \(Y\) seakurat mungkin terhadap data observasi.
Dalam praktikum ini, kita akan mengulas kembali materi yang telah dibahas dalam Kuliah 8 dengan menekankan dua pendekatan utama regresi nonlinier:
Melalui ilustrasi data bangkitan di R, peserta diharapkan dapat memahami bagaimana kedua pendekatan ini diterapkan secara praktis dan bagaimana cara membandingkan performa model berdasarkan visualisasi dan metrik evaluasi seperti \(R^2\), MSE, dan interpretasi plot hasil regresi.
Untuk mengeksplorasi regresi nonlinier secara sistematis, kita akan menggunakan data simulasi. Pendekatan ini memungkinkan kita untuk merancang hubungan antara variabel prediktor dan respons secara eksplisit sehingga memudahkan evaluasi model.
Dalam simulasi ini, kita bangkitkan nilai-nilai \(x\) dari distribusi normal, kemudian membentuk nilai \(y\) berdasarkan model kuadratik:
\[ y = 5 + 2x + 3x^2 + \varepsilon \]
dengan \(\varepsilon \sim N(0, 1)\) sebagai komponen galat acak (noise).
# Set seed untuk replikasi
set.seed(12)
# Bangkitkan data x dan error
x <- rnorm(1000, mean = 1, sd = 1)
epsilon <- rnorm(1000)
# Bentuk data y sesuai model kuadratik
y <- 5 + 2 * x + 3 * x^2 + epsilon
# Visualisasi sebaran data
plot(x, y,
main = "Data Simulasi",
xlab = "x", ylab = "y",
col = "steelblue",
xlim = c(-2.5, 4.5),
ylim = c(-15, 70))
Sebagai langkah awal, kita gunakan regresi linier sederhana untuk memodelkan hubungan antara \(x\) dan \(y\). Meskipun data kita mengandung pola kuadratik, regresi linier sering dijadikan baseline model untuk menilai seberapa besar peningkatan akurasi dari model yang lebih kompleks.
# Model regresi linier
mod_lin <- lm(y ~ x)
# Tampilkan ringkasan model
summary(mod_lin)
Call:
lm(formula = y ~ x)
Residuals:
Min 1Q Median 3Q Max
-5.582 -2.399 -1.365 1.159 26.396
Coefficients:
Estimate Std. Error t value Pr(>|t|)
(Intercept) 4.8936 0.1855 26.38 <2e-16 ***
x 7.8990 0.1357 58.19 <2e-16 ***
---
Signif. codes: 0 '***' 0.001 '**' 0.01 '*' 0.05 '.' 0.1 ' ' 1
Residual standard error: 4.116 on 998 degrees of freedom
Multiple R-squared: 0.7724, Adjusted R-squared: 0.7721
F-statistic: 3386 on 1 and 998 DF, p-value: < 2.2e-16Kita juga dapat menghitung Mean Squared Error (MSE) sebagai metrik evaluasi performa model.
R2_lin <- summary(mod_lin)$r.squared
y_pred_lin <- predict(mod_lin)
mse_lin <- mean((y - y_pred_lin)^2)
mse_lin[1] 16.90773Berikut grafik sebaran data dan garis regresi linier yang dihasilkan.
plot(x, y,
main = "Model Regresi Linier",
xlab = "x", ylab = "y",
col = "steelblue",
xlim = c(-2.5, 4.5),
ylim = c(-15, 70))
# Tambahkan garis prediksi regresi linier
lines(sort(x), y_pred_lin[order(x)],
col = "red", lwd = 2)
legend("topleft",
legend = c("Data", "Regresi Linier"),
col = c("steelblue", "red"),
pch = c(16, NA), lty = c(NA, 1), lwd = c(NA, 2))
Model regresi linier yang diperoleh adalah:
\[ \hat{y} = 4.8936 + 7.8990x \]
Model ini menunjukkan bahwa setiap kenaikan satu satuan pada \(x\), rata-rata nilai \(y\) meningkat sebesar \(7.8990\), dengan intercept sekitar \(4.89\). Model memiliki \(R^2=0.7724\) Artinya, sekitar \(77.24%\) variasi dalam data \(y\) dapat dijelaskan oleh model linier ini. Meskipun angka ini cukup tinggi, kita tahu bahwa data sebenarnya memiliki hubungan kuadratik, sehingga model linier ini tidak sepenuhnya menangkap pola sebenarnya. Nilai Mean Squared Error yang cukup (\(16.91\))besar menunjukkan bahwa terdapat deviasi yang cukup signifikan antara nilai prediksi dengan data asli, terutama di bagian ekstrem kurva. Berdasarkan visualisasi, model linier tidak mampu menggambarkan kelengkungan yang ada pada hubungan antara \(x\) dan \(y\). Hal ini akan terlihat lebih jelas saat kita membandingkannya dengan model regresi polinomial pada bagian selanjutnya.
Regresi polinomial merupakan perluasan dari model regresi linier, di mana hubungan antara prediktor dan respons dimodelkan dengan fungsi polinomial. Jika model linier hanya memuat satu suku \(x\), maka regresi polinomial dapat memasukkan pangkat-pangkat lebih tinggi dari \(x\), seperti \(x^2, x^3, \dots, x^d\).
Model linier:
\[ y_i = \beta_0 + \beta_1 x_i + \varepsilon_i \]
Model polinomial derajat \(d\):
\[ y_i = \beta_0 + \beta_1 x_i + \beta_2 x_i^2 + \beta_3 x_i^3 + \cdots + \beta_d x_i^d + \varepsilon_i \]
Model polinomial dapat diduga menggunakan Metode Kuadrat Terkecil (OLS) karena bentuknya tetap linier terhadap parameter. Namun, penggunaan derajat polinomial \(d\) yang terlalu tinggi (misalnya lebih dari 4) tidak dianjurkan, karena model menjadi sangat fleksibel dan cenderung overfitting, bahkan menyerupai bentuk kurva yang tidak realistis.
Model regresi polinomial orde dua memperluas model linier dengan menambahkan suku kuadrat dari prediktor \(x\), sehingga memungkinkan model menangkap hubungan nonlinier berbentuk parabola.
Model umum: \[ y = \beta_0 + \beta_1 x + \beta_2 x^2 + \varepsilon \]
# Model polinomial orde 2
x2 <- x^2
mod_poly2 <- lm(y ~ x + x2)
summary(mod_poly2)
Call:
lm(formula = y ~ x + x2)
Residuals:
Min 1Q Median 3Q Max
-3.08063 -0.68591 0.00314 0.68072 3.14320
Coefficients:
Estimate Std. Error t value Pr(>|t|)
(Intercept) 5.04323 0.04626 109.02 <2e-16 ***
x 2.02518 0.05862 34.55 <2e-16 ***
x2 2.98241 0.02430 122.72 <2e-16 ***
---
Signif. codes: 0 '***' 0.001 '**' 0.01 '*' 0.05 '.' 0.1 ' ' 1
Residual standard error: 1.026 on 997 degrees of freedom
Multiple R-squared: 0.9859, Adjusted R-squared: 0.9858
F-statistic: 3.477e+04 on 2 and 997 DF, p-value: < 2.2e-16# Prediksi nilai y
y_pred_poly2 <- predict(mod_poly2)
# Evaluasi performa model
R2_poly2 <- summary(mod_poly2)$r.squared
mse_poly2 <- mean((y - y_pred_poly2)^2)
mse_poly2[1] 1.049859plot(x, y,
main = "Regresi Polinomial Orde 2",
xlab = "x", ylab = "y",
col = "steelblue",
xlim = c(-2.5, 4.5),
ylim = c(-15, 70))
# Tambahkan garis prediksi model polinomial orde 2
lines(sort(x), y_pred_poly2[order(x)],
col = "blue", lwd = 2)
legend("topleft",
legend = c("Data", "Polinomial Orde 2"),
col = c("steelblue", "blue"),
pch = c(16, NA), lty = c(NA, 1), lwd = c(NA, 2))
Model polinomial orde dua yang dihasilkan dari proses estimasi adalah:
\[ \hat{y} = 5.0432 + 2.0252x + 2.9824x^2 \]
Model ini menunjukkan peningkatan performa yang signifikan dibandingkan model regresi linier. Nilai \(R^2\) adalah \(0.9859\) mengindikasikan bahwa sekitar \(98.59%\) variasi dalam data \(y\) dapat dijelaskan oleh model polinomial orde dua ini. Sementara itu, nilai galat kuadrat rata-rata atau Mean Squared Error (MSE) yang dihasilkan sebesar \(1.0499\), jauh lebih kecil dibandingkan model linier sebelumnya. Hal ini menunjukkan bahwa model polinomial orde dua mampu menangkap struktur nonlinier pada data dengan lebih akurat dan efisien, baik secara kuantitatif maupun visual.
Model regresi polinomial orde tiga memperluas model orde dua dengan menambahkan suku pangkat tiga dari prediktor \(x\), sehingga model menjadi lebih fleksibel dalam menangkap pola data yang kompleks dan asimetris.
Model umum: \[ y = \beta_0 + \beta_1 x + \beta_2 x^2 + \beta_3 x^3 + \varepsilon \]
# Model polinomial orde 3
x3 <- x^3
mod_poly3 <- lm(y ~ x + x2 + x3)
summary(mod_poly3)
Call:
lm(formula = y ~ x + x2 + x3)
Residuals:
Min 1Q Median 3Q Max
-3.09660 -0.68471 -0.01173 0.66982 3.15116
Coefficients:
Estimate Std. Error t value Pr(>|t|)
(Intercept) 5.07339 0.05393 94.075 <2e-16 ***
x 2.02618 0.05862 34.563 <2e-16 ***
x2 2.93386 0.05082 57.725 <2e-16 ***
x3 0.01640 0.01508 1.088 0.277
---
Signif. codes: 0 '***' 0.001 '**' 0.01 '*' 0.05 '.' 0.1 ' ' 1
Residual standard error: 1.026 on 996 degrees of freedom
Multiple R-squared: 0.9859, Adjusted R-squared: 0.9858
F-statistic: 2.318e+04 on 3 and 996 DF, p-value: < 2.2e-16# Prediksi nilai y
y_pred_poly3 <- predict(mod_poly3)
# Evaluasi performa model
R2_poly3 <- summary(mod_poly3)$r.squared
mse_poly3 <- mean((y - y_pred_poly3)^2)
mse_poly3[1] 1.048614plot(x, y,
main = "Regresi Polinomial Orde 3",
xlab = "x", ylab = "y",
col = "steelblue",
xlim = c(-2.5, 4.5),
ylim = c(-15, 70))
# Tambahkan garis prediksi model polinomial orde 3
lines(sort(x), y_pred_poly3[order(x)],
col = "darkorange", lwd = 2)
legend("topleft",
legend = c("Data", "Polinomial Orde 3"),
col = c("steelblue", "darkorange"),
pch = c(16, NA), lty = c(NA, 1), lwd = c(NA, 2))
Model regresi polinomial orde tiga yang diperoleh dari hasil estimasi adalah:
\[ \hat{y} = 5.0734 + 2.0262x + 2.9339x^2 + 0.0164x^3 \]
Secara umum, model ini memiliki performa yang sangat mirip dengan model polinomial orde dua. Nilai \(R^2\) adalah \(0.9859\) menunjukkan bahwa sekitar \(98.59%\) variasi dalam data dapat dijelaskan oleh model. Sementara itu, nilai Mean Squared Error (MSE) yang diperoleh adalah \(1.0486\), hanya sedikit lebih kecil dibandingkan MSE model orde dua.
Namun demikian, koefisien dari suku pangkat tiga \(x^3\) tidak signifikan secara statistik (p-value=\(0.277\)), yang menunjukkan bahwa penambahan komponen orde tiga tidak memberikan kontribusi berarti terhadap peningkatan akurasi model. Dengan demikian, meskipun performa keseluruhan model tetap baik, model polinomial orde dua tetap lebih efisien dan cukup representatif untuk memodelkan hubungan antara \(x\) dan \(y\).
Model regresi polinomial orde empat menambahkan suku pangkat empat dari prediktor \(x\), sehingga model memiliki fleksibilitas yang lebih tinggi untuk menangkap pola kompleks dan fluktuasi data. Namun, kehati-hatian diperlukan karena model dengan derajat tinggi rentan terhadap overfitting.
Model umum:
\[ y = \beta_0 + \beta_1 x + \beta_2 x^2 + \beta_3 x^3 + \beta_4 x^4 + \varepsilon \]
# Model polinomial orde 4
x4 <- x^4
mod_poly4 <- lm(y ~ x + x2 + x3 + x4)
summary(mod_poly4)
Call:
lm(formula = y ~ x + x2 + x3 + x4)
Residuals:
Min 1Q Median 3Q Max
-3.1199 -0.6909 -0.0038 0.6710 3.1677
Coefficients:
Estimate Std. Error t value Pr(>|t|)
(Intercept) 5.088006 0.056699 89.737 <2e-16 ***
x 1.975630 0.084200 23.463 <2e-16 ***
x2 2.930456 0.050995 57.466 <2e-16 ***
x3 0.045554 0.037976 1.200 0.231
x4 -0.007338 0.008773 -0.836 0.403
---
Signif. codes: 0 '***' 0.001 '**' 0.01 '*' 0.05 '.' 0.1 ' ' 1
Residual standard error: 1.026 on 995 degrees of freedom
Multiple R-squared: 0.9859, Adjusted R-squared: 0.9858
F-statistic: 1.738e+04 on 4 and 995 DF, p-value: < 2.2e-16# Prediksi nilai y
y_pred_poly4 <- predict(mod_poly4)
# Evaluasi performa model
R2_poly4 <- summary(mod_poly4)$r.squared
mse_poly4 <- mean((y - y_pred_poly4)^2)
mse_poly4[1] 1.047877plot(x, y,
main = "Regresi Polinomial Orde 4",
xlab = "x", ylab = "y",
col = "steelblue",
xlim = c(-2.5, 4.5),
ylim = c(-15, 70))
# Tambahkan garis prediksi model polinomial orde 4
lines(sort(x), y_pred_poly4[order(x)],
col = "darkgreen", lwd = 2)
legend("topleft",
legend = c("Data", "Polinomial Orde 4"),
col = c("steelblue", "darkgreen"),
pch = c(16, NA), lty = c(NA, 1), lwd = c(NA, 2))
Model polinomial orde empat yang diperoleh dari hasil estimasi adalah:
\[ \hat{y} = 5.0880 + 1.9756x + 2.9305x^2 + 0.0456x^3 - 0.0073x^4 \]
Model ini memberikan fleksibilitas maksimum dibandingkan model sebelumnya, tetapi tidak menunjukkan perbaikan performa yang berarti. Nilai koefisien \(R^2\) adalah \(0.9859\), identik dengan model orde dua dan tiga. Meskipun nilai Mean Squared Error (MSE) sedikit menurun menjadi \(1.0479\), perbedaan ini sangat kecil dan tidak signifikan secara praktis.
Secara statistik, koefisien dari suku pangkat tiga \(x^3\) dan pangkat empat \(x^4\) tidak signifikan karena memiliki nilai p-value masing-masing sebesar \(0.231\) dan \(0.403\). Hal ini menunjukkan bahwa kedua suku tersebut tidak memberikan kontribusi penting dalam menjelaskan variasi data. Dengan demikian, meskipun model orde empat memiliki kompleksitas lebih tinggi, model polinomial orde dua tetap menjadi pilihan yang lebih sederhana, efisien, dan cukup akurat dalam memodelkan hubungan antara \(x\) dan \(y\).
Untuk mengevaluasi performa masing-masing model regresi polinomial dari orde 1 hingga 4, kita dapat membandingkan nilai koefisien determinasi (\(R^2\)) dan Mean Squared Error (MSE) yang dihasilkan oleh setiap model. Tabel berikut merangkum hasil evaluasi tersebut:
# Buat data frame perbandingan
hasil_poly <- data.frame(
Orde = 2:4,
R2 = c(R2_poly2, R2_poly3, R2_poly4),
MSE = c(mse_poly2, mse_poly3, mse_poly4)
)
hasil_polyDari tabel di atas, terlihat bahwa model polinomial orde dua memberikan peningkatan performa yang sangat signifikan dibandingkan model linier biasa (orde satu), ditandai dengan kenaikan \(R^2\) dari \(0.7724\) menjadi \(0.9859\), serta penurunan drastis MSE dari \(16.91\) menjadi \(1.0499\). Namun, penambahan orde model lebih tinggi (orde 3 dan 4) tidak menghasilkan peningkatan yang berarti, baik dalam hal \(R^2\) maupun MSE. Bahkan, koefisien dari suku orde lebih tinggi dalam model orde 3 dan 4 tidak signifikan secara statistik. Oleh karena itu, model polinomial orde dua dapat disimpulkan sebagai model yang paling optimal dan efisien untuk data ini, karena mampu menangkap pola nonlinier dengan akurasi tinggi tanpa menambah kompleksitas yang tidak perlu.
Untuk mendapatkan pemahaman visual yang utuh terhadap perbedaan antara model polinomial berbagai orde, kita dapat menampilkan seluruh garis prediksi dari model orde 2, 3, dan 4 dalam satu grafik. Ini berguna untuk mengamati seberapa besar tambahan orde memengaruhi bentuk kurva dan akurasi model.
# Plot utama data
plot(x, y,
main = "Perbandingan Model Polinomial",
xlab = "x", ylab = "y",
col = "steelblue", pch = 16,
xlim = c(-2.5, 4.5),
ylim = c(-15, 70))
# Tambahkan garis prediksi untuk masing-masing model
lines(sort(x), y_pred_poly3[order(x)], col = "darkorange", lwd = 2)
lines(sort(x), y_pred_poly4[order(x)], col = "darkgreen", lwd = 2)
lines(sort(x), y_pred_poly2[order(x)], col = "blue", lwd = 2)
# Tambahkan legenda
legend("topleft",
legend = c("Data", "Polinomial Orde 2", "Polinomial Orde 3", "Polinomial Orde 4"),
col = c("steelblue", "blue", "darkorange", "darkgreen"),
pch = c(16, NA, NA, NA),
lty = c(NA, 1, 1, 1),
lwd = c(NA, 2, 2, 2))
Dari grafik ini terlihat bahwa model polinomial orde dua sudah cukup akurat menggambarkan hubungan antara variabel prediktor dan respons. Penambahan orde tiga dan empat tidak mengubah bentuk kurva secara signifikan, dan justru mulai menunjukkan pola yang sedikit berlebihan atau overfitting di ujung kurva. Maka, secara visual dan statistik, model orde dua menjadi pilihan paling seimbang antara kesederhanaan dan akurasi.
Menggunakan fungsi polinomial seperti pada bagian sebelumnya memang memberikan fleksibilitas dalam menangkap hubungan nonlinier, namun secara implisit juga memaksakan struktur global pada hubungan antara \(X\) dan \(Y\). Artinya, bentuk kurva ditentukan oleh satu fungsi tunggal yang berlaku di seluruh domain prediktor \(X\). Pendekatan ini bisa menjadi tidak efisien bila pola data sebenarnya hanya berubah secara lokal di rentang tertentu dari \(X\).
Sebagai alternatif, kita dapat menggunakan fungsi tangga (step function), yaitu dengan membagi domain \(X\) ke dalam beberapa bin atau segmen, lalu memberikan nilai konstanta berbeda pada setiap bin. Dengan cara ini, kita tidak perlu memodelkan bentuk fungsional global—melainkan hanya menetapkan rata-rata atau nilai tetap pada masing-masing rentang.
Secara teknis, kita memilih sejumlah titik potong (cutpoints) \(c_1, c_2, \dots, c_K\) di sepanjang rentang \(X\), kemudian membentuk \(K+1\) peubah dummy:
\[ \begin{aligned} C_0(X) &= I(X < c_1), \\ C_1(X) &= I(c_1 \le X < c_2), \\ C_2(X) &= I(c_2 \le X < c_3), \\ &\vdots \\ C_K(X) &= I(X \ge c_K) \end{aligned} \]
Setiap fungsi \(C_j(X)\) adalah indikator (dummy variable) yang menyatakan apakah suatu observasi berada di dalam bin ke-\(j\). Karena setiap observasi pasti hanya berada dalam satu bin, maka berlaku:
\[ C_0(X) + C_1(X) + \cdots + C_K(X) = 1 \]
Dengan kata lain, kita mengubah variabel kontinu \(X\) menjadi variabel kategorik terurut, lalu melakukan regresi dengan variabel dummy tersebut.
Dalam menerapkan fungsi tangga, terdapat dua keputusan penting yang harus ditentukan:
Jumlah Titik Potong (Jumlah Bin):
Semakin banyak bin, semakin fleksibel model dalam menangkap perubahan lokal pada data. Namun, terlalu banyak bin dapat menyebabkan overfitting, seperti halnya model polinomial orde tinggi.
Lokasi Titik Potong (Cutpoints):
Penentuan cutpoint dapat dilakukan dengan beberapa cara:
Setelah pembentukan variabel dummy selesai, model dapat diperkirakan menggunakan Metode Kuadrat Terkecil (OLS) karena bentuk modelnya tetap linier terhadap parameter.
Model regresi fungsi tangga secara umum dapat dituliskan sebagai:
\[ y_i = \beta_0 + \beta_1 C_1(x_i) + \beta_2 C_2(x_i) + \cdots + \beta_K C_K(x_i) + \varepsilon_i \]
Model ini pada dasarnya adalah regresi linier biasa terhadap \(K\) variabel dummy (dengan intercept), sehingga semua proses estimasi, inferensi, dan evaluasi model tetap dapat dilakukan menggunakan kerangka regresi linier.
Secara intuitif, regresi fungsi tangga pada dasarnya memperkirakan rata-rata nilai \(y\) di setiap bin. Karena setiap bin merepresentasikan rentang tertentu dari \(x\), model akan menghasilkan satu nilai prediksi konstan untuk semua observasi dalam rentang tersebut. Dengan kata lain, hasil estimasi \(\hat{y}\) pada fungsi tangga adalah mean lokal dari respons \(y\) di dalam interval \(x\) yang sama. Hal ini membuat model sederhana namun efektif dalam menangkap perubahan perilaku data secara bertahap di sepanjang domain \(x\).
Berdasarkan hal tersebut, koefisien \(\beta_0\) dalam model fungsi tangga dapat diinterpretasikan sebagai rata-rata nilai \(y\) pada bin acuan (baseline), yaitu kelompok observasi yang menjadi referensi ketika semua variabel dummy bernilai nol. Sementara itu, setiap koefisien \(\beta_j\) untuk \(j = 1, 2, \dots, K\) menggambarkan selisih rata-rata antara bin ke-\(j\) dengan bin acuan.
Dengan demikian, model fungsi tangga tidak hanya memberikan nilai konstan pada setiap interval, tetapi juga memungkinkan kita untuk menafsirkan bagaimana rata-rata respons \(y\) berubah antar segmen dari variabel \(x\). Interpretasi ini membuat fungsi tangga sangat mudah dibaca, karena setiap \(\beta_j\) menunjukkan seberapa besar perbedaan rata-rata \(y\) dibandingkan segmen pertama.
Dalam contoh praktikum ini, kita akan menggunakan titik potong yang ditetapkan secara manual. Pendekatan ini memungkinkan kita mengontrol secara eksplisit batas antar segmen.
Untuk ilustrasi pertama, kita mulai dengan satu titik potong yang membagi domain prediktor \(x\) menjadi dua bin. Misalnya, kita menetapkan titik potong pada \(x = 1.0\), sehingga data terbagi menjadi dua kelompok:
Kita dapat membentuk satu variabel dummy (\(D\)) yang bernilai 1 jika \(x \ge 1.0\), dan 0 jika \(x < 1.0\). Kemudian kita gunakan variabel ini dalam regresi linier sebagai prediktor.
Model yang diperoleh dapat dituliskan sebagai:
\[ \hat{y} = \beta_0 + \beta1D \]
Dengan:
Dengan kata lain, nilai prediksi \(\hat{y}\) konstan di masing-masing bin, yaitu:
# Titik potong (cutpoint) = 1.0
cut1 <- 1.0
# Buat variabel dummy
D <- ifelse(x >= cut1, 1, 0)
# Model regresi fungsi tangga dengan 1 cutpoint
mod_step1 <- lm(y ~ D)
summary(mod_step1)
Call:
lm(formula = y ~ D)
Residuals:
Min 1Q Median 3Q Max
-10.476 -3.150 -0.734 1.812 44.983
Coefficients:
Estimate Std. Error t value Pr(>|t|)
(Intercept) 6.7537 0.2733 24.71 <2e-16 ***
D 11.9961 0.3921 30.59 <2e-16 ***
---
Signif. codes: 0 '***' 0.001 '**' 0.01 '*' 0.05 '.' 0.1 ' ' 1
Residual standard error: 6.197 on 998 degrees of freedom
Multiple R-squared: 0.484, Adjusted R-squared: 0.4835
F-statistic: 936.1 on 1 and 998 DF, p-value: < 2.2e-16# Evaluasi performa model fungsi tangga 1 cutpoint
y_pred_step1 <- predict(mod_step1)
R2_step1 <- summary(mod_step1)$r.squared
mse_step1 <- mean((y - y_pred_step1)^2)
# Tampilkan nilai MSE
mse_step1[1] 38.32674# Visualisasi fungsi tangga dengan prediksi
plot(x, y,
main = "Regresi Fungsi Tangga Satu Titik Potong",
xlab = "x", ylab = "y",
col = "steelblue",
xlim = c(-2.5, 4.5),
ylim = c(-15, 70))
# Tambahkan garis prediksi dari model fungsi tangga
lines(sort(x), y_pred_step1[order(x)], col = "darkred", lwd = 2)
# Garis vertikal titik potong
abline(v = cut1, col = "gray40", lty = 2)
legend("topleft",
legend = c("Data", "Prediksi Fungsi Tangga", "Titik Potong"),
col = c("steelblue", "darkred", "gray40"),
pch = c(16, NA, NA),
lty = c(NA, 1, 2),
lwd = c(NA, 2, 1.5))
Model fungsi tangga dengan satu titik potong menghasilkan nilai \(R^2\) sebesar 0.484 dan Mean Squared Error (MSE) sebesar 38.3267. Ini menunjukkan bahwa model ini mampu menjelaskan sekitar \(48.4%\) variasi pada data, dengan MSE sekitar \(38.33\). Karena model hanya membagi data menjadi dua kelompok dengan nilai prediksi konstan di setiap bin, maka model ini masih memiliki galat cukup besar dibanding model dengan fleksibilitas bentuk yang lebih tinggi, seperti regresi polinomial.
Pada contoh sebelumnya, kita membentuk variabel dummy secara manual dengan ifelse(x >= cut1, 1, 0). Namun, jika kita ingin membuat lebih dari satu titik potong (bin), pendekatan manual ini menjadi tidak praktis. Untuk itu, kita bisa menggunakan fungsi cut() dari R, yang secara otomatis mengelompokkan data ke dalam interval (bin) berdasarkan titik potong yang ditentukan.
Sebagai contoh, kita dapat membuat dua bin berdasarkan titik potong 1.0 sebagai berikut:
bin1 <- cut(x, breaks = c(-Inf, 1.0, Inf))
# Cek ringkasan bin
summary(bin1)(-Inf,1] (1, Inf]
514 486 Fungsi cut() akan menghasilkan variabel bertipe faktor, di mana (-Inf,1] merepresentasikan \(x < 1.0\) dan (1, Inf] merepresentasikan \(x \ge 1.0\). Variabel ini bisa langsung digunakan dalam model regresi:
mod_step1b <- lm(y ~ bin1)
summary(mod_step1b)
Call:
lm(formula = y ~ bin1)
Residuals:
Min 1Q Median 3Q Max
-10.476 -3.150 -0.734 1.812 44.983
Coefficients:
Estimate Std. Error t value Pr(>|t|)
(Intercept) 6.7537 0.2733 24.71 <2e-16 ***
bin1(1, Inf] 11.9961 0.3921 30.59 <2e-16 ***
---
Signif. codes: 0 '***' 0.001 '**' 0.01 '*' 0.05 '.' 0.1 ' ' 1
Residual standard error: 6.197 on 998 degrees of freedom
Multiple R-squared: 0.484, Adjusted R-squared: 0.4835
F-statistic: 936.1 on 1 and 998 DF, p-value: < 2.2e-16Model ini akan secara otomatis menggunakan (-Inf,1] sebagai baseline, sehingga hasilnya identik dengan model sebelumnya. Nilai \(\beta_0\) adalah rata-rata \(y\) untuk (-Inf,1], dan koefisien untuk (1, Inf] menunjukkan selisih rata-rata terhadap (-Inf,1].
Pendekatan ini sangat berguna ketika kita memiliki lebih dari satu titik potong, karena kita cukup menyusun breaks dalam fungsi cut() tanpa harus membuat dummy variable satu per satu secara manual. Untuk contoh-contoh selanjutnya, kita akan menggunakan pendekatan cut() ini alih-alih membuat variabel dummy secara manual.
Setelah memahami fungsi tangga dengan satu titik potong, kini kita akan memperluas model dengan dua titik potong, misalnya pada \(x = 0\) dan \(x = 2\)
# Definisikan dua titik potong
cutpoints2 <- c(-Inf, 0, 2, Inf)
# Buat variabel bin kategori
bin2 <- cut(x, breaks = cutpoints2)bin2 berisi kategori (-Inf,0], (0,2], dan (2, Inf] yang merepresentasikan masing-masing segmen dari domain \(x\). Kita bisa langsung memasukkannya ke dalam model regresi.
mod_step2 <- lm(y ~ bin2)
summary(mod_step2)
Call:
lm(formula = y ~ bin2)
Residuals:
Min 1Q Median 3Q Max
-9.652 -3.326 -0.618 2.306 33.812
Coefficients:
Estimate Std. Error t value Pr(>|t|)
(Intercept) 5.3777 0.3739 14.38 <2e-16 ***
bin2(0,2] 5.4405 0.4143 13.13 <2e-16 ***
bin2(2, Inf] 24.5425 0.5495 44.67 <2e-16 ***
---
Signif. codes: 0 '***' 0.001 '**' 0.01 '*' 0.05 '.' 0.1 ' ' 1
Residual standard error: 4.73 on 997 degrees of freedom
Multiple R-squared: 0.6997, Adjusted R-squared: 0.6991
F-statistic: 1162 on 2 and 997 DF, p-value: < 2.2e-16Seperti sebelumnya, prediksi \(\hat{y}\) akan konstan di tiap bin, merepresentasikan nilai rata-rata lokal dari \(y\) di tiap segmen \(x\).
# Prediksi dan evaluasi
y_pred_step2 <- predict(mod_step2)
R2_step2 <- summary(mod_step2)$r.squared
mse_step2 <- mean((y - y_pred_step2)^2)
mse_step2[1] 22.3023# Visualisasi fungsi tangga dua titik potong
plot(x, y,
main = "Regresi Fungsi Tangga Dua Titik Potong",
xlab = "x", ylab = "y",
col = "steelblue",
xlim = c(-2.5, 4.5),
ylim = c(-15, 70))
# Tambahkan garis prediksi
lines(sort(x), y_pred_step2[order(x)], col = "purple", lwd = 2)
# Tambahkan garis vertikal titik potong
abline(v = 0, col = "gray40", lty = 2)
abline(v = 2, col = "gray40", lty = 2)
# Legenda
legend("topleft",
legend = c("Data", "Prediksi Fungsi Tangga", "Titik Potong"),
col = c("steelblue", "purple", "gray40"),
pch = c(16, NA, NA),
lty = c(NA, 1, 2),
lwd = c(NA, 2, 1.5))
Model fungsi tangga dengan dua titik potong ini menghasilkan nilai \(R^2\) sebesar 0.6997 dan MSE sebesar 22.3023. Hasil ini lebih baik dibandingkan model satu titik potong karena model kini memiliki tiga segmen yang memungkinkan penangkapan variasi lokal dalam data \(x\). Meskipun masih belum seakurat model polinomial, model fungsi tangga dua titik potong sudah menunjukkan peningkatan akurasi dan fleksibilitas dalam menangkap perubahan bentuk hubungan antara \(x\) dan \(y\).
# Titik potong: -1, 1, 2
cutpoints3 <- c(-Inf, -1, 1, 2, Inf)
bin3 <- cut(x, breaks = cutpoints3)
# Model regresi fungsi tangga 3 cutpoints
mod_step3 <- lm(y ~ bin3)
summary(mod_step3)
Call:
lm(formula = y ~ bin3)
Residuals:
Min 1Q Median 3Q Max
-9.652 -2.084 -0.359 1.701 33.812
Coefficients:
Estimate Std. Error t value Pr(>|t|)
(Intercept) 7.7825 0.8256 9.427 < 2e-16 ***
bin3(-1,1] -1.0726 0.8430 -1.272 0.204
bin3(1,2] 6.5376 0.8501 7.690 3.52e-14 ***
bin3(2, Inf] 22.1376 0.8862 24.981 < 2e-16 ***
---
Signif. codes: 0 '***' 0.001 '**' 0.01 '*' 0.05 '.' 0.1 ' ' 1
Residual standard error: 3.783 on 996 degrees of freedom
Multiple R-squared: 0.8081, Adjusted R-squared: 0.8075
F-statistic: 1398 on 3 and 996 DF, p-value: < 2.2e-16# Evaluasi
y_pred_step3 <- predict(mod_step3)
R2_step3 <- summary(mod_step3)$r.squared
mse_step3 <- mean((y - y_pred_step3)^2)
# Visualisasi
plot(x, y,
main = "Regresi Fungsi Tangga Tiga Titik Potong",
xlab = "x", ylab = "y",
col = "steelblue",
xlim = c(-2.5, 4.5),
ylim = c(-15, 70))
lines(sort(x), y_pred_step3[order(x)], col = "orange3", lwd = 2)
abline(v = c(-1, 1, 2), col = "gray40", lty = 2)
legend("topleft",
legend = c("Data", "Prediksi Fungsi Tangga", "Titik Potong"),
col = c("steelblue", "orange3", "gray40"),
pch = c(16, NA, NA),
lty = c(NA, 1, 2),
lwd = c(NA, 2, 1.5))
# Titik potong: -1.5, 0, 1.5, 3
cutpoints4 <- c(-Inf, -1.5, 0, 1.5, 3, Inf)
bin4 <- cut(x, breaks = cutpoints4)
# Model regresi fungsi tangga 4 cutpoints
mod_step4 <- lm(y ~ bin4)
summary(mod_step4)
Call:
lm(formula = y ~ bin4)
Residuals:
Min 1Q Median 3Q Max
-8.9386 -2.6986 -0.3133 2.0692 18.2855
Coefficients:
Estimate Std. Error t value Pr(>|t|)
(Intercept) 10.804 1.767 6.114 1.40e-09 ***
bin4(-1.5,0] -5.602 1.796 -3.120 0.00186 **
bin4(0,1.5] -1.617 1.775 -0.911 0.36244
bin4(1.5,3] 11.291 1.784 6.328 3.76e-10 ***
bin4(3, Inf] 34.642 1.986 17.441 < 2e-16 ***
---
Signif. codes: 0 '***' 0.001 '**' 0.01 '*' 0.05 '.' 0.1 ' ' 1
Residual standard error: 3.952 on 995 degrees of freedom
Multiple R-squared: 0.7908, Adjusted R-squared: 0.79
F-statistic: 940.3 on 4 and 995 DF, p-value: < 2.2e-16# Evaluasi
y_pred_step4 <- predict(mod_step4)
R2_step4 <- summary(mod_step4)$r.squared
mse_step4 <- mean((y - y_pred_step4)^2)
# Visualisasi
plot(x, y,
main = "Regresi Fungsi Tangga Empat Titik Potong",
xlab = "x", ylab = "y",
col = "steelblue",
xlim = c(-2.5, 4.5),
ylim = c(-15, 70))
lines(sort(x), y_pred_step4[order(x)], col = "darkgreen", lwd = 2)
abline(v = c(-1.5, 0, 1.5, 3), col = "gray40", lty = 2)
legend("topleft",
legend = c("Data", "Prediksi Fungsi Tangga", "Titik Potong"),
col = c("steelblue", "darkgreen", "gray40"),
pch = c(16, NA, NA),
lty = c(NA, 1, 2),
lwd = c(NA, 2, 1.5))
# Titik potong: -2, -0.5, 0.5, 2, 3.5
cutpoints5 <- c(-Inf, -2, -0.5, 0.5, 2, 3.5, Inf)
bin5 <- cut(x, breaks = cutpoints5)
# Model regresi fungsi tangga 5 cutpoints
mod_step5 <- lm(y ~ bin5)
summary(mod_step5)
Call:
lm(formula = y ~ bin5)
Residuals:
Min 1Q Median 3Q Max
-8.4549 -2.3722 -0.3411 1.6652 17.4671
Coefficients:
Estimate Std. Error t value Pr(>|t|)
(Intercept) 14.828 3.684 4.025 6.14e-05 ***
bin5(-2,-0.5] -8.693 3.717 -2.339 0.019547 *
bin5(-0.5,0.5] -9.366 3.692 -2.537 0.011326 *
bin5(0.5,2] -2.747 3.687 -0.745 0.456427
bin5(2,3.5] 13.895 3.698 3.757 0.000182 ***
bin5(3.5, Inf] 41.434 3.979 10.412 < 2e-16 ***
---
Signif. codes: 0 '***' 0.001 '**' 0.01 '*' 0.05 '.' 0.1 ' ' 1
Residual standard error: 3.684 on 994 degrees of freedom
Multiple R-squared: 0.8184, Adjusted R-squared: 0.8174
F-statistic: 895.7 on 5 and 994 DF, p-value: < 2.2e-16# Evaluasi
y_pred_step5 <- predict(mod_step5)
R2_step5 <- summary(mod_step5)$r.squared
mse_step5 <- mean((y - y_pred_step5)^2)
# Visualisasi
plot(x, y,
main = "Regresi Fungsi Tangga Lima Titik Potong",
xlab = "x", ylab = "y",
col = "steelblue",
xlim = c(-2.5, 4.5),
ylim = c(-15, 70))
lines(sort(x), y_pred_step5[order(x)], col = "tomato4", lwd = 2)
abline(v = c(-2, -0.5, 0.5, 2, 3.5), col = "gray40", lty = 2)
legend("topleft",
legend = c("Data", "Prediksi Fungsi Tangga", "Titik Potong"),
col = c("steelblue", "tomato4", "gray40"),
pch = c(16, NA, NA),
lty = c(NA, 1, 2),
lwd = c(NA, 2, 1.5))
hasil_step <- data.frame(
Model = paste("Cutpoint", 1:5),
R2 = c(R2_step1, R2_step2, R2_step3, R2_step4, R2_step5),
MSE = c(mse_step1, mse_step2, mse_step3, mse_step4, mse_step5)
)
hasil_stepBerdasarkan hasil evaluasi model fungsi tangga dengan jumlah titik potong yang berbeda, tampak bahwa peningkatan jumlah cutpoint secara umum meningkatkan kualitas model. Ketika hanya digunakan satu titik potong, nilai \(R^2\) sebesar 0.484 dan MSE sebesar 38.33 menunjukkan bahwa model masih sangat sederhana dan belum mampu menangkap pola nonlinier secara baik. Penambahan titik potong kedua meningkatkan \(R^2\) menjadi 0.699 dan menurunkan MSE secara signifikan menjadi 22.30, mengindikasikan peningkatan ketepatan prediksi.
Model dengan tiga titik potong menunjukkan peningkatan paling signifikan, dengan \(R^2\) mencapai 0.808 dan MSE turun menjadi 14.26. Ini menunjukkan bahwa model mulai cukup fleksibel dalam menangkap variasi data. Namun, penambahan titik potong keempat justru menyebabkan sedikit penurunan pada \(R^2\) (menjadi 0.791) dan peningkatan MSE (menjadi 15.54), yang dapat mengindikasikan gejala overfitting lokal atau ketidakefisienan segmentasi. Model dengan lima titik potong kembali menunjukkan performa terbaik, dengan \(R^2\) tertinggi sebesar 0.818 dan MSE terendah sebesar 13.49, sehingga dapat dikatakan paling optimal di antara lima model ini dalam menjelaskan variasi data.
Secara keseluruhan, model fungsi tangga dengan lebih banyak segmentasi cenderung menghasilkan prediksi yang lebih akurat, namun tetap perlu mempertimbangkan keseimbangan antara kompleksitas model dan risiko overfitting.
plot(x, y,
main = "Perbandingan Model Fungsi Tangga",
xlab = "x", ylab = "y",
col = "steelblue",
xlim = c(-2.5, 4.5), ylim = c(-15, 70))
# Tambahkan garis prediksi setiap model
lines(sort(x), y_pred_step1[order(x)], col = "darkred", lwd = 2)
lines(sort(x), y_pred_step2[order(x)], col = "purple", lwd = 2)
lines(sort(x), y_pred_step3[order(x)], col = "orange3", lwd = 2)
lines(sort(x), y_pred_step4[order(x)], col = "darkgreen", lwd = 2)
lines(sort(x), y_pred_step5[order(x)], col = "tomato4", lwd = 2)
legend("topleft",
legend = c("Step-1", "Step-2", "Step-3", "Step-4", "Step-5"),
col = c("darkred", "purple", "orange3", "darkgreen", "tomato4"),
lty = 1, lwd = 2)
Pada analisis sebelumnya, kita menentukan titik potong secara manual dan mengevaluasi performa model fungsi tangga dengan jumlah cutpoint mulai dari satu hingga lima. Hasilnya menunjukkan bahwa model dengan lima titik potong memiliki performa terbaik berdasarkan nilai \(R^2\) dan MSE. Namun, pendekatan manual tersebut masih bersifat arbitrer.
Sebagai alternatif, kita dapat menggunakan metode otomatis untuk menentukan titik potong berdasarkan karakteristik distribusi data prediktor \(x\). Dua metode umum yang dapat digunakan adalah:
Untuk perbandingan yang adil, kita gunakan tiga titik potong (4 bin) seperti model terbaik kedua sebelumnya (Cutpoint 3). Berikut implementasinya.
# Breaks sama lebar: 4 bin → 3 titik potong
breaks_width <- seq(min(x), max(x), length.out = 5) # 4 bin = 5 titik termasuk batas kiri kanan
bin_width <- cut(x, breaks = breaks_width, include.lowest = TRUE)
mod_step_width <- lm(y ~ bin_width)
summary(mod_step_width)
Call:
lm(formula = y ~ bin_width)
Residuals:
Min 1Q Median 3Q Max
-8.2815 -2.3988 -0.5578 1.8330 26.6059
Coefficients:
Estimate Std. Error t value Pr(>|t|)
(Intercept) 6.2874 0.5395 11.655 <2e-16 ***
bin_width(-0.508,1.03] 0.6122 0.5712 1.072 0.284
bin_width(1.03,2.57] 10.2678 0.5751 17.853 <2e-16 ***
bin_width(2.57,4.11] 30.8390 0.7663 40.244 <2e-16 ***
---
Signif. codes: 0 '***' 0.001 '**' 0.01 '*' 0.05 '.' 0.1 ' ' 1
Residual standard error: 4.073 on 996 degrees of freedom
Multiple R-squared: 0.7776, Adjusted R-squared: 0.7769
F-statistic: 1161 on 3 and 996 DF, p-value: < 2.2e-16# Prediksi dan evaluasi
y_pred_width <- predict(mod_step_width)
R2_width <- summary(mod_step_width)$r.squared
mse_width <- mean((y - y_pred_width)^2)
mse_width[1] 16.52143# Visualisasi model fungsi tangga dengan breaks sama lebar
plot(x, y,
main = "Fungsi Tangga - Breaks Sama Lebar (4 Bin)",
xlab = "x", ylab = "y",
col = "steelblue",
xlim = c(-2.5, 4.5), ylim = c(-15, 70))
# Garis prediksi model
lines(sort(x), y_pred_width[order(x)], col = "darkorange", lwd = 2)
# Tambahkan garis vertikal pada batas bin
abline(v = breaks_width, col = "gray50", lty = 2)
legend("topleft",
legend = c("Data", "Prediksi Step (Equal Width)", "Batas Bin"),
col = c("steelblue", "darkorange", "gray50"),
pch = c(16, NA, NA),
lty = c(NA, 1, 2),
lwd = c(NA, 2, 1.2))
# Breaks kuantil: 4 bin → 3 titik potong
breaks_quantile <- quantile(x, probs = seq(0, 1, length.out = 5))
bin_quantile <- cut(x, breaks = breaks_quantile, include.lowest = TRUE)
mod_step_quantile <- lm(y ~ bin_quantile)
summary(mod_step_quantile)
Call:
lm(formula = y ~ bin_quantile)
Residuals:
Min 1Q Median 3Q Max
-11.307 -1.529 -0.267 1.248 39.113
Coefficients:
Estimate Std. Error t value Pr(>|t|)
(Intercept) 5.4476 0.2822 19.306 < 2e-16 ***
bin_quantile(0.365,0.959] 2.4481 0.3990 6.135 1.23e-09 ***
bin_quantile(0.959,1.56] 6.9250 0.3990 17.354 < 2e-16 ***
bin_quantile(1.56,4.11] 19.1716 0.3990 48.043 < 2e-16 ***
---
Signif. codes: 0 '***' 0.001 '**' 0.01 '*' 0.05 '.' 0.1 ' ' 1
Residual standard error: 4.461 on 996 degrees of freedom
Multiple R-squared: 0.7331, Adjusted R-squared: 0.7323
F-statistic: 911.8 on 3 and 996 DF, p-value: < 2.2e-16# Prediksi dan evaluasi
y_pred_quantile <- predict(mod_step_quantile)
R2_quantile <- summary(mod_step_quantile)$r.squared
mse_quantile <- mean((y - y_pred_quantile)^2)
mse_quantile[1] 19.82534# Visualisasi model fungsi tangga dengan breaks berbasis kuantil
plot(x, y,
main = "Fungsi Tangga - Breaks Berdasarkan Kuantil (4 Bin)",
xlab = "x", ylab = "y",
col = "steelblue",
xlim = c(-2.5, 4.5), ylim = c(-15, 70))
# Garis prediksi model
lines(sort(x), y_pred_quantile[order(x)], col = "darkgreen", lwd = 2)
# Tambahkan garis vertikal pada batas kuantil
abline(v = breaks_quantile, col = "gray50", lty = 2)
legend("topleft",
legend = c("Data", "Prediksi Step (Quantile-Based)", "Batas Kuantil"),
col = c("steelblue", "darkgreen", "gray50"),
pch = c(16, NA, NA),
lty = c(NA, 1, 2),
lwd = c(NA, 2, 1.2))
hasil_step_extended <- data.frame(
Model = c("Cutpoint 3 (Manual)",
"Cutpoint 5 (Manual)",
"Equal Width (Auto)",
"Quantile-Based (Auto)"),
R2 = c(R2_step3, R2_step5, R2_width, R2_quantile),
MSE = c(mse_step3, mse_step5, mse_width, mse_quantile))
hasil_step_extendedModel regresi polinomial dan regresi fungsi tangga sebenarnya merupakan kasus khusus dari pendekatan yang lebih umum, yaitu basis function regression.
Idenya adalah untuk menetapkan suatu bentuk transformasi terhadap variabel prediktor \(X\), menggunakan sekumpulan fungsi basis:
\[ b_1(X),\ b_2(X),\ \dots,\ b_K(X), \]
sehingga model regresi menjadi:
\[ y_i = \beta_0 + \beta_1 b_1(x_i) + \beta_2 b_2(x_i) + \dots + \beta_K b_K(x_i) + \varepsilon_i. \]
Dalam hal ini, fungsi-fungsi \(b_1(\cdot),\ b_2(\cdot),\ \dots,\ b_K(\cdot)\) disebut sebagai basis functions yang bersifat fixed and known, yaitu sudah ditentukan sebelumnya.
Polinomial:
\[ b_j(x_i) = x_i^j \]
Fungsi Tangga (Step Function):
\[ b_j(x_i) = I(c_j < x_i \le c_{j+1}) \]
Model ini secara struktural setara dengan regresi linier biasa, namun prediktornya merupakan hasil transformasi dari variabel input \(X\) melalui fungsi basis tersebut. Oleh karena itu, kita tetap dapat menggunakan Metode Kuadrat Terkecil (MKT / OLS) untuk mengestimasi parameter \(\beta_0, \beta_1, \dots, \beta_K\).
Dalam memilih ordo polinomial atau jumlah dan lokasi titik potong (cutpoints) untuk model fungsi tangga, penting untuk tidak hanya mengandalkan nilai \(R^2\), MSE atau metrik lain pada data pelatihan saja. Karena pemilihan parameter yang terlalu fleksibel bisa menyebabkan overfitting — yaitu model sangat bagus pada data pelatihan tetapi buruk saat dihadapkan pada data baru. Salah satu cara yang efektif untuk menangani ini adalah menggunakan metode Cross‑Validation.
Secara ringkas, cross‐validation adalah teknik untuk menilai seberapa baik model kita akan bekerja pada data yang belum pernah dilihat sebelumnya. Anda membagi data ke dalam beberapa subset (folds), kemudian model dilatih pada sebagian subset dan diuji pada subset yang tersisa. Proses ini diulangi sebanyak semua kombinasi “seluruh data sebagai training + validation” dan hasilnya dirata‐rata untuk mendapatkan estimasi performa yang lebih bisa dipercaya.
Sebagai contoh, pada k‑fold cross‑validation, data dibagi menjadi \(k\) bagian. Model akan dilatih pada \(k-1\) bagian dan diuji pada bagian yang tersisa, lalu proses ini diulang hingga semua bagian pernah menjadi data uji. Nilai performa (misalnya MSE) kemudian dirata-ratakan. Gambar di bawah memperlihatkan skema umum k‑fold cross‑validation:
Sumber: Research Gate
Untuk praktikum model fungsi tangga atau polinomial, penerapan cross‑validation dapat dilakukan sebagai berikut:
Beberapa alasan utama penggunaan cross-validation:
Cross‑validation tidak hanya digunakan dalam regresi, tetapi juga pada hampir semua model pembelajaran mesin, termasuk splines, regularized regression, dan ensemble methods.