Tugas 1 Machine Learning

[KEMBALI KE MENU SEBELUMNYA]

DAFTAR ISI

1. Latar Belakang

2. Tujuan

3. Dataset

4. Metodologi

5. Hasil Analisis

6. Kesimpulan

7. Download File

Prediksi Stabilitas Jaringan Listrik Menggunakan Algoritma Naïve Bayes dan K-Means

1. Latar Belakang [back]

Stabilitas jaringan listrik sangat penting untuk mencegah gangguan dan blackout
Peningkatan permintaan energi dan variasi beban membuat prediksi stabilitas menjadi lebih kompleks.

2. Tujuan [back]

Memprediksi apakah jaringan listrik stabil atau tidak.
Mengoptimalkan analisis data dengan kombinasi K-Means dan Naïve Bayes.
Membandingkan hasil clustering dan klasifikasi untuk meningkatkan akurasi prediksi.

3. Dataset [back]

Dataset: Data_for_UCI_named (UCI Machine Learning Repository).

Informasi Atribut:

11 atribut prediktif, 1 atribut non-prediktif (p1), 2 bidang target:

tau[x]: waktu reaksi partisipan (real dari rentang [0,5–10] detik). Tau1 – nilai untuk produsen listrik.
p[x]: daya nominal yang dikonsumsi (negatif)/dihasilkan (positif) (real). Untuk konsumen dari rentang [-0,5, -2] s^-2; p1 = |p2 + p3 + p4|
g[x]: koefisien (gamma) yang sebanding dengan elastisitas harga (real dari rentang [0,05–1] s^-1). g1 – nilai untuk produsen listrik.
stab: bagian real maksimal dari akar persamaan karakteristik (jika positif – sistem secara linear tidak stabil) (real)
stabf: label stabilitas sistem (kategorikal: stabil/tidak stabil)

4. Metodologi [back]

A. Naïve Bayes

Algoritma Naive Bayes adalah algoritma machine learning berbasis probabilitas yang menggunakan Teorema Bayes untuk melakukan klasifikasi.

Disebut “naive” karena algoritma ini mengasumsikan bahwa setiap fitur (atribut) saling independen satu sama lain, meskipun pada kenyataannya asumsi ini sering tidak sepenuhnya benar.

Gaussian Naive Bayes

Gaussian Naive Bayes digunakan untuk klasifikasi prediksi stabilitas jaringan listrik.
Input: Fitur asli.
Langkah (Python):

Kode program (python)

# =========================================================
# 📘 Prediksi Stabilitas Jaringan Listrik
# 🚀 Naïve Bayes (FINAL OPTIMIZED VERSION)
# Dataset : Data_for_UCI_named.csv (10.000 data)
# =========================================================

# 1️⃣ Import Library
import pandas as pd
import seaborn as sns
import matplotlib.pyplot as plt

from sklearn.model_selection import train_test_split, GridSearchCV
from sklearn.preprocessing import StandardScaler
from sklearn.pipeline import Pipeline
from sklearn.naive_bayes import GaussianNB
from sklearn.feature_selection import SelectKBest, f_classif
from sklearn.metrics import (
    accuracy_score,
    precision_score,
    recall_score,
    f1_score,
    confusion_matrix,
    classification_report,
    roc_auc_score
)

from google.colab import files

# 2️⃣ Upload Dataset
print("Upload file Data_for_UCI_named.csv")
uploaded = files.upload()

# 3️⃣ Load Dataset
data = pd.read_csv("Data_for_UCI_named.csv")

print("\n=== INFO DATASET ===")
print(data.info())

print("\n=== DISTRIBUSI TARGET ===")
print(data['stabf'].value_counts())

# 4️⃣ Pisahkan Fitur & Target
X = data.drop('stabf', axis=1)
y = data['stabf'].map({'stable': 0, 'unstable': 1})

# 5️⃣ Stratified Train-Test Split
X_train, X_test, y_train, y_test = train_test_split(
    X, y,
    test_size=0.2,
    stratify=y,
    random_state=42
)

print(f"\nJumlah data latih : {len(X_train)}")
print(f"Jumlah data uji   : {len(X_test)}")

# 6️⃣ Pipeline (Scaler + Feature Selection + Naïve Bayes)
pipeline = Pipeline([
    ('scaler', StandardScaler()),
    ('select', SelectKBest(score_func=f_classif)),
    ('nb', GaussianNB())
])

# 7️⃣ Hyperparameter Tuning (Batas Maksimal NB)
param_grid = {
    'select__k': [6, 8, 10, 12],
    'nb__var_smoothing': [1e-12, 1e-10, 1e-9, 1e-8]
}

grid = GridSearchCV(
    pipeline,
    param_grid,
    cv=10,
    scoring='accuracy',
    n_jobs=-1
)

print("\n⏳ Training & Optimasi Model...")
grid.fit(X_train, y_train)

print("\n✅ Parameter Terbaik:")
print(grid.best_params_)

# 8️⃣ Model Terbaik
best_model = grid.best_estimator_

# 9️⃣ Prediksi
y_pred = best_model.predict(X_test)
y_prob = best_model.predict_proba(X_test)[:, 1]

# 🔟 Evaluasi Model
akurasi = accuracy_score(y_test, y_pred)
presisi = precision_score(y_test, y_pred)
recall = recall_score(y_test, y_pred)
f1 = f1_score(y_test, y_pred)
roc_auc = roc_auc_score(y_test, y_prob)

print("\n=== HASIL EVALUASI (FINAL NAÏVE BAYES) ===")
print(f"Akurasi  : {akurasi:.4f}")
print(f"Presisi  : {presisi:.4f}")
print(f"Recall   : {recall:.4f}")
print(f"F1-Score : {f1:.4f}")
print(f"ROC-AUC  : {roc_auc:.4f}")

# 1️⃣1️⃣ Confusion Matrix
cm = confusion_matrix(y_test, y_pred)
plt.figure(figsize=(6, 4))
sns.heatmap(
    cm,
    annot=True,
    fmt='d',
    cmap='Blues',
    xticklabels=['Pred: Stable', 'Pred: Unstable'],
    yticklabels=['Actual: Stable', 'Actual: Unstable']
)
plt.title('Confusion Matrix - Final Naïve Bayes')
plt.xlabel('Prediksi')
plt.ylabel('Aktual')
plt.show()

# 1️⃣2️⃣ Classification Report
print("\n=== CLASSIFICATION REPORT ===")
print(classification_report(y_test, y_pred, target_names=['Stable', 'Unstable']))

📘 PENJELASAN SETIAP SYNTAX KODE

(Naïve Bayes – Versi Akurasi Maksimal)

1️⃣ Import Library

import pandas as pd

➡️ Digunakan untuk:

Membaca dataset CSV
Mengelola data dalam bentuk tabel (DataFrame)

import seaborn as sns
import matplotlib.pyplot as plt

➡️ Digunakan untuk:

Visualisasi data
Menampilkan confusion matrix dalam bentuk heatmap

from sklearn.model_selection import train_test_split, GridSearchCV

➡️ train_test_split
Membagi data menjadi data latih dan data uji

➡️ GridSearchCV
Mencari kombinasi parameter terbaik menggunakan cross validation

from sklearn.preprocessing import StandardScaler

➡️ Menstandarkan fitur:

Mean = 0
Standar deviasi = 1

from sklearn.pipeline import Pipeline

➡️ Menggabungkan beberapa tahap pemrosesan:

Scaling
Seleksi fitur
Klasifikasi

➡️ Mencegah data leakage

from sklearn.naive_bayes import GaussianNB

➡️ Model Naïve Bayes untuk data numerik kontinu
Mengasumsikan distribusi Gaussian

from sklearn.feature_selection import SelectKBest, f_classif

➡️ Memilih fitur terbaik

f_classif: ANOVA F-test
Mengurangi fitur tidak relevan

from sklearn.metrics import (...)

➡️ Digunakan untuk evaluasi kinerja model:

Accuracy
Precision
Recall
F1-score
Confusion Matrix
ROC-AUC

from google.colab import files

➡️ Digunakan untuk upload dataset di Google Colab

2️⃣ Upload Dataset

uploaded = files.upload()

➡️ Menampilkan dialog upload file di Colab
➡️ File CSV akan tersimpan sementara

3️⃣ Load Dataset

data = pd.read_csv("Data_for_UCI_named.csv")

➡️ Membaca dataset CSV menjadi DataFrame

print(data.info())

➡️ Menampilkan:

Jumlah kolom
Tipe data
Missing value

print(data['stabf'].value_counts())

➡️ Melihat distribusi kelas:

stable
unstable

4️⃣ Pisahkan Fitur dan Target

X = data.drop('stabf', axis=1)

➡️ X: semua fitur input
➡️ axis=1: menghapus kolom

y = data['stabf'].map({'stable': 0, 'unstable': 1})

➡️ Mengubah label kategori menjadi numerik:

stable → 0
unstable → 1

5️⃣ Train-Test Split

X_train, X_test, y_train, y_test = train_test_split(
    X, y,
    test_size=0.2,
    stratify=y,
    random_state=42
)

Penjelasan parameter:

Parameter	Fungsi
`test_size=0.2`	80% latih, 20% uji
`stratify=y`	Menjaga proporsi kelas
`random_state=42`	Hasil konsisten

6️⃣ Pipeline

pipeline = Pipeline([
    ('scaler', StandardScaler()),
    ('select', SelectKBest(score_func=f_classif)),
    ('nb', GaussianNB())
])

➡️ Tahapan berurutan:

Standarisasi fitur
Seleksi fitur terbaik
Klasifikasi Naïve Bayes

➡️ Semua tahap hanya dilatih pada data training

7️⃣ Hyperparameter Tuning

param_grid = {
    'select__k': [6, 8, 10, 12],
    'nb__var_smoothing': [1e-12, 1e-10, 1e-9, 1e-8]
}

Penjelasan:

select__k → jumlah fitur terbaik
var_smoothing → mencegah variansi nol pada Gaussian

grid = GridSearchCV(
    pipeline,
    param_grid,
    cv=10,
    scoring='accuracy',
    n_jobs=-1
)

Parameter	Fungsi
`cv=10`	10-fold cross validation
`scoring='accuracy'`	Metrik evaluasi
`n_jobs=-1`	Gunakan semua CPU

8️⃣ Training Model

grid.fit(X_train, y_train)

➡️ Melatih model dengan semua kombinasi parameter

grid.best_params_

➡️ Menampilkan parameter terbaik

best_model = grid.best_estimator_

➡️ Mengambil model terbaik

9️⃣ Prediksi

y_pred = best_model.predict(X_test)

➡️ Memprediksi kelas

y_prob = best_model.predict_proba(X_test)[:, 1]

➡️ Probabilitas kelas unstable
➡️ Digunakan untuk ROC-AUC

🔟 Evaluasi

accuracy_score(y_test, y_pred)

➡️ Persentase prediksi benar

precision_score(y_test, y_pred)

➡️ Ketepatan prediksi kelas positif

recall_score(y_test, y_pred)

➡️ Kemampuan mendeteksi kelas positif

f1_score(y_test, y_pred)

➡️ Rata-rata harmonik precision & recall

roc_auc_score(y_test, y_prob)

➡️ Kemampuan pemisahan kelas

1️⃣1️⃣ Confusion Matrix

confusion_matrix(y_test, y_pred)

➡️ Tabel kesalahan prediksi

sns.heatmap(...)

➡️ Visualisasi confusion matrix

1️⃣2️⃣ Classification Report

classification_report(y_test, y_pred)

➡️ Ringkasan lengkap performa model

B. K-Means (Rapidminer)

K-Means adalah algoritma machine learning unsupervised learning yang digunakan untuk clustering (pengelompokan data) berdasarkan kemiripan (jarak) antar data.

Artinya, K-Means tidak menggunakan label kelas, melainkan mengelompokkan data secara otomatis ke dalam K kelompok (cluster).

Digunakan untuk clustering data awal.
Menentukan pola/kelompok tersembunyi dalam data.
Langkah:

1. Retrieve Dataset

Gunakan operator Retrieve untuk memuat dataset Data_for_UCI_named.

2. Set Role

Tentukan kolom target (stabf) menjadi label dengan operator Set Role.

3. Multiply Data

Gunakan operator Multiply jika ingin mencoba beberapa jumlah cluster (k) secara paralel.
Ini memungkinkan evaluasi beberapa konfigurasi K-Means sekaligus.

4. K-Means Clustering

Tambahkan operator K-Means untuk masing-masing dataset hasil multiply.

Sesuaikan parameter k (jumlah cluster) sesuai eksperimen: k=2, k=3, k=4, k=5, k=6, k=7
Hubungkan output exa (examples) ke operator evaluasi.

5. Performance / Evaluation

Gunakan operator Performance (Cluster Distance Performance) untuk menilai kualitas cluster.

6. Output / Analisis

Pilih jumlah k optimal berdasarkan kriteria evaluasi dengan Elbow Method.

5. Hasil Analisis [back]

=== HASIL EVALUASI (FINAL NAÏVE BAYES) === Akurasi : 0.9865 Presisi : 0.9898 Recall : 0.9890 F1-Score : 0.9894

ROC-AUC : 0.9992

=== CLASSIFICATION REPORT === precision recall f1-score support Stable 0.98 0.98 0.98 724 Unstable 0.99 0.99 0.99 1276 accuracy 0.99 2000 macro avg 0.99 0.99 0.99 2000 weighted avg 0.99 0.99 0.99 2000

Dari matriks ini, kita dapat mengamati secara kuantitatif:

Jumlah False Positives (FP) yang sangat rendah, yaitu 14, menegaskan kemampuan model untuk menghindari salah menandai kondisi stabil sebagai tidak stabil.
Jumlah False Negatives (FN) yang rendah, yaitu 13, menunjukkan bahwa model jarang gagal mendeteksi ketidakstabilan yang sebenarnya terjadi, yang sangat penting untuk keandalan operasional.

Dengan Rapidminer diperoleh:

Berdasarkan data rata-rata dalam jarak centroid pada setiap variasi k, gunakan metode elbow untuk menentukan nilai k untuk jumlah cluster yang paling optimal

selisih rata rata jarak centroid

k=2 - k=3: 3,47

k=3 - k=4: 2,784

k=4 - k=5: 2,092

k=5 - k=6: 1,503

k=6 - k=7: 1,458

dengan metode elbow diperoleh k=4 untuk jumlah cluster paling optimal

6. Kesimpulan [back]

Model Naive Bayes berhasil memprediksi stabilitas jaringan listrik pada dataset yang telah diproses dengan sangat akurat, mencapai akurasi 98,65%, presisi 98,98%, dan recall 98,9%. Presisi tinggi mengurangi risiko false alarm, sedangkan recall tinggi memastikan deteksi instabilitas nyata, menjadikan model ini andal dan efisien untuk manajemen sistem tenaga listrik. Sebelum klasifikasi, K-Means clustering dengan K=4 (hasil Metode Elbow) bisa digunakan untuk mengidentifikasi struktur data optimal, memudahkan pembersihan anomali dan noise, sehingga meningkatkan kualitas dan representasi dataset. Kombinasi kedua metode ini menunjukkan pendekatan yang kuat, praktis, dan efektif untuk analisis dan prediksi stabilitas jaringan listrik. Sehingga dapat disimpulkan bahwa model ini memberikan hasil yang lebih baik dibandingkan dengan artikel sumber.