Machine Learning – 28 – SVM

April 30, 2019 0 Comments

machine-learning, கணியம்

Support Vector Machine (SVM) என்பது தரவுகளை வகைப்படுத்திப் பிரிப்பதற்கான ஒரு வழிமுறை ஆகும். ஏற்கெனவே இதற்கென logistic regression என்பதைப் பற்றிப் பார்த்தோம். ஆனால் இந்த SVM என்பது வகைப்படுத்துதல் எனும் வேலையை logistic-ஐ விட இன்னும் சற்று துல்லியமாக அமைக்கிறது. நேர்கோடு மூலம் பிரிக்கப்படும் தரவுகளுக்கு large margin classifier எவ்வாறு உதவுகிறது என்பதையும், நேர்கோடு முறையில் பிரிக்கப்பட முடியாத தரவுகளுக்கு kernels எவ்வாறு உதவுகிறது என்பதையும் இப்பகுதியில் காணலாம்.

Large margin classifier (linear):

கீழ்க்கண்ட உதாரணத்தில் ஒரு நேர்கோடு மூலம் வகைப்படுத்த முடியும் தரவுகளை logistic எவ்வாறு பிரிக்கிறது, svm எவ்வாறு பிரிக்கிறது என்பதைக் காட்டியுள்ளோம். இதில் x1, x2 எனும் இரண்டு அம்சங்கள் உள்ளன. அவை 2 பரிமாணங்கள் (2 dimension matrix) கொண்ட ஒரே அணியாக numpy மூலம் மாற்றப்படுகின்றன. பின்னர் அத்தரவுகளைக் கொண்டு logistic-க்கும், svm-க்கும் பயிற்சி அளிக்கிறோம். பின்னர் ஒவ்வொன்றும் தரவுகளைப் பிரிப்பதற்கான நேர்கோட்டினை சரியாக எங்கு அமைக்கின்றன என்பதைக் காண்பதற்கான நிரல் classifier()-க்குள் எழுதப்பட்டுள்ளது.


import numpy as np
import matplotlib.pyplot as plt
from sklearn import svm
from sklearn.linear_model.logistic import LogisticRegression
def classifier():
xx = np.linspace(1,10)
yy = -regressor.coef_[0][0] / regressor.coef_[0][1] * xx – regressor.intercept_[0] / regressor.coef_[0][1]
plt.plot(xx, yy)
plt.scatter(x1,x2)
plt.show()
x1 = [2,6,3,9,4,10]
x2 = [3,9,3,10,2,13]
X = np.array([[2,3],[6,9],[3,3],[9,10],[4,2],[10,13]])
y = [0,1,0,1,0,1]
regressor = LogisticRegression()
regressor.fit(X,y)
classifier()
regressor = svm.SVC(kernel='linear',C = 1.0)
regressor.fit(X,y)
classifier()

view raw

linear_svc.py

hosted with ❤ by GitHub

logistic மூலம் தரவுகள் பிரிக்கப்படும்போது அதற்கான நேர்கோடு பின்வருமாறு அமைகிறது. அதாவது கீழே உள்ள வகைக்கு மிகவும் நெருக்கமாக எவ்வித இடைவெளியும் இல்லாமல் நேர்கோடு அமைக்கப்பட்டுள்ளது. ஆனால் மேலே உள்ள வகைக்கும் கோட்டிற்குமான இடைவெளியோ மிகவும் அதிகமாக உள்ளது.

SVM மூலம் தரவுகள் பிரிக்கப்படும்போது இரண்டு வகைக்கும் நடுவில் உள்ள கோடு அவ்விரண்டு வகையிலிருந்தும் சமமான அளவு தூரத்தில் உள்ளது. எனவே தான் இது equal margin / large margin classifier என்று அழைக்கப்படுகிறது. இது logistic regression-க்கான ஒரு optimization-ஆகவே கருதப்படுகிறது.

Kernels (non-linear):

Kernel என்பது நேர்கோடு போட்டு பிரிக்க முடியாத சற்று கடினமான non-linear முறையில் அமைந்துள்ள தரவுகளை வகைப்படுத்துவதற்குப் பயன்படுகிறது. இது போன்ற நேர்கோட்டில் பொருந்தாத தரவுகளைப் பொறுத்துவதற்கு ஏற்கெனவே polynomial regression என்ற ஒன்றைப் பார்த்தோம். ஆனால் அதில் ஒவ்வொரு features-வுடைய higher order மதிப்புகள் கணக்கிடப்பட்டு அவை புதிதாக இணைந்துள்ள அம்சங்களாகக் கணக்கில் கொள்ளப்படும். எனவே தரவுகள் முழுதாகப் பொருந்தும் வரையிலும் square, cube என்று அடுத்தடுத்த order-ல் features-ஐக் கணக்கிட்டு இணைத்துக் கொண்டே செல்வோம். இவ்வாறு செய்யும்போது பயிற்சி அளிக்கப்படும் தரவில் அதிக அளவு அம்சங்கள் சேர்க்கப்படுவதால், ஒரு algorithm கற்றுக் கொள்வதற்கான நேரமும் கணினி அனைத்தையும் அதிக அளவில் நினைவில் வைத்துக் கொள்ள வேண்டிய தேவையும் அதிகரிக்கிறது. இதைத் தவிர்ப்பதற்காக வந்ததே kernels / similarity functions ஆகும்.

இது புதிது புதிதாக அம்சங்களை இணைக்காமல், ஏற்கெனவே உள்ள அம்சங்களில் இருந்து புதிய அம்சங்களைக் கணக்கிட்டுப் பயன்படுத்துகிறது. உதாரணத்துக்கு நமது பயிற்சித் தரவில் 5 அம்சங்களும் 100 மாதிரித் தரவுகளும் உள்ளன என்று வைத்துக்கொள்வோம். Polynomial எனும் போது இத்தகைய 5 features-க்கும் square மற்றும் cube மதிப்புகள் கண்டுபிடிக்கப்பட்டு, கடைசியில் அவை 20 -க்கும் மேலான features-ஆக வந்து நிற்கும். அதுவே kernel மூலம் பொறுத்தும் போது ஒவ்வொரு அம்சங்களிலும் உள்ள 100 மாதிரிகளில் இருந்து ஒரு தரவினை தேர்வு செய்து அதனை landmark-ஆக அமைக்கிறது. பின்னர் அதிலிருந்து மற்ற தரவுகள் எவ்வளவு தூரத்தில் அமைந்துள்ளன என்பது கணக்கிடப்படுகிறது. அவை landmark-க்கு அருகில் இருந்தால் 1 எனவும், இல்லையெனில் 0 எனவும் வகைப்படுத்தப்படுகின்றன. இதை வைத்தே புதிய feature கணக்கிடப்படுகிறது. அதாவது பயிற்சித் தரவில் உள்ள 5 அம்சங்களுக்கு வெறும் 5 புதிய features மட்டுமே இம்முறையில் கணக்கிடப்படுகின்றன.
இந்த similarity function-க்கான சமன்பாடு பின்வருமாறு. இதுவே kernel என்றும் அழைக்கப்படுகிறது. இந்த kernel இக்கணக்கீடுகளை நிகழ்த்துவதற்கு பல்வேறு வாய்ப்பாடுகளைப் பெற்றிருக்கும். அதில் ஒன்றான exp()-க்கான சமன்பாடு கீழே கொடுக்கப்பட்டுள்ளது. இதுவே gaussian kernel என்று அழைக்கப்படுகிறது. இதே போன்று polynomial kernel, string kernel, chi-squared kernel, histogram-intersection kernel என்று பல்வேறு வகையான வாய்ப்பாடுகள் kernel-ல் உள்ளன.

f1 = similarity (x ,l1)
= exp (-(||x-l||**2 / 2*sigma squared ))

SVM without kernels என்பது logistic regression-ஐக் குறிக்கிறது. அதாவது kernels மூலம் உருவாக்கப்பட்ட புதிய features-ஐப் பயன்படுத்தாமல், நேரடியாக raw feature-ஐக் கொண்டு மட்டுமே வகைப்படுத்துதல் நிகழ்ந்தால், அது logistic regression-ஐயே குறிக்கிறது. எனவே எப்போது kernel-ஐப் பயன்படுத்தலாம் எப்போது logistic-ஐப் பயன்படுத்தலாம் என்று பார்ப்போம். தேர்ந்தெடுக்கப்பட்ட அம்சங்களின் எண்ணிக்கை(100000 or 100), பயிற்சிக்கு அளிக்கப்பட்ட மாதிரித் தரவுகளின் எண்ணிக்கையை(10000) விட மிகவும் அதிகமாக இருந்தாலோ அல்லது மிகவும் குறைவாக இருந்தாலோ svm without kernel-ஐப் பயன்படுத்தலாம். அதுவே features-ன் எண்ணிக்கை(1000) மிகவும் அதிகமாக இல்லாமல் ஓரளவுக்கு சற்று அதிகமாக இருக்கும்போது svm with kernel-ஐப் பயன்படுத்தலாம்.

கீழ்க்கண்ட எடுத்துக்காட்டில் பல்வேறு அம்சங்களை வைத்து ஒரு மலர் மல்லியா, ரோஜாவா, தாமரையா என்று வகைப்படுத்தப்படுகிறது. இவை svm without kernel அதாவது logistic மூலம் வகைப்படுத்தப்படுவதைவிட kernel மூலம் வகைப்படுத்தப்படும்போது அதன் accuracy அதிகரிப்பதைக் காணலாம்.


import numpy as np
import matplotlib.pyplot as plt
from sklearn import svm
import pandas as pd
from sklearn.metrics import accuracy_score
from sklearn.model_selection import train_test_split
from sklearn.svm import SVC
from sklearn.metrics import classification_report, confusion_matrix
from sklearn.linear_model.logistic import LogisticRegression
from matplotlib.colors import ListedColormap
df = pd.read_csv('./flowers.csv')
X = df[list(df.columns)[:-1]]
y = df['Flower']
X_train, X_test, y_train, y_test = train_test_split(X, y, random_state = 0)
logistic = LogisticRegression()
logistic.fit(X_train, y_train)
y_pred = logistic.predict(X_test)
print ('Accuracy-logistic:', accuracy_score(y_test, y_pred))
gaussian = SVC(kernel='rbf')
gaussian.fit(X_train, y_train)
y_pred = gaussian.predict(X_test)
print ('Accuracy-svm:', accuracy_score(y_test, y_pred))

view raw

nonlinear_kernels.py

hosted with ❤ by GitHub

வெளியீடு:

Accuracy-logistic: 0.868421052631579
Accuracy-svm: 0.9736842105263158

%d bloggers like this: