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.

Mendownload Dataset dari Kaggle ke Google Driver

Pada tulisan ini akan diberikan contoh untuk mendownload dataset pada kaggle dan tersimpan langsung pada Google Drive, tanpa terlebih dahulu di download ke storage pada PC/Laptop. Proses download dilakukan melalui Google Colab.

1. Jalankan perintah berikut :
• !pip install kaggle
• !pip install google-auth google-auth-oauthlib google-auth-httplib2
2. Buat API pada web kaggle, kemudian pada program di bawah isi dengan username dan key yang didapatkan.
3. Upload file kaggle.jason pada directory google drive

from google.colab import drive

from google.colab import files

from google.colab import auth

import os

# Mount Google Drive

drive.mount('/content/drive')

# Path untuk menyimpan file kaggle.json yang sudah diupload ke Google Drive

kaggle_json_path = '/content/drive/MyDrive/kaggle.json'

# Path untuk dataset pada Kaggle

kaggle_dataset_path = 'tawsifurrahman/tuberculosis-tb-chest-xray-dataset'

# Jalankan autentikasi

auth.authenticate_user()

# Set konfigurasi API Kaggle

os.environ['KAGGLE_USERNAME'] = "xxxxxx"

os.environ['KAGGLE_KEY'] = "xxxxxxx"

# Mengcopy file kaggle.json dari Google Drive ke direktori .kaggle

!mkdir -p ~/.kaggle

!cp "/content/drive/MyDrive/Colab Notebooks/kaggle.json" ~/.kaggle/kaggle.json

!chmod 600 ~/.kaggle/kaggle.json

# Mengunduh dataset dari Kaggle

!kaggle datasets download -d {kaggle_dataset_path} -p "/content/drive/MyDrive/dataset/"

# Menampilkan file yang sudah terunduh

!ls "/content/drive/MyDrive/dataset/"

Ekstrak DataSet pada Google Drive

import zipfile

zip_file = "/content/drive/MyDrive/dataset/tuberculosis-tb-chest-xray-dataset.zip"

destination_folder = "/content/drive/MyDrive/dataset/tuberculosis-tb-chest-xray-dataset"

with zipfile.ZipFile(zip_file, 'r') as zip_ref:

    zip_ref.extractall(destination_folder)

7.3 Support Vector Machine (1)

Sumber : Machine Learning: The Art and Science of Algorithms that Make Sense of Data", Peter Flach

--

SVM atau Support Vector Machine adalah salah satu algoritma machine learning untuk melakukan klasifikasi data. Konsep dasar dari SVM adalah mencari sebuah garis atau bidang pemisah yang dapat memisahkan dua kelas data dengan margin yang maksimum. Margin adalah jarak antara garis pemisah dengan titik data terdekat dari kedua kelas. SVM mencari garis pemisah ini dengan cara memaksimalkan margin antara kedua kelas.

Dalam buku Machine Learning: The Art and Science of Algorithms that Make Sense of Data, SVM dibahas pada bab 7.3. SVM adalah salah satu algoritma linear yang dapat menghasilkan model dengan tingkat akurasi yang baik. SVM bekerja dengan mengubah ruang data menjadi ruang yang lebih tinggi, dimana data yang awalnya tidak terpisah secara linier dapat dipisahkan dengan garis pemisah yang linier. SVM menggunakan kernel function untuk melakukan transformasi ini.

Keuntungan dari SVM adalah kemampuannya dalam menangani data yang kompleks dengan jumlah fitur yang besar. Selain itu, SVM juga mampu menangani data yang tidak seimbang dengan baik, yaitu ketika jumlah data pada kelas yang satu jauh lebih sedikit dari kelas yang lain. Namun, kekurangan dari SVM adalah kurang efisien dalam mengolah data yang sangat besar dan kompleks, serta membutuhkan pemilihan parameter yang tepat untuk mendapatkan hasil yang optimal.

Dalam implementasinya, SVM dapat digunakan untuk berbagai macam tugas, seperti klasifikasi biner dan multi-kelas, regresi, deteksi outlier, dan lain sebagainya. SVM telah digunakan dalam berbagai bidang, seperti pengenalan gambar, pengenalan suara, bioinformatika, dan sebagainya.

Figure 7.7

Gambar 7.7 menunjukkan geometri dari sebuah Support Vector Machine (SVM) untuk mengklasifikasikan dua kelas data. SVM mencari garis yang terbaik untuk memisahkan kedua kelas data tersebut. Garis ini disebut dengan hyperplane, Hyperplane adalah permukaan yang memiliki dimensi satu kurang dari ruang fitur. Dalam kasus dua dimensi, hyperplane adalah garis, sedangkan dalam tiga dimensi, hyperplane adalah bidang.

Pada gambar tersebut, terdapat dua kelas yaitu kelas positif (berwarna biru) dan kelas negatif (berwarna merah). Ada beberapa titik data yang ditandai dengan lingkaran pada gambar, yang disebut support vectors. Support vectors adalah titik data pelatihan yang terletak di sekitar garis batas keputusan (decision boundary) dan memberikan sumbu untuk menentukan garis batas keputusan.

Dalam notasi matematika, hyperplane didefinisikan sebagai w · x + b = 0, di mana w adalah normal vektor hyperplane dan b adalah bias. Vektor normal w menentukan orientasi dari hyperplane, sedangkan bias b mengontrol jarak antara garis batas keputusan dengan titik-titik pelatihan terdekat.

Pada gambar 7.7, garis batas keputusan ditunjukkan sebagai garis hitam tebal yang memisahkan dua kelas.

Margin adalah jarak antara garis batas keputusan dengan support vector terdekat. Margin ini dinyatakan sebagai m = 1/||w||, di mana ||w|| adalah norma Euclidean dari vektor w. Dalam kasus dua dimensi, ||w|| dapat dinyatakan sebagai akar kuadrat dari w1^2 + w2^2.

Tujuan dari SVM adalah untuk menemukan garis batas keputusan yang memaksimalkan margin m. Ini dapat dirumuskan sebagai masalah optimasi dengan batasan, di mana batasan adalah memastikan bahwa semua titik pelatihan berada pada sisi yang benar dari garis batas keputusan. Solusi untuk masalah optimasi ini dapat ditemukan menggunakan teknik optimasi, seperti algoritma lagrange.

chap7. Linier Model

 Sumber : Machine Learning: The Art and Science of Algorithms that Make Sense of Data", Peter Flach

---

Bab 7 membahas tentang model linier, yang merupakan jenis model yang berbeda dengan model logis yang dibahas di bab sebelumnya. Model-model dalam bab ini dan bab berikutnya didefinisikan dalam ruang misalnya dengan menggunakan geometri. Meskipun sebagian besar fitur bernilai real tidak intrinsik bersifat geometris, seperti usia seseorang atau suhu sebuah objek, kita masih bisa membayangkan fitur tersebut dicatat dalam sistem koordinat Kartesius d-dimensi. Kemudian, kita dapat menggunakan konsep geometri seperti garis dan bidang untuk membangun model klasifikasi, atau menggunakan konsep geometri jarak untuk merepresentasikan kesamaan (similarity) antara data. Dalam model-model berbasis jarak, kesamaan antara data direpresentasikan sebagai jarak antara dua titik.

Model geometris ini didasarkan pada konsep bahwa sampel dalam dataset dapat diwakili sebagai titik dalam ruang dengan dimensi yang sama dengan jumlah fitur dalam dataset. Contohnya, jika dataset terdiri dari sampel dengan dua fitur, seperti panjang dan lebar, maka setiap sampel dapat diwakili sebagai titik dalam ruang dua dimensi. Jika dataset terdiri dari sampel dengan tiga fitur, seperti panjang, lebar, dan tinggi, maka setiap sampel dapat diwakili sebagai titik dalam ruang tiga dimensi.

Dalam model geometris, setiap kelas dalam dataset dapat diwakili sebagai himpunan titik-titik yang dikelompokkan bersama dalam ruang. Misalnya, jika dataset terdiri dari sampel dengan dua fitur dan terdiri dari dua kelas, maka masing-masing kelas dapat diwakili sebagai dua himpunan titik-titik dalam ruang dua dimensi.

Untuk melakukan klasifikasi, model geometris mencoba untuk menemukan batas keputusan yang memisahkan himpunan titik-titik yang mewakili kelas yang berbeda. Batas keputusan ini dapat berupa garis, bidang, atau hiperbidang, tergantung pada dimensi ruang yang digunakan. Model geometris bekerja dengan cara menghitung jarak antara setiap sampel dalam dataset dengan batas keputusan, dan kemudian memprediksi kelas yang sesuai berdasarkan posisi sampel terhadap batas keputusan.

jika dataset terdiri dari 5 fitur, maka setiap sampel akan diwakili sebagai titik dalam ruang 5 dimensi. Ini karena setiap fitur akan membentuk satu dimensi di dalam ruang yang diwakili oleh sampel tersebut. Dalam hal ini, setiap sampel akan diwakili oleh sebuah vektor dengan delapan komponen yang merepresentasikan nilai dari setiap fitur dalam dataset.

Sedangkan dalam model-model linear, kita menggunakan konsep garis dan bidang untuk membangun model klasifikasi. Konsep linearitas memainkan peran fundamental dalam matematika dan disiplin terkait. Matematika dari model linear sangat mudah dipahami dan mudah diterapkan dalam machine learning. Karena sederhananya penerapannya, model linear menjadi sangat menarik dalam memecahkan berbagai masalah.

Beberapa algoritma machine learning yang merupakan linear models antara lain:

1. Regresi Linier
2. Regresi Logistik
3. Support Vector Machine (SVM) dengan kernel linier
4. Analisis Diskriminan Linier (LDA)
5. Ridge Regression
6. Lasso Regression
7. Elastic Net Regression
8. Perceptron dan Multi-Layer Perceptron (MLP)
9. Generalized Linear Model (GLM)

1.2. Model Geometris (Output Machine Learning)

Sumber : Machine Learning: The Art and Science of Algorithms that Make Sense of Data", Peter Flach

--

Model geometris sebagai salah satu model yang digunakan dalam Machine Learning untuk melakukan klasifikasi. Model geometris ini didasarkan pada konsep bahwa sampel dalam dataset dapat diwakili sebagai titik dalam ruang dengan dimensi yang sama dengan jumlah fitur dalam dataset. Contohnya, jika dataset terdiri dari sampel dengan dua fitur, seperti panjang dan lebar, maka setiap sampel dapat diwakili sebagai titik dalam ruang dua dimensi. Jika dataset terdiri dari sampel dengan tiga fitur, seperti panjang, lebar, dan tinggi, maka setiap sampel dapat diwakili sebagai titik dalam ruang tiga dimensi.

Dalam model geometris, setiap kelas dalam dataset dapat diwakili sebagai himpunan titik-titik yang dikelompokkan bersama dalam ruang. Misalnya, jika dataset terdiri dari sampel dengan dua fitur dan terdiri dari dua kelas, maka masing-masing kelas dapat diwakili sebagai dua himpunan titik-titik dalam ruang dua dimensi.

Untuk melakukan klasifikasi, model geometris mencoba untuk menemukan batas keputusan yang memisahkan himpunan titik-titik yang mewakili kelas yang berbeda. Batas keputusan ini dapat berupa garis, bidang, atau hiperbidang, tergantung pada dimensi ruang yang digunakan. Model geometris bekerja dengan cara menghitung jarak antara setiap sampel dalam dataset dengan batas keputusan, dan kemudian memprediksi kelas yang sesuai berdasarkan posisi sampel terhadap batas keputusan.

Meskipun model geometris relatif sederhana dan mudah dipahami, namun model ini memiliki kelemahan dalam menangani dataset yang kompleks dan tidak linear. Oleh karena itu, model geometris seringkali digunakan sebagai model dasar dalam Machine Learning dan diikuti dengan pengembangan model yang lebih canggih seperti model berbasis kernel dan neural network.

--

Salah satu contoh model geometris yang dijelaskan dalam buku tersebut adalah model linear, di mana model ini mencoba untuk memisahkan dua kelas dengan menggunakan sebuah garis atau sebuah hyperplane. Garis atau hyperplane ini dibangun dengan cara mencari pusat massa dari masing-masing kelas, dan membangun garis atau hyperplane yang berada di tengah-tengah antara kedua pusat massa ini. Dalam kasus model linear dengan dua dimensi, garis yang dibangun merupakan garis lurus, sedangkan pada model linear dengan tiga dimensi, hyperplane yang dibangun merupakan bidang datar.

Selain model linear, terdapat pula model non-linear yang bersifat geometris, seperti decision tree, k-nearest neighbors, dan neural networks. Model non-linear ini memanfaatkan representasi geometris data yang lebih kompleks, misalnya dengan membangun struktur pohon keputusan, menentukan kelas berdasarkan jarak terdekat, atau memanfaatkan beberapa lapisan atau hidden layers pada neural network.

Model-model geometris ini memiliki keuntungan karena representasi geometris data yang mudah dipahami dan diinterpretasi. Selain itu, model-model ini juga dapat memperlihatkan secara visual bagaimana suatu model melakukan klasifikasi terhadap data. Namun, model-model geometris ini juga memiliki kelemahan, di antaranya kurang fleksibel dalam mengatasi data yang kompleks dan memiliki noise. Oleh karena itu, diperlukan model-model Machine Learning lainnya yang dapat mengatasi kelemahan-kelemahan tersebut.

Figure 1.1 menunjukkan contoh dari klasifikasi linier dasar yang menggunakan model geometris untuk memprediksi kelas suatu sampel dalam dataset. Gambar tersebut menunjukkan dua kelas yang berbeda dalam ruang dua dimensi. Garis putus-putus pada gambar merupakan garis batas keputusan atau "decision boundary" yang memisahkan kedua kelas tersebut. Garis ini dibentuk oleh model klasifikasi linier dasar yang menggunakan persamaan w·x = t, di mana w adalah vektor bobot dan t adalah ambang batas.

Jika terdapat batas keputusan linear yang memisahkan dua kelas, maka data dikatakan linearly separable. Batas keputusan linier ini didefinisikan oleh persamaan w·x = t, di mana w adalah vektor tegak lurus terhadap batas keputusan, x menunjuk pada titik acak pada batas keputusan, dan t adalah ambang keputusan.

Dalam contoh ini, garis batas keputusan dibangun dengan mengambil setengah jarak antara pusat massa kelas positif (p) dan kelas negatif (n). Kemudian, vektor w dihitung dengan mengurangi vektor n dari vektor p, sehingga w = p - n. Vektor w dapat dianggap sebagai vektor yang mengarah dari "pusat massa" contoh negatif, n, ke pusat massa positif, p. Dalam hal ini, w sebanding atau sama dengan p - n. Pusat massa ini dapat dihitung dengan cara mengambil rata-rata dari contoh positif dan negatif. Dengan menetapkan ambang keputusan yang sesuai, batas keputusan dapat dipotong secara setengah.

Selanjutnya, ambang batas t dihitung dengan menggunakan persamaan t = (||p||2 - ||n||2)/2, di mana ||x|| adalah panjang vektor x. Ambang batas ini memungkinkan untuk menentukan posisi garis batas keputusan pada sumbu y.

Dalam proses klasifikasi, model linier ini menghitung jarak antara setiap sampel dalam dataset dengan garis batas keputusan. Jika sampel berada di atas garis, maka akan diprediksi sebagai kelas positif, dan jika sampel berada di bawah garis, maka akan diprediksi sebagai kelas negatif.
--
Persamaan t = (||p||2 - ||n||2)/2 pada gambar 1.1 adalah persamaan untuk menghitung ambang batas atau "decision threshold" pada model klasifikasi linier dasar. Pada contoh gambar tersebut, ambang batas t digunakan untuk menentukan posisi garis batas keputusan pada sumbu y. Persamaan tersebut memungkinkan untuk menghitung ambang batas dengan menggunakan pusat massa kelas positif (p) dan kelas negatif (n).

---

jika notasi ||x|| menunjukkan panjang atau norma dari vektor x, maka pada persamaan tersebut, ||p||2 dan ||n||2 adalah kuadrat dari norma dari vektor pusat massa kelas positif dan kelas negatif.

Penjelasan lebih lanjut mengenai persamaan tersebut adalah sebagai berikut:

• ||p||2 dan ||n||2 adalah kuadrat dari panjang vektor p dan n, masing-masing.

• Selisih antara ||p||2 dan ||n||2 menunjukkan jarak antara pusat massa kelas positif dan kelas negatif pada sumbu y.

• Nilai selisih tersebut dibagi dua, karena setengah dari jarak tersebut merupakan jarak antara garis batas keputusan dengan pusat massa kelas positif atau kelas negatif.

• Oleh karena itu, ambang batas ditentukan dengan mengurangi ||n||2 dari ||p||2, kemudian membagi selisih tersebut dengan dua.

Dalam matematika, norma atau panjang vektor adalah besarnya suatu vektor dalam ruang vektor, yang dapat dihitung dengan rumus ||x|| = sqrt(x1^2 + x2^2 + ... + xn^2), di mana x1, x2, ..., xn adalah koordinat dari vektor tersebut. Dalam konteks persamaan t = (||p||2 - ||n||2)/2, ||p||2 dan ||n||2 mengacu pada panjang atau norma dari vektor pusat massa kelas positif dan kelas negatif.

Namun, model ini dapat berkinerja buruk jika data tidak memenuhi asumsi yang dibutuhkan. Asumsi bahwa data terpisah secara linier tidak selalu terpenuhi di dunia nyata karena adanya noise. Oleh karena itu, linear separability tidak terjadi sangat sering dalam praktik, kecuali jika data sangat sparse, seperti pada klasifikasi teks. Karena data biasanya tidak linearly separable, maka kita memerlukan metode untuk memilih batas keputusan yang terbaik. Salah satu opsi alami adalah memilih klasifikasi dengan margin yang besar, di mana margin dari klasifikasi linier adalah jarak antara batas keputusan dan contoh terdekat, misalnya menggunakan Support Vector Machines (SVM).

Confusion Matrix

Confusion Matrix atau tabel kontingensi adalah tabel dua dimensi yang digunakan untuk mengevaluasi kinerja model Machine Learning pada klasifikasi biner, yaitu klasifikasi yang hanya memiliki dua kelas, misalnya "positif" dan "negatif", atau "spam" dan "non-spam". Confusion Matrix digunakan untuk membandingkan hasil prediksi model dengan nilai yang sebenarnya pada data testing, dan terdiri dari empat jenis metrik evaluasi, yaitu True Positive (TP), False Positive (FP), True Negative (TN), dan False Negative (FN).

Berikut adalah penjelasan dari keempat metrik evaluasi tersebut:

1. True Positive (TP): Jumlah kasus positif yang diprediksi dengan benar oleh model.
2. False Positive (FP): Jumlah kasus negatif yang salah diprediksi sebagai positif oleh model.
3. True Negative (TN): Jumlah kasus negatif yang diprediksi dengan benar oleh model.
4. False Negative (FN): Jumlah kasus positif yang salah diprediksi sebagai negatif oleh model.

Dari empat metrik evaluasi tersebut, dapat diperoleh metrik evaluasi lain seperti:

1. Akurasi (Accuracy): Persentase keseluruhan prediksi yang benar dari model. Dihitung dengan (TP + TN) / (TP + TN + FP + FN).
2. Presisi (Precision): Persentase prediksi positif yang benar dari model. Dihitung dengan TP / (TP + FP).
3. Recall (Sensitivity atau True Positive Rate): Persentase kasus positif yang diidentifikasi dengan benar oleh model. Dihitung dengan TP / (TP + FN).
4. F1-Score: Rata-rata harmonis antara Presisi dan Recall. Dihitung dengan 2 * (Presisi * Recall) / (Presisi + Recall).

Confusion Matrix sangat berguna dalam mengevaluasi kinerja model Machine Learning pada klasifikasi biner karena memungkinkan kita untuk memahami dengan jelas di mana model gagal dan di mana model berhasil dalam melakukan klasifikas

Melakukan Prediksi Menggunakan Machine Learning

Pada tulisan sebelumnya telah dilakukan analisis dengan Korelasi Pearson untuk mengetahui fitur yang paling berpengaruh pada dataset :

DATASET : https://archive.ics.uci.edu/ml/datasets/Energy+efficiency

https://archive.ics.uci.edu/ml/machine-learning-databases/00242/ENB2012_data.xlsx

NAMA FILE : ENB2012_data.xlsx

768 sampel, Setiap sampel terdiri dari 8 fitur numerik yang terdiri dari faktor-faktor seperti luas permukaan, tinggi plafon, dan jenis kaca yang digunakan.

1. Kolom X1 : compactness relatif dari bangunan (Relative Compactness), yang merupakan rasio antara volume bangunan dan luas permukaan eksterior bangunan.
2. Kolom X2 : permukaan (Surface Area) dari bangunan.
3. Kolom : luas dinding (Wall Area) dari bangunan.
4. Kolom X4 : luas atap (Roof Area) dari bangunan.
5. Kolom X5: tinggi keseluruhan (Overall Height) dari bangunan.
6. Kolom X6 : orientasi (Orientation) bangunan. Kolom ini mengindikasikan arah pandang bangunan terhadap matahari, diukur dalam derajat dari utara dalam arah jarum jam.
7. Kolom X7 : luas kaca (Glazing Area) dari bangunan.
8. Kolom X8 : distribusi luas kaca (Glazing Area Distribution) pada bangunan.
9. Kolom Y1 : koefisien transmisi panas (Heat Transmission Coefficient) dari bangunan, yang mengukur seberapa baik bangunan dapat menahan panas dari luar ke dalam.
10. Kolom Y2 : kehilangan energi pendinginan (Cooling Load) dari bangunan, yang mengukur jumlah energi yang dibutuhkan untuk mendinginkan ruangan dalam bangunan.

Regresi Linier Berganda

Pada data set tersebut akan dilakukan regresi berganda untuk memprediksi nilai Y1 dan Y2, data yang akan diuji akan diambil secara acak sebanyak 20% dari data data latih yang disediakan (dataset)

import pandas as pd

import numpy as np

import matplotlib.pyplot as plt

from sklearn.linear_model import LinearRegression

from sklearn.preprocessing import PolynomialFeatures

from sklearn.metrics import r2_score, mean_squared_error

# Membaca dataset

url = "https://archive.ics.uci.edu/ml/machine-learning-databases/00242/ENB2012_data.xlsx"

df = pd.read_excel(url)

# Mengganti nama kolom pada dataset

df = df.rename(columns={'X1': 'relative compactness',

                        'X2': 'surface area',

                        'X3': 'wall area',

                        'X4': 'roof area',

                        'X5': 'overall height',

                        'X6': 'orientation',

                        'X7': 'glazing area',

                        'X8': 'glazing area distribution',

                        'Y1': 'heating load',

                        'Y2': 'cooling load'})

# Mengambil variabel yang akan digunakan dalam analisis

X = df[['roof area', 'overall height']]

y1 = df['heating load']

y2 = df['cooling load']

# Membagi dataset menjadi data latih dan data uji

from sklearn.model_selection import train_test_split

X_train, X_test, y1_train, y1_test, y2_train, y2_test = train_test_split(X, y1, y2, test_size=0.2, random_state=0)

# Melakukan regresi polinomial pada data latih

poly = PolynomialFeatures(degree=2)

X_poly_train = poly.fit_transform(X_train)

X_poly_test = poly.transform(X_test)

regressor1 = LinearRegression()

regressor1.fit(X_poly_train, y1_train)

regressor2 = LinearRegression()

regressor2.fit(X_poly_train, y2_train)

# Memprediksi nilai y berdasarkan data uji

y1_pred = regressor1.predict(X_poly_test)

y2_pred = regressor2.predict(X_poly_test)

# Menampilkan persamaan regresi

print("Persamaan Regresi Heating Load: Y = {} + {}*X1 + {}*X2 + {}*X1^2 + {}*X2^2 + {}*X1*X2".format(

    regressor1.intercept_, regressor1.coef_[0], regressor1.coef_[1], regressor1.coef_[2], regressor1.coef_[3], regressor1.coef_[4]))

print("Persamaan Regresi Cooling Load: Y = {} + {}*X1 + {}*X2 + {}*X1^2 + {}*X2^2 + {}*X1*X2".format(

    regressor2.intercept_, regressor2.coef_[0], regressor2.coef_[1], regressor2.coef_[2], regressor2.coef_[3], regressor2.coef_[4]))

# Menampilkan plot kurva regresi

fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(10,5))

ax1.scatter(X_test['roof area'], y1_test, color='red')

ax1.plot(X_test['roof area'], y1_pred, color='blue', linewidth=2)

ax1.set_xlabel('roof area')

ax1.set_ylabel('Heating Load')

ax2.scatter(X_test['roof area'], y2_test, color='blue')

ax2.plot(X_test['roof area'], y2_pred, color='red', linewidth=2)

ax2.set_xlabel('roof area')

ax2.set_ylabel('Cooling Load')

# Menampilkan plot kurva regresi

fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(10,5))

ax1.scatter(X_test['overall height'], y1_test, color='red')

ax1.plot(X_test['overall height'], y1_pred, color='blue', linewidth=2)

ax1.set_xlabel('overall height')

ax1.set_ylabel('Heating Load')

ax2.scatter(X_test['overall height'], y2_test, color='blue')

ax2.plot(X_test['overall height'], y2_pred, color='red', linewidth=2)

ax2.set_xlabel('overall height')

ax2.set_ylabel('Cooling Load')

# Menampilkan kolom aktual dan hasil prediksi Y1

result1 = pd.DataFrame({'Actual Y1': y1_test, 'Predicted Y1': y1_pred})

print(result1)

# Menampilkan kolom aktual dan hasil prediksi Y2

result2 = pd.DataFrame({'Actual Y2': y2_test, 'Predicted Y2': y2_pred})

print(result2)

# Menyimpan kolom aktual dan hasil prediksi Y1 dan Y2 ke file excel

with pd.ExcelWriter('predicted_results.xlsx') as writer:

    result1.to_excel(writer, sheet_name='Y1')

    result2.to_excel(writer, sheet_name='Y2')

# Menghitung MAE

from sklearn.metrics import mean_absolute_error

mae1 = mean_absolute_error(y1_test, y1_pred)

mae2 = mean_absolute_error(y2_test, y2_pred)

# Menampilkan nilai R-squared, MSE, dan MAE

print("Heating Load:")

print("R-squared:", r2_score(y1_test, y1_pred))

print("MSE:", mean_squared_error(y1_test, y1_pred))

print("MAE:", mae1)

print("Cooling Load:")

print("R-squared:", r2_score(y2_test, y2_pred))

print("MSE:", mean_squared_error(y2_test, y2_pred))

print("MAE:", mae2)

# Menyimpan nilai R-squared, MSE, dan MAE ke file excel

data = {'R-squared': [r2_score(y1_test, y1_pred), r2_score(y2_test, y2_pred)],

        'MSE': [mean_squared_error(y1_test, y1_pred), mean_squared_error(y2_test, y2_pred)],

        'MAE': [mae1, mae2]}

df = pd.DataFrame(data, index=['Heating Load', 'Cooling Load'])

df.to_excel(writer, sheet_name='Metrics')

HASIL

-----------------------------------------------------------------------------

import pandas as pd

import numpy as np

import matplotlib.pyplot as plt

from sklearn.linear_model import LinearRegression

from sklearn.preprocessing import PolynomialFeatures

from sklearn.metrics import r2_score, mean_squared_error

# Membaca dataset

url = "https://archive.ics.uci.edu/ml/machine-learning-databases/00242/ENB2012_data.xlsx"

df = pd.read_excel(url)

# Mengganti nama kolom pada dataset

df = df.rename(columns={'X1': 'relative compactness',

                        'X2': 'surface area',

                        'X3': 'wall area',

                        'X4': 'roof area',

                        'X5': 'overall height',

                        'X6': 'orientation',

                        'X7': 'glazing area',

                        'X8': 'glazing area distribution',

                        'Y1': 'heating load',

                        'Y2': 'cooling load'})

# Mengambil variabel yang akan digunakan dalam analisis

X = df[['roof area', 'overall height']]

y1 = df['heating load']

y2 = df['cooling load']

# Membagi dataset menjadi data latih dan data uji

from sklearn.model_selection import train_test_split

X_train, X_test, y1_train, y1_test, y2_train, y2_test = train_test_split(X, y1, y2, test_size=0.2, random_state=0)

# Melakukan regresi polinomial pada data latih

poly = PolynomialFeatures(degree=2)

X_poly_train = poly.fit_transform(X_train)

X_poly_test = poly.transform(X_test)

regressor1 = LinearRegression()

regressor1.fit(X_poly_train, y1_train)

regressor2 = LinearRegression()

regressor2.fit(X_poly_train, y2_train)

# Memprediksi nilai y berdasarkan data uji

y1_pred = regressor1.predict(X_poly_test)

y2_pred = regressor2.predict(X_poly_test)

# Menampilkan persamaan regresi

print("Persamaan Regresi Heating Load: Y = {} + {}*X1 + {}*X2 + {}*X1^2 + {}*X2^2 + {}*X1*X2".format(

    regressor1.intercept_, regressor1.coef_[0], regressor1.coef_[1], regressor1.coef_[2], regressor1.coef_[3], regressor1.coef_[4]))

print("Persamaan Regresi Cooling Load: Y = {} + {}*X1 + {}*X2 + {}*X1^2 + {}*X2^2 + {}*X1*X2".format(

    regressor2.intercept_, regressor2.coef_[0], regressor2.coef_[1], regressor2.coef_[2], regressor2.coef_[3], regressor2.coef_[4]))

# Menampilkan plot kurva regresi

fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(10,5))

ax1.scatter(X_test['roof area'], y1_test, color='red')

ax1.plot(X_test['roof area'], y1_pred, color='blue', linewidth=2)

ax1.set_xlabel('roof area')

ax1.set_ylabel('Heating Load')

ax2.scatter(X_test['roof area'], y2_test, color='blue')

ax2.plot(X_test['roof area'], y2_pred, color='red', linewidth=2)

ax2.set_xlabel('roof area')

ax2.set_ylabel('Cooling Load')

# Menampilkan plot kurva regresi

fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(10,5))

ax1.scatter(X_test['overall height'], y1_test, color='red')

ax1.plot(X_test['overall height'], y1_pred, color='blue', linewidth=2)

ax1.set_xlabel('overall height')

ax1.set_ylabel('Heating Load')

ax2.scatter(X_test['overall height'], y2_test, color='blue')

ax2.plot(X_test['overall height'], y2_pred, color='red', linewidth=2)

ax2.set_xlabel('overall height')

ax2.set_ylabel('Cooling Load')

# Menampilkan kolom aktual dan hasil prediksi Y1

result1 = pd.DataFrame({'Actual Y1': y1_test, 'Predicted Y1': y1_pred})

print(result1)

# Menampilkan kolom aktual dan hasil prediksi Y2

result2 = pd.DataFrame({'Actual Y2': y2_test, 'Predicted Y2': y2_pred})

print(result2)

# Menyimpan kolom aktual dan hasil prediksi Y1 dan Y2 ke file excel

with pd.ExcelWriter('predicted_results.xlsx') as writer:

    result1.to_excel(writer, sheet_name='Y1')

    result2.to_excel(writer, sheet_name='Y2')

# Menghitung MAE

from sklearn.metrics import mean_absolute_error

mae1 = mean_absolute_error(y1_test, y1_pred)

mae2 = mean_absolute_error(y2_test, y2_pred)

# Menampilkan nilai R-squared, MSE, dan MAE

print("Heating Load:")

print("R-squared:", r2_score(y1_test, y1_pred))

print("MSE:", mean_squared_error(y1_test, y1_pred))

print("MAE:", mae1)

print("Cooling Load:")

print("R-squared:", r2_score(y2_test, y2_pred))

print("MSE:", mean_squared_error(y2_test, y2_pred))

print("MAE:", mae2)

# Menyimpan nilai R-squared, MSE, dan MAE ke file excel

data = {'R-squared': [r2_score(y1_test, y1_pred), r2_score(y2_test, y2_pred)],

        'MSE': [mean_squared_error(y1_test, y1_pred), mean_squared_error(y2_test, y2_pred)],

        'MAE': [mae1, mae2]}

df = pd.DataFrame(data, index=['Heating Load', 'Cooling Load'])

df.to_excel(writer, sheet_name='Metrics')