1. Home
  2. Docs
  3. Kelas Privat Python – 01
  4. Materi [Penerapan Python]
  5. Machine Learning – Supervised Learning

Machine Learning – Supervised Learning

SVM

Support vector machines (SVM) adalah salah satu Metode Supervised Learning  yang digunakan untuk melakukan klasifikasi. Memiliki prinsip dasar untuk melakukan klasifikasi dengan menggunakan batas pemisah. SVM menggunakan prinsip mencari margin maksimum pada batas (hyperplane) untuk menemukan batas pemisah terbaik antara tiap kelas. Bagaimana bentuk batas pemisah ini bergantung pada kernel yang akan kita gunakan. Untuk sistem dengan data tak terpisahkan, SVM akan menggunakan kernel untuk mentransformasi data masukan kedalam dimensional yang lebih tinggi (Jika awalnya hanya menggunakan 2 dimensi maka akan dinaikkan ke 3 dimensi (kedalaman)).

sumber : https://www.svm-tutorial.com/2015/06/svm-understanding-math-part-3/

Terdapat beberapa kernel yang dapat digunakan:

  • Linear kernel
  • Polinomial Kernel
  • Radial Basis Function Kernel

Penerapan SVM

Pada kesempatan kali ini kita akan menggunakan library scikit-learn untuk mencoba menggunakan SVM pada sebuah dataset. Data set yang kita gunakan adalah data set pokemon yang telah kita ambil pada kegiatan web scraping dahulu dan telah kita beri label dengan menggunakan metode clustering. Label tersebut yang akan menjadi dasar penentuan kita.

Pertama kita akan mengimport semua library yang dibutuhkan, dan kita akan melakukan pengambilan data dari data kita dahulu.

import pandas as pd
import csv
from sklearn import svm

dataset = pd.read_csv ('namafile.csv')

Seperti yang kita tahu sebelumnya, pada basis data pokemon ini terdapat beberapa fitur (attack, defense, speed, dll) yang akan kita jadikan dataset kita. Jika saya melakukan print dataframe.head() maka akan terlihat seperti pada gambar dibawah.

Sekarang mari kita ambil dataset yang akan gunakan beserta dengan labelnya.

set_data = dataset.iloc [:, 4:10]
kluster_data = dataset.iloc [:,12] 

print(set_data)
print (kluster_data)

Untuk memulai model belajar kita maka kita akan membagi set_data diatas menjadi 75% train data dan 25% test data.

x_train, x_test, y_train, y_test = train_test_split(set_data, kluster_data, test_size=0.25,random_state=150) # 75% training and 25% test

Sekarang mari kita buat model untuk melakukan klasifikasi, pada kesempatan kali ini kernel yang saya coba gunakan adalah kernel linear.

from sklearn import svm

model_s = svm.SVC(kernel='linear') # Linear Kernel
model_s.fit(x_train, y_train)
y_pred = model_s.predict(x_test)

model_s.fit digunakan untuk melatih model kita dan model_s.predict digunakan untuk melakukan tes pada test data kita. Untuk melihat akurasi dari model yang telah kita buat menggunakan metode SVM (kernel=linear) tersebut kita bisa menggunakan classification_report().

from sklearn.metrics import classification_report
print(classification_report(y_test, y_pred))

Mendapatkan hasil akurasi 95% merupakan hasil yang bisa dibilang baik. sekarang kita bisa melakukan prediksi terhadap data baru yang akan kita masukkan.

hp = 30
a = 30
d =  45
sa = 50
sd = 40
s = 40

prediksi = model_s.predict([[hp,a,d,sa,sd,s]])
print(prediksi)

#[2]

Kalian dapat melakukan percobaan dengan mengganti kernel yang dipakai atau melakukan normalisasi atau standarisasi data jika dibutuhkan.

K-NN

Seperti yang kita tahu di Indonesia terdapat pengelompokkan penduduk pada tingkat RT dan RW. Pembagian penduduk pada tingkat ini tidak memerlukan pemikirin rumit eknomi, kewilayahan, dsb. Penentuan RT dan RW dilihat dari kedekatan satu rumah dengan rumah yang lain. Inilah penggambaran sederhana dari K-NN. Menilik istilahnya K-NN (K-Nearest Neighbors ) adalah model atau algoritma yang menentukan klasifikasi suatu data dari beberapa tetangga (K) terdekatnya.

Bagaimana penentuan jarak ini ditentukan? untuk bidang datar penentuan jarak ini dapat dengan mudah menggunakan persamaan pythagoras. Untuk n-dimensi kita dapat menggunakan persamaan Euclidian atau untuk kasus lebih general kita dapat menggunakan persamaan Minkowski.

sumber: www.teacherschoice.com.au

Penerapan K-NN

Pada Penerapan kali ini kita tetap akan menggunakan basis data pokemon yang kita miliki dengan. Perbedaannya adalah kita akan menggunakan dua data yang telah ditransformasi ke dalam bentuk logaritma.

import pandas as pd
import csv
from sklearn.neighbors import KNeighborsClassifier

dataset = pd.read_csv ('namafile.csv')
set_data = dataset.iloc[:, 10:12]
kluster_data = dataset.iloc[:,12]

Lalu seperti pada kesempatan sebelumnya kita akan membagi set_data diatas menjadi 75% train data dan 25% test data.

from sklearn.model_selection import train_test_split

x_train, x_test, y_train, y_test = train_test_split(set_data, kluster_data, test_size=0.25,random_state=150)

Mari kita mulai latih model kita menggunakan data tersebut lalu kita lakukan tes. Untuk kesempatan kali ini kita akan menggunakan nilai K = 1

model_k = KNeighborsClassifier(n_neighbors=1)
model_k.fit(x_train, y_train)
y_pred = model_k.predict(x_test)

mari kita lihat akurasi dari model yang kita gunakan.

from sklearn.metrics import classification_report

print(classification_report(y_test, y_pred))

Menentukan K

Seperti yang tertulis pada namanya, penentuan parameter k pada penggunaan model ini menjadi sangat penting. Berhasil menentukan nilai k yang optimum akan meningkatkan validitas prediksi kedepannya. Mari kita coba menentukan nilai K terbaik untuk data kita dengan menggunakan fungsi perulangan dan visualisasi menggunakan matplotlib.

import numpy as np
from matplotlib import pyplot as plt

error = []
for i in range(1, 50):
    model_k = KNeighborsClassifier(n_neighbors=i)
    model_k.fit(x_train, y_train)
    y_pred = model_k.predict(x_test)
    error.append(np.mean(y_pred != y_test))

plt.figure(1)  
plt.plot(range(1, 50), error, color='red', marker='o', markersize=5)
plt.title('Error pada nilai K')  
plt.xlabel('K')  
plt.ylabel('Error rata-rata')
plt.show()

Dari plot tersebut secara rata-rata penggunaan model K-NN pada data kita memiliki nilai error yang sangat rendah dengan error terkecil berada pada saat K = 4 dan K = 5. sehingga saat akan melakukan prediksi maka kita dapat menggunakan nilai K = 4 atau K = 5.

lna = 3.4011973816621555
lnd =  3.8066624897703196

prediksi = model_k.predict([[lna,lnd]])
#[2]

Kita mendapatkan hasil yang sama saat menggunakan metode SVM. Apa yang dapat kalian ambil kesimpulan dari sini? Apakah metode klusterisasi menggunakan K-Means menghasilkan hasil yang cukup baik? Apakah ini karena data pokemon yang diciptakan memang memiliki keseimbangan yang baik?