SVM dan PCA (Principal Component Analisys)

Dataset : https://www.kaggle.com/uciml/pima-indians-diabetes-database

Studi kasus : Klasifikasi Diabetes

jumlah fitur = 8 

1. Pregnancies: Jumlah kali hamil
2. Glucose: Konsentrasi glukosa plasma dalam 2 jam saat tes toleransi glukosa oral
3. BloodPressure: Tekanan darah diastolik (mm Hg)
4. SkinThickness: Ketebalan lipatan kulit trisep (mm)
5. Insulin: Insulin serum dalam 2 jam (mu U/ml)
6. BMI: Indeks massa tubuh (berat dalam kg / (tinggi dalam meter)^2)
7. DiabetesPedigreeFunction: Nilai fungsi silsilah diabetes
8. Age: Umur (tahun)
9. Outcome: Variabel target, 0 untuk tidak menderita diabetes dan 1 untuk menderita diabetes.

PCA berfungsi untuk mereduksi ke 8 fitur tersebut untuk menjadi 2 fitur baru misal PC1 dan PC 2.  Nilai PC1 dan PC2 merupakan kombinasi linear dari seluruh fitur asli pada dataset. Dengan kata lain komponen 1 dan komponen 2 dihasilkan melalui reduksi dimensi dari seluruh fitur pada dataset dengan menggunakan metode PCA. Oleh karena itu, tidak ada fitur spesifik yang ditentukan sebagai komponen 1 atau 2, melainkan merupakan kombinasi linear dari seluruh fitur pada dataset.

 

import pandas as pd

from sklearn.preprocessing import StandardScaler
from sklearn.decomposition import PCA
from sklearn.svm import SVC
from sklearn.metrics import accuracy_score
from sklearn.metrics import confusion_matrix
import numpy as np
import matplotlib.pyplot as plt

# Load dataset
train_data = pd.read_csv("diabetes-train.csv")
test_data = pd.read_csv("diabetes-test.csv")

# Separate attributes and targets
X_train = train_data.iloc[:, :-1].values
y_train = train_data.iloc[:, -1].values
X_test = test_data.iloc[:, :-1].values
y_test = test_data.iloc[:, -1].values

# Standardize the data
scaler = StandardScaler()
X_train = scaler.fit_transform(X_train)
X_test = scaler.transform(X_test)

# Apply PCA
pca = PCA(n_components=2)
X_train = pca.fit_transform(X_train)
X_test = pca.transform(X_test)

# Print 2 new features from PCA
#print("New feature 1 (PC1):", X_test[:, 0])
#print("New feature 2 (PC2):", X_test[:, 1])

# Print variance ratio of each component
print(pca.explained_variance_ratio_)

# Train SVM
svm = SVC(kernel='linear', random_state=0)
svm.fit(X_train, y_train)

# Make predictions on the test data
y_pred = svm.predict(X_test)

# Calculate accuracy
accuracy = accuracy_score(y_test, y_pred)
print("Accuracy: {:.2f}%".format(accuracy*100))

# Menghitung confusion matrix
cm = confusion_matrix(y_test, y_pred)

# Menampilkan confusion matrix
print("Confusion matrix:")
print(cm)

# Print coefficients of the hyperplane
print("Coefficients of the hyperplane: ", svm.coef_)

# Plot decision boundary
x_min, x_max = X_test[:, 0].min() - 1, X_test[:, 0].max() + 1
y_min, y_max = X_test[:, 1].min() - 1, X_test[:, 1].max() + 1
xx, yy = np.meshgrid(np.arange(x_min, x_max, 0.1), np.arange(y_min, y_max, 0.1))
Z = svm.predict(np.c_[xx.ravel(), yy.ravel()])
Z = Z.reshape(xx.shape)
plt.contourf(xx, yy, Z, alpha=0.4)
plt.scatter(X_test[:, 0], X_test[:, 1], c=y_pred, s=20, edgecolor='k')
plt.xlabel('PC1')
plt.ylabel('PC2')
plt.title('SVM Decision Boundary')
plt.show()

# Print actual and predicted values for each test data point
#print("{:<10} {:<15} {}".format('Index', 'Actual Value', 'Predicted Value'))
#for i in range(len(y_test)):
#    print("{:<10} {:<15} {}".format(i+1, y_test[i], y_pred[i]))

# Save actual and predicted values to txt file
with open('actual_pred.txt', 'w') as f:
    f.write("{:<10} {:<15} {}\n".format('Index', 'Actual Value', 'Predicted Value'))
    for i in range(len(y_test)):
        f.write("{:<10} {:<15} {}\n".format(i+1, y_test[i], y_pred[i]))
print("Actual and predicted values saved to actual_pred.txt file")

# Save 2 new features to excel file
new_features = pd.DataFrame({'New feature 1 (PC1)': X_test[:, 0], 'New feature 2 (PC2)': X_test[:, 1]})
new_features.to_excel('new-features.xlsx', index=False)

Hasil Running Program

Dua Fitur yang Dihasilkan oleh PCA

Penjelasan Program

# Standardize the data
scaler = StandardScaler()
X_train = scaler.fit_transform(X_train)
X_test = scaler.transform(X_test)

- - -

Baris kode scaler = StandardScaler() digunakan untuk membuat objek scaler yang akan digunakan untuk melakukan standardisasi pada data, 

pada baris kode X_train = scaler.fit_transform(X_train), objek scaler digunakan untuk melakukan proses standardisasi pada data latih (X_train). Proses standardisasi ini dilakukan dengan mengubah skala nilai pada setiap fitur sehingga memiliki mean (rerata) 0 dan standar deviasi (simpangan baku) 1. Hal ini bertujuan untuk memastikan bahwa semua fitur memiliki pengaruh yang setara terhadap model yang akan dibangun

Baris kode X_test = scaler.transform(X_test) digunakan untuk melakukan proses standardisasi yang sama pada data uji (X_test) menggunakan objek scaler yang sama dengan yang digunakan pada data latih.

Menuliskan hasil Standarisasi Fitur pada File

import pandas as pd

from sklearn.preprocessing import StandardScaler

# Read data train and test

train_data = pd.read_csv('diabetes-train.csv')

test_data = pd.read_csv('diabetes-test.csv')

# Separate features and target variable

X_train = train_data.iloc[:, :-1].values

y_train = train_data.iloc[:, -1].values

X_test = test_data.iloc[:, :-1].values

y_test = test_data.iloc[:, -1].values

# Standardize the data

scaler = StandardScaler()

X_train_std = scaler.fit_transform(X_train)

X_test_std = scaler.transform(X_test)

# Create standardized dataframes

train_data_std = pd.DataFrame(data=X_train_std, columns=train_data.columns[:-1])

test_data_std = pd.DataFrame(data=X_test_std, columns=test_data.columns[:-1])

train_data_std['Outcome'] = y_train

test_data_std['Outcome'] = y_test

# Save to Excel

with pd.ExcelWriter('diabetes-std.xlsx', engine='xlsxwriter') as writer:

    train_data_std.to_excel(writer, sheet_name='Train', index=False)

    test_data_std.to_excel(writer, sheet_name='Test', index=False)

----

Standarisasi Nilai-Nilai Fitur

# Apply PCA

pca = PCA(n_components=2)

X_train = pca.fit_transform(X_train)

X_test = pca.transform(X_test)

Bars program di atas bertujuan untuk mengimplementasikan PCA (Principal Component Analysis) pada data. PCA adalah salah satu teknik reduksi dimensi yang berguna dalam mengatasi masalah overfitting dan mengurangi kompleksitas model. PCA diaplikasikan pada data latih dan data uji dengan memanggil objek PCA dari library scikit-learn. Argumen n_components diatur menjadi 2 untuk menghasilkan 2 fitur baru yang merupakan kombinasi linier dari fitur asli yang paling signifikan dalam menjelaskan varian data.

Setelah PCA diaplikasikan, fitur-fitur asli pada data latih dan data uji diubah ke dalam representasi fitur-fitur baru yang dihasilkan oleh PCA. Ini dilakukan dengan memanggil metode fit_transform() pada data latih dan transform() pada data uji.

----

Bersambung

SVM Studi Kasus Diabetes & Confusion Matrix

Dataset : https://www.kaggle.com/uciml/pima-indians-diabetes-database

Studi kasus : Klasifikasi Diabetes

Dataset yang digunakan adalah Pima Indians Diabetes Database. Dataset ini berisi informasi klinis tentang 768 pasien wanita Pima Indian yang berusia di atas 21 tahun. Dataset ini memiliki 9 kolom, yaitu:

1. Pregnancies: Jumlah kali hamil
2. Glucose: Konsentrasi glukosa plasma dalam 2 jam saat tes toleransi glukosa oral
3. BloodPressure: Tekanan darah diastolik (mm Hg)
4. SkinThickness: Ketebalan lipatan kulit trisep (mm)
5. Insulin: Insulin serum dalam 2 jam (mu U/ml)
6. BMI: Indeks massa tubuh (berat dalam kg / (tinggi dalam meter)^2)
7. DiabetesPedigreeFunction: Nilai fungsi silsilah diabetes
8. Age: Umur (tahun)
9. Outcome: Variabel target, 0 untuk tidak menderita diabetes dan 1 untuk menderita diabetes.

Tujuan dari dataset ini adalah untuk memprediksi apakah seorang pasien wanita Pima Indian akan mengalami diabetes atau tidak berdasarkan informasi klinis yang diberikan.

#SVM diabetes #https://www.kaggle.com/uciml/pima-indians-diabetes-database/download import pandas as pd import numpy as np import requests from io import BytesIO import zipfile from sklearn.model_selection import train_test_split from sklearn.svm import SVC from sklearn.metrics import accuracy_score # Download dataset #file_url = "https://www.kaggle.com/uciml/pima-indians-diabetes-database/download" #r = requests.get(file_url) #z = zipfile.ZipFile(BytesIO(r.content)) #z.extractall() # Load dataset dataset = pd.read_csv('diabetes.csv') # Split into features and label X = dataset.drop('Outcome', axis=1) y = dataset['Outcome'] # Split into train and test set X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42) # Create SVM model svm_model = SVC(kernel='linear') # Train SVM model svm_model.fit(X_train, y_train) # Make prediction y_pred = svm_model.predict(X_test) # Calculate accuracy accuracy = accuracy_score(y_test, y_pred) print('Accuracy:', accuracy) # Print confusion matrix and classification report print('Confusion matrix:\n', confusion_matrix(y_test, y_pred)) print('Classification report:\n', classification_report(y_test, y_pred)) # Display actual and predicted values df_compare = pd.DataFrame({'Actual': y_test, 'Predicted': y_pred})

print(df_compare.head(10))

Hasil Program :

Accuracy: 0.7532467532467533

Confusion matrix:

[[80 19]

[19 36]]

Classification report:

precision recall f1-score support

0 0.81 0.81 0.81 99 1 0.65 0.65 0.65 55 accuracy 0.75 154 macro avg 0.73 0.73 0.73 154 weighted avg 0.75 0.75 0.75 154 Actual Predicted 668 0 0 324 0 0 624 0 0 690 0 0 473 0 0 204 0 0 97 0 0 336 0 1 568 0 1

148 0 1

CONFUSION MATRIX

Dalam program di atas, confusion matrix dapat dihitung menggunakan fungsi confusion_matrix() yang tersedia dalam scikit-learn. Hasil confusion matrix kemudian ditampilkan dengan menggunakan fungsi print(). Confusion matrix merupakan suatu tabel yang menunjukkan jumlah prediksi yang benar dan yang salah pada setiap kelas target. Confusion matrix memiliki 4 elemen, yaitu True Positive (TP), False Positive (FP), False Negative (FN), dan True Negative (TN). Berikut penjelasan dari setiap elemen tersebut:

• True Positive (TP) : jumlah data yang benar diprediksi sebagai positif
• False Positive (FP) : jumlah data yang salah diprediksi sebagai positif
• False Negative (FN) : jumlah data yang salah diprediksi sebagai negatif
• True Negative (TN) : jumlah data yang benar diprediksi sebagai negatif

Dalam program di atas, confusion matrix menunjukkan hasil sebagai matriks 2x2, dengan baris pertama menunjukkan kelas "0" (yang negatif) dan baris kedua menunjukkan kelas "1" (yang positif). Oleh karena itu, kita dapat membaca hasil confusion matrix sebagai berikut:

1. Pada baris pertama, kolom pertama menunjukkan jumlah data yang benar diprediksi sebagai negatif (True Negative, TN) dan kolom kedua menunjukkan jumlah data yang salah diprediksi sebagai positif (False Positive, FP).
2. Pada baris kedua, kolom pertama menunjukkan jumlah data yang salah diprediksi sebagai negatif (False Negative, FN) dan kolom kedua menunjukkan jumlah data yang benar diprediksi sebagai positif (True Positive, TP).

Dengan mengetahui elemen-elemen dalam confusion matrix, kita dapat menghitung berbagai metrik evaluasi model seperti akurasi, precision, recall, dan F1-score.

Support Vector Machine & Quadratic Programming

Algoritma SVM (Support Vector Machine) adalah algoritma pembelajaran mesin yang digunakan untuk klasifikasi dan regresi. Algoritma ini mencari hyperplane (garis pembatas) yang terbaik memisahkan dua kelas dengan margin terbesar.

Proses pembelajaran SVM dimulai dengan memberikan data latih kepada algoritma, yang kemudian menghitung hyperplane terbaik. Hyperplane ini dipilih sedemikian rupa sehingga margin (jarak antara hyperplane dan titik-titik terdekat pada setiap kelas) sebesar-besarnya. Titik-titik ini disebut sebagai support vector.

SVM mengoptimalkan margin dengan mencari hyperplane yang memiliki margin terbesar. Hal ini dilakukan dengan menggunakan teknik matematika yang disebut "quadratic programming" untuk menemukan parameter optimal yang diperlukan untuk menentukan hyperplane terbaik.

Setelah hyperplane terbaik ditemukan, algoritma dapat digunakan untuk memprediksi label dari data yang belum diketahui. Data baru akan ditempatkan pada satu sisi hyperplane atau sisi lainnya tergantung di mana letaknya relatif terhadap hyperplane, dan akan diberikan label yang sesuai dengan sisi yang dipilih.

Dalam beberapa kasus, data tidak dapat dipisahkan secara linier menggunakan hyperplane. Dalam hal ini, SVM menggunakan teknik kernel untuk memproyeksikan data ke dalam dimensi yang lebih tinggi, di mana data dapat dipisahkan secara linier. Teknik kernel dapat diterapkan pada berbagai jenis fungsi kernel, seperti linear, polinomial, sigmoid, atau radial basis function (RBF).

Dalam kesimpulannya, SVM adalah algoritma pembelajaran mesin yang kuat dan efektif untuk klasifikasi dan regresi. Algoritma ini dapat menangani data dengan baik dalam kasus-kasus di mana kelas tidak dapat dipisahkan secara linier, dan memiliki keuntungan dalam mengoptimalkan margin untuk meningkatkan kinerja model.

---

Quadratic programming (QP) adalah suatu metode optimasi yang digunakan dalam SVM untuk menyelesaikan masalah pemrograman kuadrat. SVM memerlukan QP untuk menentukan hyperplane optimal yang memisahkan dua kelas data dengan margin yang maksimal.

Dalam konteks SVM, QP mengambil data latih sebagai input dan meminimalkan fungsi biaya yang terkait dengan margin maksimal. Fungsi biaya ini melibatkan parameter λ yang digunakan untuk mengontrol trade-off antara margin dan kesalahan klasifikasi.

Dalam praktiknya, QP digunakan untuk menyelesaikan masalah pemrograman kuadrat yang melibatkan konstrain seperti ketidaknegatifan dari variabel dan kesetimbangan dari jumlah kesalahan klasifikasi positif dan negatif. Dalam hal ini, QP digunakan untuk menentukan koefisien hyperplane yang optimal dan memisahkan dua kelas data dengan margin maksimal.

Secara umum, QP adalah proses yang kompleks dan membutuhkan perhitungan matematis yang rumit. Namun, implementasi QP dalam SVM telah diperbaiki seiring berkembangnya teknologi, sehingga saat ini telah tersedia beberapa pustaka atau library QP open source yang dapat digunakan untuk menyelesaikan masalah SVM secara efektif dan efisien.

Beberapa contoh library QP yang dapat digunakan untuk mendukung implementasi SVM dengan quadratic programming adalah:

1. CVXOPT: library ini menyediakan alat untuk menyelesaikan masalah optimasi konveks dengan menggunakan bahasa pemrograman Python. CVXOPT mendukung berbagai jenis masalah optimasi, termasuk quadratic programming yang digunakan dalam SVM. CVXOPT juga dapat digunakan untuk menyelesaikan masalah optimasi dalam bentuk umum dengan memanfaatkan fungsi yang tersedia pada library tersebut.

1. CVXOPT: library ini menyediakan alat untuk menyelesaikan masalah optimasi konveks dengan menggunakan bahasa pemrograman Python. CVXOPT mendukung berbagai jenis masalah optimasi, termasuk quadratic programming yang digunakan dalam SVM. CVXOPT juga dapat digunakan untuk menyelesaikan masalah optimasi dalam bentuk umum dengan memanfaatkan fungsi yang tersedia pada library tersebut.

1. LIBSVM: library ini menyediakan implementasi SVM dengan menggunakan quadratic programming. LIBSVM merupakan library populer yang mendukung berbagai jenis SVM, termasuk SVM dengan kernel non-linear. LIBSVM dapat digunakan dalam bahasa pemrograman C, C++, dan Java, dan memiliki dukungan untuk beberapa jenis format data.

1. QuadProg++: library ini merupakan implementasi open-source dari algoritma quadratic programming. QuadProg++ menyediakan solusi untuk masalah optimasi quadratic dengan memanfaatkan metode active-set. Library ini dapat digunakan dalam bahasa pemrograman C++, dan mendukung berbagai jenis masalah optimasi, termasuk yang terkait dengan SVM.