Pertemuan 11: Skenario Pemodelan & Algoritma Klasifikasi Terawasi

Penerapan Unit Kompetensi SKKNI J.62DMI00.012.1 (Membangun Skenario Model) dan J.62DMI00.013.1 (Membangun Model): Train-Validation-Test Split, Model Selection vs Assessment, K-Fold Cross-Validation, strategi pencarian parameter (Best Guess, OFAT, Grid Search), pencegahan Data Leakage via Pipeline, serta komparasi algoritma klasifikasi (k-NN, Decision Tree, Naive Bayes, SVM, Logistic Regression, Random Forest, AdaBoost, XGBoost) lengkap dengan kelebihan/kekurangan dan parameter tuning pada dataset Iris.

Penyusun Modul & Portal: Mahendar Dwi Payana
Penulis Materi Pelatihan DTS 2021: Afiahayati, S.Kom., M.Cs., Ph.D. — Thematic Academy Digital Talent Scholarship 2021
Penyelenggara & Kurikulum: Kementerian Komunikasi dan Informatika RI (Kominfo) & Sekolah Teknik Elektro dan Informatika (STEI) ITB
Standar Rujukan: Standar Kompetensi Kerja Nasional Indonesia (SKKNI) No. 299 Tahun 2020 — Skema Associate Data Scientist


1. Landasan Standar Kompetensi Kerja (SKKNI)

Modul ini adalah bagian pertama dari pemodelan. Materi mencakup merancang skenario model dan membangun model klasifikasi (pemodelan regresi menyusul pada Pertemuan 12).

Kode UnitElemen KompetensiKriteria Unjuk Kerja (KUK) Inti
J.62DMI00.012.1
Membangun Skenario Model
1. Mengidentifikasi teknik pemodelan1.1 Asumsi spesifik mengenai data diidentifikasi sesuai karakteristik data.
1.2 Teknik-teknik pemodelan data diidentifikasi sesuai karakteristik data dan tujuan teknis.
2. Menentukan teknik pemodelan2.1 Teknik pemodelan yang sesuai karakteristik data ditentukan.
2.2 Deskripsi teknik pemodelan yang dipilih didokumentasikan sesuai SOP.
3. Menyiapkan skenario pengujian3.1 Skenario uji yang mungkin diterapkan ditentukan sesuai tujuan teknis.
3.2 Metrik evaluasi pengujian diidentifikasi sesuai skenario uji.
3.3 Skenario uji yang dipilih didokumentasikan sesuai standar.
J.62DMI00.013.1
Membangun Model
1. Menyiapkan parameter model1.1 Parameter yang sesuai dengan model diidentifikasi.
1.2 Nilai toleransi parameter evaluasi pengujian ditetapkan sesuai tujuan teknis.
2. Menggunakan tools pemodelan2.1 Tools untuk membuat model diidentifikasi.
2.2 Algoritma pemodelan dibangun menggunakan tools yang dipilih.
2.3 Algoritma pemodelan dieksekusi sesuai skenario pengujian.
2.4 Parameter model dioptimasi untuk menghasilkan nilai evaluasi yang sesuai skenario.

Tujuan Pembelajaran Modul

Setelah mempelajari modul ini, peserta diharapkan mampu:

  1. Membangun Skenario Model — mengidentifikasi teknik pemodelan, menentukan teknik yang sesuai karakteristik data & tujuan teknis, serta menyiapkan skenario pengujian.
  2. Membangun Model Klasifikasi — menyiapkan parameter model dan menggunakan tools pemodelan.

Pokok Bahasan:

Memuat diagram visual...

Cakupan Praktikum Modul 11

Modul 11 (Membangun Model dan Studi Kasus) menggunakan dataset Iris dengan pembagian data latih 70% dan uji 30%, menerapkan berbagai metode klasifikasi dengan parameter tuning, lalu membandingkannya terhadap algoritma AdaBoost. Studi kasus kelompok memodelkan mutu pendidikan (SNP) sekolah Kabupaten Bogor dengan klasifikasi dan regresi.


2. Membangun Skenario Pemodelan (J.62DMI00.012.1)

Perancangan skenario eksperimen dilakukan sebelum model dibangun, dan terdiri atas tiga keputusan penting: pembagian data, langkah eksperimen, dan parameter evaluasi.

A. Pembagian Data (Data Splitting)

Data dibagi menjadi dua bagian utama: data latih (mengembangkan model) dan data uji (mengukur performansi). Praktik yang lebih lengkap menambahkan data validasi di antaranya.

Memuat diagram visual...

Peran tiap bagian data:

BagianPeranKeterkaitan
Data LatihMelatih parameter model—
Data ValidasiMembandingkan model dengan hyperparameter berbeda; mendeteksi underfitting/overfittingModel Selection (estimasi performa model berbeda → pilih error minimum)
Data UjiMenguji performa algoritma yang satu terhadap yang lainModel Assessment (estimasi error untuk data baru)

Rasional & proporsi umum:

  • Jika data sedikit, model dilatih pada data yang terlalu sedikit dan generalisasi menjadi terlalu "optimis" (bias tinggi).
  • Proporsi train:validation yang lazim: 66,6%:33,3%, 75%:25%, dan 80%:20%. Modul ini memakai 70% latih : 30% uji.
from sklearn import datasets
from sklearn.model_selection import train_test_split

# Dataset Iris: 150 sampel, 4 fitur, 3 kelas
iris = datasets.load_iris()
X, y = iris.data, iris.target

# Proporsi 70% latih : 30% uji
X_train, X_test, y_train, y_test = train_test_split(
    X, y, train_size=0.7, random_state=42
)
print("Data latih:", len(X_train), "| Data uji:", len(X_test))

B. Validasi Silang K-Fold (Cross-Validation)

Dilakukan pada data latih, terutama bila jumlah data relatif sedikit. Data latih dibagi menjadi KK bagian; secara iteratif, 1 bagian menjadi data validasi dan K−1K-1 bagian melatih model. Rata-rata skor menjadi estimasi performa yang lebih stabil daripada satu kali split.

CV(K)=1K∑k=1KSkork\text{CV}_{(K)} = \frac{1}{K}\sum_{k=1}^{K} \text{Skor}_k
from sklearn.model_selection import cross_val_score
from sklearn.svm import SVC

model = SVC(kernel='linear', C=1)

# 5-Fold Cross Validation
scores = cross_val_score(model, X, y, cv=5)
print("Akurasi tiap fold  :", scores)
print("Akurasi rata-rata  :", scores.mean())
  • Stratified K-Fold: menjaga proporsi setiap kelas pada tiap lipatan — wajib untuk data timpang.
  • Time-Series Split: untuk data runtun waktu guna mencegah kebocoran masa depan (future leakage).

C. Bahaya Fatal Kebocoran Data (Data Leakage)

[!CAUTION] Data Leakage: kondisi di mana informasi dari luar data latih (khususnya data uji atau masa depan) bocor ke dalam proses pelatihan.

Penyebab umum: StandardScaler.fit(), SimpleImputer.fit(), atau SMOTE yang diterapkan pada seluruh dataset sebelum pemisahan train/test.

Solusi: bungkus pra-pemrosesan dan model ke dalam Scikit-learn Pipeline sehingga fit hanya terjadi pada data latih.

from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression

# Salah: scaler di-fit pada seluruh data sebelum split -> LEAKAGE!

# Benar: semua tahap dalam Pipeline
pipe = Pipeline([
    ('scaler', StandardScaler()),
    ('clf', LogisticRegression(max_iter=1000, random_state=42))
])
pipe.fit(X_train, y_train)
print("Akurasi Pipeline:", pipe.score(X_test, y_test))

D. Menentukan Langkah Eksperimen (Strategi Pencarian Parameter)

Setiap algoritma punya parameter tertentu. Eksperimen dilakukan dengan beberapa variasi parameter; kombinasi dengan performa terbaik dipakai selanjutnya. Tiga strategi pencarian:

StrategiCara KerjaKelebihanKekurangan
Best GuessMenebak satu kombinasi berdasarkan pengalamanSangat cepatTidak sistematis; bisa melewatkan kombinasi terbaik
One Factor at a Time (OFAT)Mengubah satu parameter sambil menahan yang lainSederhanaMengabaikan interaksi antar-parameter
Grid SearchMenguji seluruh kombinasi pada grid yang didefinisikanSistematis & menyeluruhMahal secara komputasi

E. Parameter Evaluasi per Tipe Tugas

Tipe TugasMetrik Evaluasi
KlasifikasiAkurasi, Presisi, Recall/Sensitivity, Specificity, F1-measure
RegresiMSE (Mean Squared Error), MAPE (Mean Absolute Percentage Error)
KlasteringSilhouette Score, Davies-Bouldin Index

Untuk klasifikasi biner, keempat metrik dasar diturunkan dari Confusion Matrix:

Accuracy=TP+TNTP+TN+FP+FN,Precision=TPTP+FP,Recall=TPTP+FN\text{Accuracy} = \frac{TP+TN}{TP+TN+FP+FN}, \quad \text{Precision} = \frac{TP}{TP+FP}, \quad \text{Recall} = \frac{TP}{TP+FN} Specificity=TNTN+FP,F1=2⋅P⋅RP+R\text{Specificity} = \frac{TN}{TN+FP}, \qquad F_1 = 2 \cdot \frac{P \cdot R}{P + R}

Pembahasan mendalam Confusion Matrix, ROC/PR-Curve, dan SHAP ada pada Pertemuan 15.


3. Membangun Model Klasifikasi (J.62DMI00.013.1)

3.1 Logistic Regression (Baseline Linier)

Model linier yang memetakan kombinasi fitur ke probabilitas kelas melalui Fungsi Sigmoid:

P(Y=1∣X)=σ(z)=11+e−z,z=β0+∑j=1pβjXjP(Y=1 \mid X) = \sigma(z) = \frac{1}{1 + e^{-z}}, \qquad z = \beta_0 + \sum_{j=1}^{p} \beta_j X_j
from sklearn.linear_model import LogisticRegression
from sklearn import metrics

lr = LogisticRegression(max_iter=1000, random_state=42)
lr.fit(X_train, y_train)
print("Akurasi Logistic Regression:", metrics.accuracy_score(y_test, lr.predict(X_test)))

3.2 k-Nearest Neighbor (k-NN) Classifier

Algoritma k-NN:

  1. Menentukan nilai kk (jumlah tetangga).
  2. Menghitung jarak data baru terhadap semua data latih.
  3. Mengidentifikasi kk tetangga terdekat.
  4. Menentukan label data baru berdasarkan kelas tetangga (umumnya voting).
d(x,x′)=∑j=1p(xj−xj′)2d(x, x') = \sqrt{\sum_{j=1}^{p} (x_j - x'_j)^2}

Contoh kasus: 4 data latih (P1–P4) dengan 2 atribut (x1,x2x_1, x_2) dan 2 kelas (BAD, GOOD); tentukan kelas data uji P5 berdasarkan kk tetangga terdekatnya.

Kelebihan & Kekurangan:

KelebihanKekurangan
Cocok untuk data numerikLazy learner — tidak membangun model eksplisit
Mudah dipahami & diimplementasikanBiaya komputasi prediksi tinggi
Non-parametrikPerlu memilih kk yang tepat

Memilih kk: Jika kk terlalu kecil → sensitif terhadap noise. Jika kk terlalu besar → tetangga bisa mencakup kelas lain.

ParameterKeteranganContoh Nilai
n_neighborsJumlah neighborBilangan integer (1,2,3,… )(1, 2, 3, \dots)
from sklearn.neighbors import KNeighborsClassifier

knn = KNeighborsClassifier()   # sklearn default: n_neighbors=5
knn.fit(X_train, y_train)
print("KNN:", knn.score(X_test, y_test))

Penting: KNN sangat sensitif skala → wajib standardisasi fitur (lihat Pertemuan 09).


3.3 Decision Tree Classifier

Membangun pohon keputusan dari data latih; outputnya berupa rule yang dipakai untuk klasifikasi. Struktur pohon:

Memuat diagram visual...

Prosedur pembangunan (Gini Index/Impurity):

  1. Hitung Gini Index (GI) untuk setiap atribut.
  2. Tentukan root = atribut dengan GI terkecil.
  3. Ulangi langkah 1–2 pada level berikutnya hingga semua leaf bernilai GI = 0.
IG(p)=1−∑i=1Cpi2I_G(p) = 1 - \sum_{i=1}^{C} p_i^2

Contoh Perhitungan Gini (studi kasus "Beli"):

Data latih 7 rekaman, 3 atribut (Kebutuhan Primer, Sudah Gajian, Harga Barang), target Beli/Tidak. Total GI dihitung sebagai weighted average GI kedua anak node.

AtributGini IndexKeputusan
Kebutuhan Primer0,40—
Sudah Gajian0,22✅ Root (GI terkecil)
Harga Barang0,34—

Penanganan atribut kontinu: untuk Harga Barang, GI dihitung pada titik tengah dua data berdekatan (mis. > 9500, > 15000, > 26500, > 36500, > 44000, > 66500), lalu ambil GI terkecil. Pada contoh, GI Harga Barang > 15000 lebih kecil sehingga dipakai untuk memecah leaf kiri. Karena leaf kanan GI = 0, ia tidak dipecah lagi.

Kelebihan & Kekurangan:

KelebihanKekurangan
Memberikan penjelasan berupa rule yang dapat dibacaPembangunan pada data numerik lebih rumit; berpotensi kehilangan informasi
Tidak butuh asumsi distribusiPohon dapat tumbuh sangat kompleks (overfitting)
ParameterKeteranganDefault
max_depthKedalaman maksimum pohonNone (tumbuh sampai GI = 0)
min_samples_splitMinimum sampel agar node dapat split2
from sklearn.tree import DecisionTreeClassifier, plot_tree
import matplotlib.pyplot as plt

dt = DecisionTreeClassifier(max_depth=None, min_samples_split=2, random_state=42)
dt.fit(X_train, y_train)
print("Decision Tree:", dt.score(X_test, y_test))

plt.figure(figsize=(12, 8))
plot_tree(dt, feature_names=iris.feature_names, class_names=iris.target_names, filled=True)
plt.show()

Untuk mencegah overfitting, batasi max_depth dan/atau naikkan min_samples_split.


3.4 Naive Bayes Classifier

Membangun model probabilistik untuk klasifikasi. Dua pendekatan model:

  • Discriminative Model — memodelkan P(y∣x)P(y \mid x) secara langsung.
  • Generative Model — memodelkan P(x∣y)P(x \mid y) dan P(y)P(y), lalu menurunkan P(y∣x)P(y \mid x). Naive Bayes termasuk generative.

MAP Classification Rule (Maximum A Posteriori) dengan aturan Bayes:

y^=arg⁡max⁡y  P(y∣x1,…,xn)  ∝  arg⁡max⁡y  P(y)∏i=1nP(xi∣y)\hat{y} = \arg\max_{y}\; P(y \mid x_1,\dots,x_n) \;\propto\; \arg\max_{y}\; P(y)\prod_{i=1}^{n} P(x_i \mid y)

Contoh kasus: 14 data latih bermain tenis dengan 4 atribut (Outlook, Temperature, Humidity, Wind) dan 2 kelas (YES/NO). Klasifikasi data uji menggunakan probabilitas kondisi tiap atribut per kelas.

Kelebihan & Kekurangan:

KelebihanKekurangan
Bekerja baik pada data latih kecilPembangunan pada data numerik lebih rumit
Sangat cepatAsumsi independensi fitur sering tidak berlaku di dunia nyata
from sklearn.naive_bayes import GaussianNB, BernoulliNB

# GaussianNB lebih tepat untuk fitur kontinu; BernoulliNB untuk fitur biner
nb = GaussianNB()
nb.fit(X_train, y_train)
print("Naive Bayes:", nb.score(X_test, y_test))

3.5 Support Vector Machine (SVM)

Ide utama SVM: menemukan hyperplane terbaik yang memisahkan dua daerah keputusan dengan baik. Hyperplane terbaik diperoleh dengan memaksimalkan jarak (margin) terhadap titik data terdekat (support vectors).

min⁡w,b12∥w∥2dengan kendalayi(wTxi+b)≥1\min_{w,b} \frac{1}{2}\lVert w \rVert^2 \quad \text{dengan kendala} \quad y_i(w^T x_i + b) \ge 1

Algoritma: fitur dipetakan ke ruang dimensi lebih tinggi memakai fungsi kernel, lalu dicari hyperplane pemisah terbaik.

Jenis Kernel:

  • Linear: K(xi,xj)=xiTxjK(x_i, x_j) = x_i^T x_j.
  • Polynomial: K(xi,xj)=(xiTxj+c)dK(x_i, x_j) = (x_i^T x_j + c)^d.
  • Radial Basis Function (RBF): K(xi,xj)=exp⁡(−γ∥xi−xj∥2)K(x_i, x_j) = \exp(-\gamma \lVert x_i - x_j \rVert^2).
  • Sigmoid.

Interpretasi Hyperparameter:

  • Parameter CC (regularisasi): keseimbangan antara jarak maksimal dan kesalahan klasifikasi minimal.
    • CC tinggi → penalti besar saat salah klasifikasi (cocok untuk data ber-noise rendah).
    • CC rendah → lebih toleran terhadap kesalahan (cocok untuk data ber-noise tinggi).
  • Parameter γ\gamma: γ\gamma besar → kelengkungan tajam; γ\gamma kecil → batas keputusan lebih landai.
ParameterKeteranganDefault
kernellinear, poly, rbf, sigmoidrbf
CRegularisasi untuk semua kernel1.0
gammaKoefisien kernel untuk poly & rbfscale
degreeDerajat polinomial (kernel poly)3
from sklearn.svm import SVC

svm_linear = SVC(kernel='linear', C=1)
svm_linear.fit(X_train, y_train)
print("SVM Linear:", svm_linear.score(X_test, y_test))

Kelebihan & Kekurangan:

KelebihanKekurangan
Strategi kernel mengatasi data kompleksHyperparameter & kernel perlu di-tuning
Outlier dapat diatasi via soft margin CCWaktu training lama untuk dataset besar

3.6 Random Forest (Ensemble Bagging)

Menggabungkan ratusan pohon keputusan independen. Setiap pohon dilatih pada sampel bootstrap dan memilih subset acak fitur pada setiap pemisahan (feature subspace sampling). Prediksi akhir = mayoritas suara:

y^=mode(T1(x),T2(x),…,TB(x))\hat{y} = \text{mode}\left(T_1(x), T_2(x), \dots, T_B(x)\right)

3.7 Boosting Algorithm

Boosting adalah strategi ensemble yang mengubah weak model menjadi strong model dengan mengombinasikan prediksi tiap model melalui average/weighted average atau higher voting. Tiga tipe utama:

Memuat diagram visual...

Adaptive Boosting (AdaBoost)

AdaBoost mengidentifikasi data yang salah klasifikasi dan memberikan bobot lebih pada data tersebut, sehingga classifier berikutnya lebih fokus. Secara default di Scikit-learn, base estimator yang di-boost adalah Decision Tree (stump).

Formulasi matematis:

  1. Error tertimbang model ke-tt:
εt=∑i: ht(xi)≠yiwi(t)\varepsilon_t = \sum_{i:\, h_t(x_i) \neq y_i} w_i^{(t)}
  1. Bobot kepercayaan model (semakin kecil error, semakin besar pengaruhnya):
αt=12ln⁡(1−εtεt)\alpha_t = \frac{1}{2}\ln\left(\frac{1 - \varepsilon_t}{\varepsilon_t}\right)
  1. Pembaruan bobot sampel (sampel salah → bobot naik):
wi(t+1)=wi(t)⋅exp⁡(−αt yi ht(xi)),lalu dinormalisasiw_i^{(t+1)} = w_i^{(t)} \cdot \exp\left(-\alpha_t\, y_i\, h_t(x_i)\right), \quad \text{lalu dinormalisasi}
  1. Prediksi akhir:
H(x)=sign(∑t=1Tαt ht(x))H(x) = \text{sign}\left(\sum_{t=1}^{T} \alpha_t\, h_t(x)\right)
ParameterKeteranganDefault
n_estimatorsJumlah weak learner yang digunakan50
learning_rateBobot tiap classifier per iterasi boosting1.0
from sklearn.ensemble import AdaBoostClassifier
from sklearn import metrics

ab = AdaBoostClassifier(n_estimators=50, learning_rate=1, random_state=42)
ab.fit(X_train, y_train)

y_pred_ab = ab.predict(X_test)
akurasi_ab = metrics.accuracy_score(y_test, y_pred_ab) * 100
print(f"Akurasi Adaboost: {round(akurasi_ab, 2)}%")

learning_rate lebih besar meningkatkan kontribusi tiap estimator; nilai lebih kecil butuh lebih banyak estimator.


3.8 Gradient Boosting & XGBoost

Gradient Boosting juga sekuensial, tetapi setiap pohon baru dilatih memprediksi pseudo-residual (gradien kerugian) dari model sebelumnya:

Fm(x)=Fm−1(x)+γmhm(x)F_m(x) = F_{m-1}(x) + \gamma_m h_m(x)

XGBoost menambahkan regularisasi dan optimasi orde-dua (Hessian) sehingga sering menjadi state-of-the-art pada data tabular.


4. Hyperparameter Tuning dengan GridSearchCV

Grid Search menguji seluruh kombinasi hyperparameter secara sistematis dengan validasi silang, lalu memilih kombinasi terbaik.

Best Params=arg⁡max⁡θ∈Θ  CV(K)(θ)\text{Best Params} = \arg\max_{\theta \in \Theta} \; \text{CV}_{(K)}(\theta)
from sklearn.model_selection import GridSearchCV
from sklearn.neighbors import KNeighborsClassifier

# Ruang pencarian: k = 1..49 dan strategi bobot
param_grid = dict(
    n_neighbors=list(range(1, 50)),
    weights=["uniform", "distance"]
)

knn = KNeighborsClassifier()
grid = GridSearchCV(knn, param_grid, cv=10, scoring='accuracy')
grid.fit(X_train, y_train)

print("Akurasi terbaik KNN :", grid.best_score_)
print("Parameter terbaik   :", grid.best_params_)
print("Estimator terbaik   :", grid.best_estimator_)

Alternatif: RandomizedSearchCV (sampling acak ruang parameter, lebih cepat) dan HalvingGridSearchCV (eliminasi progresif).


5. Praktikum Lab 11-1: Komparasi Algoritma pada Dataset Iris

Dataset Iris: 150 sampel, 3 kelas (Setosa, Versicolor, Virginica), 4 fitur (panjang/lebar sepal & petal dalam cm).

"""
Komparasi Algoritma Klasifikasi & Eksekusi Skenario Pengujian
Sumber praktikum: Modul 11 - Membangun Model (DTS 2021)
Disusun ulang oleh: Mahendar Dwi Payana
"""
from sklearn import datasets, metrics
from sklearn.model_selection import train_test_split, cross_val_score
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression
from sklearn.svm import SVC
from sklearn.tree import DecisionTreeClassifier
from sklearn.naive_bayes import GaussianNB
from sklearn.neighbors import KNeighborsClassifier

iris = datasets.load_iris()
X, y = iris.data, iris.target

X_train, X_test, y_train, y_test = train_test_split(
    X, y, train_size=0.7, random_state=42
)

models = {
    "Logistic Regression": LogisticRegression(max_iter=1000, random_state=42),
    "k-NN":                KNeighborsClassifier(),
    "Decision Tree":       DecisionTreeClassifier(max_depth=None, min_samples_split=2, random_state=42),
    "Naive Bayes":         GaussianNB(),
    "SVM Linear":          SVC(kernel='linear', C=1),
    "SVM Polynomial":      SVC(kernel='poly', C=1, gamma=0.01, degree=2),
    "SVM RBF":             SVC(kernel='rbf', C=1, gamma=0.01),
}

for nama, model in models.items():
    pipe = Pipeline([('scaler', StandardScaler()), ('clf', model)])
    pipe.fit(X_train, y_train)
    acc = metrics.accuracy_score(y_test, pipe.predict(X_test))
    cv = cross_val_score(pipe, X, y, cv=5).mean()
    print(f"{nama:<20} : Akurasi = {acc:.4f} | CV-5 = {cv:.4f}")

Catatan Praktikum: Selalu bandingkan model pada data uji yang sama agar perbandingan adil. Untuk data kontinu, GaussianNB biasanya lebih tepat daripada BernoulliNB.


6. Praktikum Lab 11-2: AdaBoost vs. Baseline (Tugas Modul 11)

Sesuai Tugas Harian Modul 11: gunakan dataset Iris, bagi 70% latih / 30% uji, lakukan parameter tuning untuk akurasi terbaik, lalu bandingkan dengan AdaBoost.

from sklearn.ensemble import AdaBoostClassifier
from sklearn import metrics

# Baseline terbaik dari Lab 11-1 (mis. SVM RBF)
svm = SVC(kernel='rbf', C=1, gamma=0.01)
svm.fit(X_train, y_train)
acc_svm = metrics.accuracy_score(y_test, svm.predict(X_test))
print(f"Akurasi SVM RBF : {acc_svm:.4f}")

# AdaBoost
abc = AdaBoostClassifier(n_estimators=50, learning_rate=1, random_state=42)
abc.fit(X_train, y_train)
acc_ab = metrics.accuracy_score(y_test, abc.predict(X_test))
print(f"Akurasi AdaBoost: {acc_ab:.4f}")

Hasil Referensi (Notebook Tugas Modul 11): SVM dengan hyperparameter tepat mencapai akurasi 97,78%, sedangkan AdaBoost 95,56%. Temuan ini menegaskan bahwa boosting tidak otomatis mengalahkan model tunggal — performa bergantung pada karakteristik data. Pada dataset kecil yang relatif mudah dipisahkan seperti Iris, SVM kernel RBF sangat kuat, sedangkan AdaBoost unggul ketika weak learner dapat mengeksploitasi struktur non-linier kompleks.

Catatan Metodologis: Karena Iris hanya 150 baris, selisih 1–2 sampel dapat menggeser akurasi beberapa persen. Gunakan K-Fold Cross-Validation untuk perbandingan yang lebih andal.


7. Studi Kasus: Klasifikasi & Regresi Mutu Pendidikan (SNP)

Studi kasus kelompok (UGM03) memodelkan Standar Nasional Pendidikan (SNP) sekolah SMP di Kabupaten Bogor dari data Dapodik (hasil integrasi Pertemuan 10). Delapan standar (S1–S8) dianalisis untuk memprediksi level SNP.

A. Pelabelan Target (Labeling, SKKNI 010.1)

Nilai SNP = rata-rata delapan standar, lalu dikelompokkan menjadi level ordinal:

# SNP = rata-rata S1..S8
dt_pmp['SNP'] = dt_pmp[['S1','S2','S3','S4','S5','S6','S7','S8']].mean(axis=1)

def level_snp(hitung):
    rerata = round(hitung, 2)
    if   1.00 <= rerata <= 2.04: return 'SNP_1'
    elif 2.05 <= rerata <= 3.70: return 'SNP_2'
    elif 3.71 <= rerata <= 5.06: return 'SNP_3'
    elif 5.07 <= rerata <= 6.66: return 'SNP_4'
    else:                        return 'SNP'

dt_pmp['level'] = dt_pmp.apply(lambda x: level_snp(x['SNP']), axis=1)

B. Penanganan Ketimpangan Kelas

Kelas SNP_3 dan SNP_4 jauh lebih sedikit. Solusi: menambahkan data PMP tahun sebelumnya hanya untuk kelas minoritas (SNP_3), lalu menyelaraskan label menjadi biner (SNP_3 → 0, SNP_4 → 1).

def label_snp(level):
    if level == 'SNP_3':   return 0
    elif level == 'SNP_4': return 1

dt_pmp = dt_pmp.append(
    dt_pmp_2018[dt_pmp_2018['level'] == 'SNP_3'], ignore_index=True
)
dt_pmp['level'] = dt_pmp.apply(lambda x: label_snp(x['level']), axis=1)

C. Seleksi Fitur via Korelasi & Density Plot

Korelasi (kriteria Guilford, 1956) dan density plot per kelas menentukan fitur paling diskriminatif:

Kriteria GuilfordKoefisien rr
Hubungan sangat kuat0,80 – 1,00
Hubungan kuat0,60 – 0,79
Cukup berarti0,40 – 0,59
Rendah0,20 – 0,39
Rendah sekali0,00 – 0,19
import seaborn as sn
import matplotlib.pyplot as plt
from pylab import rcParams

def plot_correlation(data):
    rcParams['figure.figsize'] = 15, 20
    sn.heatmap(data[['S1','S2','S3','S4','S5','S6','S7','S8','level']].corr(),
               annot=True, fmt=".2f")
    plt.show()

plot_correlation(dt_pmp)

Temuan: Fitur paling prediktif adalah S5 (Standar PTK, r=0.95r=0.95) dan S6 (Standar Sarpras, r=0.94r=0.94), disusul S3 (0,60) dan S7 (0,69). Interpretasi itu dikonfirmasi density plot: kurva kelas 0 dan 1 hampir berhimpit pada S2, tetapi terpisah jelas pada S5.

D. Pemodelan Klasifikasi & Evaluasi

from sklearn.model_selection import GridSearchCV
from sklearn.neighbors import KNeighborsClassifier
from sklearn.metrics import accuracy_score
from sklearn.ensemble import AdaBoostClassifier

# Hanya 4 fitur terpilih
X = dt_pmp[['S3', 'S5', 'S6', 'S7']]
y = dt_pmp['level']

X_train, X_test, y_train, y_test = train_test_split(X, y, train_size=0.7, random_state=42)
scaler = StandardScaler()
X_train = scaler.fit_transform(X_train)
X_test = scaler.transform(X_test)

# KNN + GridSearchCV (parameter tuning)
grid = GridSearchCV(KNeighborsClassifier(),
                    dict(n_neighbors=list(range(1, 50)),
                         weights=["uniform", "distance"]),
                    cv=10, scoring='accuracy')
grid.fit(X_train, y_train)
print("KNN terbaik:", grid.best_score_, grid.best_params_)

# AdaBoost sebagai pembanding
ab = AdaBoostClassifier(n_estimators=50, learning_rate=1, random_state=42)
ab.fit(X_train, y_train)
print("Akurasi AdaBoost:", accuracy_score(y_test, ab.predict(X_test)))

Kesimpulan Studi Kasus: Model KNN terbaik memperoleh akurasi tertinggi untuk mengklasifikasikan level SNP berdasarkan fitur S3, S5, S6, dan S7.

E. Pemodelan Regresi (Pelengkap — dibahas tuntas di Pertemuan 12)

Studi kasus juga memodelkan nilai kontinu SNP sebagai target regresi berganda:

import numpy as np
from sklearn import linear_model
from sklearn.metrics import r2_score

msk = np.random.rand(len(dt_pmp)) < 0.8
train_reg, test_reg = dt_pmp[msk], dt_pmp[~msk]

regr = linear_model.LinearRegression()
regr.fit(np.asanyarray(train_reg[['S3','S5','S6','S7']]),
         np.asanyarray(train_reg[['SNP']]))

print("Coefficients:", regr.coef_, "| Intercept:", regr.intercept_)

test_y = np.asanyarray(test_reg[['SNP']])
test_y_ = regr.predict(np.asanyarray(test_reg[['S3','S5','S6','S7']]))
print("MAE   : %.2f" % np.mean(np.absolute(test_y_ - test_y)))
print("MSE   : %.2f" % np.mean((test_y_ - test_y) ** 2))
print("R2    : %.2f" % r2_score(test_y_, test_y))

Persamaan regresi jamak yang diperoleh:

SNP=1.000+0.158 S3+0.146 S5+0.225 S6+…\text{SNP} = 1.000 + 0.158\,S_3 + 0.146\,S_5 + 0.225\,S_6 + \dots

8. Ringkasan Komparasi Model

AlgoritmaAsumsi KunciSensitif Skala?KelebihanKekurangan
Logistic RegressionRelasi linier log-oddsYaCepat, koefisien interpretabelKurang menangkap non-linier
k-NNKedekatan lokalSangatSederhana, non-parametrikLazy learner; biaya prediksi tinggi
Decision TreeRekursif pemisahan GiniTidakMenghasilkan rule; tanpa asumsiMudah overfitting; kompleks
Naive BayesIndependensi fiturTidakBaik pada data kecil; sangat cepatAsumsi independensi sering dilanggar
SVMMargin maksimumYaEfektif dimensi tinggi (kernel)Lambat data besar; tuning CC, γ\gamma
Random ForestBagging pohonTidakRobust, akurasi tinggiKurang interpretabel
AdaBoostBoosting sekuensialTidakFokus sampel sulit; weak → strongSensitif outlier & noise
Gradient Boosting / XGBoostBoosting + regularisasiTidakSOTA tabularBanyak hyperparameter

Kesimpulan Modul: Perancangan skenario eksperimen (pembagian data, strategi langkah, parameter evaluasi) adalah langkah wajib sebelum membangun model. Setiap algoritma memiliki kelebihan dan kekurangan, sehingga diperlukan eksperimen komprehensif untuk mendapatkan model terbaik bagi suatu kasus/dataset.


9. Lembar Evaluasi & Tugas Praktikum Mandiri


10. Referensi Pustaka & Tautan Resmi

  1. Afiahayati, S.Kom., M.Cs., Ph.D. (2021). Modul 11 — Membangun Model dan Studi Kasus. Thematic Academy Digital Talent Scholarship 2021, Kementerian Komunikasi dan Informatika RI.
  2. Kementerian Ketenagakerjaan RI (2020). SKKNI No. 299 Tahun 2020 Bidang Artificial Intelligence Subbidang Data Science (Unit J.62DMI00.012.1 Membangun Skenario Model & J.62DMI00.013.1 Membangun Model).
  3. Christopher M. Bishop (2006). Pattern Recognition and Machine Learning. Springer.
  4. Ronald A. Fisher (1936). The Use of Multiple Measurements in Taxonomic Problems. Annals of Eugenics, 7(2), 179–188. (Dataset Iris).
  5. Corinna Cortes & Vladimir Vapnik (1995). Support-Vector Networks. Machine Learning, 20(3), 273–297. (SVM & Kernel Trick).
  6. Yoav Freund & Robert E. Schapire (1997). A Decision-Theoretic Generalization of On-Line Learning and an Application to Boosting. Journal of Computer and System Sciences, 55(1), 119–139. (Algoritma AdaBoost).
  7. J. P. Guilford (1956). Fundamental Statistics in Psychology and Education (3rd ed.). McGraw-Hill. (Kriteria interpretasi koefisien korelasi).
  8. F. Pedregosa et al. (2011). Scikit-learn: Machine Learning in Python. Journal of Machine Learning Research, 12, 2825–2830.

On this page