Klasifikasi termasuk kedalam supervised learning, dimana pembuatan model klasifikasi biasanya memerlukan data historis atau data yang telah diketahui labelnya untuk digunakan dalam melatih model guna memprediksi label / kategori dari data baru yang belum diketahui. Dalam membangun model klasifikasi yang baik, sangat penting untuk memiliki data yang berkualitas karena kinerja dari model yang dihasilkan bergantung pada data latih yang diberikan.
Klasifikasi dapat dibedakan menjadi 2 (dua), yaitu klasifikasi biner (binary classification) yang hanya mempunyai dua label tujuan, seperti ya/tidak, positif/negatif, 0/1 dan klasifikasi multikelas (multiclass classification) atau klasifikasi dengan banyak kategori yang mengkategorikan tiga atau lebih label.
Klasifikasi adalah yang paling sering digunakan dalam suatu sistem yang memanfaatkan kecerdasan buatan, baik untuk menyelesaikan hal-hal yang sederhana maupun berbagai tugas klasifikasi yang kompleks. Beberapa contoh implementasi klasifikasi seperti deteksi fraud pada transaksi keuangan, deteksi spam, sentimen analisis dan klasifikasi gambar, kategori produk, jenis malware dan lain sebagainya.
Kemudian, bagaimana cara membuat model machine learning untuk melakukan klasifikasi ? Dalam artikel ini Penulis akan berbagi pengetahuan tentang bagaimana cara membuat model machine learning untuk melakukan klasifikasi. Disini Penulis menggunakan Anaconda-Navigator untuk membuat model hingga melakukan deployment, jadi pastikan kalian sudah menginstall Anaconda-Navigator jika ingin mengikuti sampai ke tahap deployment. Namun jika kalian hanya ingin membuat model saja, google colab sudah lebih dari cukup karena tidak perlu melakukan instalasi apapun. Selain anaconda-navigator kalian juga bisa menggunakan miniconda dan visual studio code / pycharm atau bahkan cukup dengan IDE dari python, terserah mana yang lebih familiar.
Persiapan
Pertama-tama buat environment baru pada Anaconda-Navigator dan install beberapa library berikut dengan menggunakan terminal ataupun melalui fitur search packages.
pip install pandas
pip install -U scikit-learn
#dataset
pip install palmerpenguinsSetelah packages diatas terinstall, buka jupyter notebook lalu load libraries dan dataset yang akan digunakan dengan perintah berikut:
import pandas as pd
import numpy as np
from palmerpenguins import load_penguins
from sklearn.preprocessing import MinMaxScaler
from sklearn.impute import KNNImputer
data = load_penguins()
data.head(5)kode data = load_penguins() berfungsi untuk memanggil dataset palmerpenguins dan kode data.head(5) berfungsi untuk menampilkan 5 data teratas dari dataset tadi. Dapat dilihat pada baris ke 4 (indeks ke-3) terdapat missing value pada beberapa kolom. Untuk melihat jumlah missing value pada dataset secara keseluruhan dapat menggunakan perintah data.isnull().sum() atau data[data.isnull().any(axis=1)] untuk menampilkan semua data yang memiliki missing value.
Kemudian bagaimana cara mengatasi missing value tersebut? pada tutorial ini kita akan menggunakan nearest neighbor imputation untuk melakukan imputasi pada missing value.
# mapping data
data['sex'] = data['sex'].map({'female': 0, 'male': 1})
data['species'] = data['species'].map({'Adelie': 0,'Chinstrap':1,'Gentoo':2})
data['island'] = data['island'].map({'Biscoe':0,'Dream':1,'Torgersen':2})
# normalisasi
mms = MinMaxScaler()
data = pd.DataFrame(mms.fit_transform(data),columns=data.columns)
# imputasi dengan KNN
imp = KNNImputer()
data = pd.DataFrame(imp.fit_transform(data), columns=data.columns)
# kembalikan lagi
data_final = pd.DataFrame(mms.inverse_transform(data),columns=data.columns)
# pembulatan pada kolom sex, karena seharusnya hanya 0 atau 1
data_final['sex'] = data_final['sex'].round()
# cek kembali apakah sudah benar
data_final.head(5)pada kode diatas, langkah yang pertama dilakukan adalah mengubah kolom yang berisi teks menjadi angka karena algorithma machine learning pada dasarnya hanya bisa memproses angka. Kemudian kita lakukan normalisasi pada dataset kita kedalam range 0-1 dengan menggunakan MinMaxScaler. Setelah itu, missing value pada daset kita lakukan imputasi dengan menggunakan nearest neighbor imputation (KNN Imputer). Setelah itu kita kembalikan lagi dataset yang telah dinormalisasi ke bentuk sebelumnya dan kita lakukan pembulatan pada kolom sex, karena seharusnya value di kolom tersebut hanya 0 atau 1. Output dari kode diatas seharusnya menampilkan 5 data teratas dengan data pada baris ke 4 (indeks ke-3) sudah terisi, dan apabila kita cek dengan perintah data_final.isnull().sum() seharusnya sudah menunjukkan angka 0 semua. Dengan ini maka data telah siap untuk selanjutnya masuk kedalam tahap modelling.
Membuat Model Klasifikasi
Dalam membuat model machine learning, kita perlu memisah dataset awal menjadi data latih dan data uji, dimana besarannya biasanya 70-80% untuk data latih dan sisanya sebagai data uji. Pemisahan ini sangat penting karena data uji tadi akan digunakan untuk mengukur kinerja dari model yang telah kita buat.
from sklearn.model_selection import train_test_split
X=data_final.drop(['species', 'island', 'year'],axis=1)
y=data_final['species']
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=25, shuffle=True)pada kode diatas penulis memisahkan dataset menjadi 80% data untuk data latih dan 20% data untuk data uji dengan menggunakan library bawaan dari sklearn. Penulis juga melakukan feature selection pada variabel bebas (X) dengan menghapus kolom island dan year. Karena hanya spesies Adeile saja yang bisa ditemukan di ketiga pulau lainnya, sedangkan spesies lain hanya menghuni satu pulau saja. Untuk detail lebih lanjut dapat membaca artikel berikut ini:
Sedangkan kolom year dihapus karena tidak relevan. Selanjutnya kita bisa langsung menggunakan data yang telah dipisah tadi ke dalam beberapa algorithma machine learning untuk kemudian dibandingkan model mana yang memiliki kinerja yang paling baik.
Logistic Regression
from sklearn.linear_model import LogisticRegression
lr = LogisticRegression(random_state=25)
lr.fit(X_train,y_train)
y_pred_lr = lr.predict(X_test)Decission Tree
from sklearn.tree import DecisionTreeClassifier
dt = DecisionTreeClassifier(random_state=25)
dt.fit(X_train, y_train)
y_pred_dt = dt.predict(X_test)Random Forest
from sklearn.ensemble import RandomForestClassifier
rf = RandomForestClassifier(random_state=25)
rf.fit(X_train,y_train)
y_pred_rf = rf.predict(X_test)Support Vector Machine
from sklearn.svm import SVC
svc = SVC(random_state=25)
svc.fit(X_train,y_train)
y_pred_svc = svc.predict(X_test)Kita menggunakan 4 algorithma machine learning yang berbeda, secara garis besar, semua algorithma memiliki cara penggunaan yang sama, yaitu pertama kita load algoritmanya terlebih dahulu, lalu kita buat model dengan perintah fit pada data train kemudian model tersebut kita suruh untuk melakukan prediksi pada data data uji (X_test). output dari prediksi tersebut kita simpan kedalam variabel y_pred_[nama] untuk kemudian kita bandingkan dengan kunci jawaban guna mendapatkan evaluation metrics yang kita inginkan.
Evaluasi
Untuk mengukur model mana yang memiliki kinerja paling baik, kita dapat melihat dari evaluation metrics barupa akurasi dan F1 Score. Setelah sebelumnya kita membuat model dan melakukan prediksi pada data uji, sekarang kita perlu membandingkan hasil dari prediksi tersebut.
from sklearn.metrics import accuracy_score, f1_score, classification_report
# LR
LR_f1 = f1_score(y_test, y_pred_lr, average='weighted')
LR_AC = accuracy_score(y_test, y_pred_lr)
# SVM
SVC_f1 = f1_score(y_test, y_pred_svc, average='weighted')
SVC_AC = accuracy_score(y_test, y_pred_svc)
# DT
DT_f1 = f1_score(y_test, y_pred_dt, average='weighted')
DT_AC = accuracy_score(y_test, y_pred_dt)
# RF
RF_f1 = f1_score(y_test, y_pred_rf, average='weighted')
RF_AC = accuracy_score(y_test, y_pred_rf)
models = pd.DataFrame({
'Model': ['Logistic Regression', 'Support Vector Classifier', 'Decision Tree', 'Random Forest'],
'Accuracy': [LR_AC, SVC_AC, DT_AC, RF_AC],
'F1 Score': [LR_f1, SVC_f1, DT_f1, RF_f1]
})
models.sort_values(by='F1 Score', ascending=False)Pada kode diatas, kita mengukur nilai f1_score pada masing-masing model dengan average weighted dan menyimpan kedalam variabel [model]_f1, begitu juga dengan akurasi. Kemudian kita membuat dataframe baru dengan nilai dari hasil pengukuran tadi dan mengurutkannya berdasarkan nilai F1 Score. output dari kode diatas adalah sebagai berikut:
Model Accuracy F1 Score
Logistic Regression 0.985507 0.985671
Random Forest 0.971014 0.971623
Decision Tree 0.956522 0.957797
Support Vector Classifier 0.768116 0.691386Dapat kita lihat pada hasil diatas bahwa model Logistic Regression menghasilkan nilai akurasi dan F1 Score terbaik dibandingkan dengan model lainnya, untuk melihat detail dari hasil klasifikasi dengan menggunakan Logistic Regression dapat menggunakan perintah classification_report seperti dibawah ini
print(classification_report(y_test, y_pred_lr))
######### OUTPUT ###########
precision recall f1-score support
0.0 1.00 0.97 0.99 35
1.0 0.93 1.00 0.96 13
2.0 1.00 1.00 1.00 21
accuracy 0.99 69
macro avg 0.98 0.99 0.98 69
weighted avg 0.99 0.99 0.99 69
sedangkan untuk melihat feature importance dari model Logistic Regression bisa menggunakan kode dibawah ini
coefficients = lr.coef_[0]
round_coefficients = np.round_(coefficients, decimals = 4)
feature_names = X.columns.to_list()
feature_importance = dict(zip(feature_names, round_coefficients))
# Print feature importance
for feature, importance in feature_importance.items():
print(f"{feature} = {importance}")
######### OUTPUT ###########
bill_length_mm = -0.9193
bill_depth_mm = 1.1827
flipper_length_mm = 0.0737
body_mass_g = 0.0017
sex = 0.102