project:eve
23.01.28 SVM ์ํฌํธ ๋ฒกํฐ ๋จธ์ ๋ณธ๋ฌธ
Studying here๐ ์คํ๋ฒ ์ค ์์ธ๋์ ๊ตฌ์ญ์
ADP๋ฅผ ์ค๋นํ๋ฉด์ ๋ฐ์ดํฐ ๋ถ์์ ๋ณธ๊ฒฉ์ ์ผ๋ก ๊ณต๋ถํ์ง ํ๋ฌ์ด ๋ค ๋์ด ๊ฐ๋ ๊ฒ ๊ฐ๋ค.
์ฒ์์๋ ์๋ก์ด ๊ฐ๋ ์ฒ์ง์ฌ์ ๊ณ ์์ค๋ฌ์ ๋๋ฐ ์์ฆ์ ๊ฐ๋ ๋ค์ ์ง๊ทธ์ ๋ณด๊ณ ์์ผ๋ฉด ๊ธ๋ฐฉ๊ธ๋ฐฉ ์ํ ์ด๋ฐ๊ฑฐ๊ตฐ ํ๊ณ ๋์ด๊ฐ๊ฒ ๋์ ๊ณต๋ถํ๋ ๊ฒ ์กฐ๊ธ ์ฌ๋ฏธ์๋ค. ์ฌ์ ํ ๋ณธ ์ ๋ ์๋ ๊ธฐํธ๋ค์ด ์ถค์ถ๋ ํต๊ณ์์ ์ด๋ ต์ง๋ง.. ๊ทธ๋๋ ์ด์ฌํ ๊ณต๋ถํด์ 3์์ ๋ฐ๋ก ํฉ๊ฒฉํ๋ ๊ธฐ๋๋ฅผ ์กฐ๊ธ ๊ฑธ์ด๋ณธ๋ค ใ ใ
์ด๋ฒ ๊ธ์์๋ ์ํฌํธ ๋ฒกํฐ ๋จธ์ ์ ๊ณต๋ถํ๋ ค๊ณ ํ๋ค.
1) ์ ์
SVM(์ํฌํธ ๋ฒกํฐ ๋จธ์ )์ด๋?? ์๋ก์ด ๋ฐ์ดํฐ๊ฐ ์ ๋ ฅ๋์์ ๋ ๊ธฐ์กด ๋ฐ์ดํฐ๋ฅผ ํ์ฉํด ๋ถ๋ฅํ๋ ๋ฐฉ๋ฒ์ด๋ค. ๋ค๋ฅธ ๋ถ์ ๋ฐฉ๋ฒ์๋ ์๋ ์ ๋๊ฐ ์๋๋ฐ, ์ฒ์ ์์์ ์ต๋ ๋ง์ง ๋ถ๋ฅ๊ธฐ -> ์ฑ๋ฅ์ ๊ฐํํ SVC(Classifier) -> ๋น์ ํ ํด๋์ค๋ ์ฒ๋ฆฌํ ์ ์๋ SVM์ผ๋ก ๋ฐ์ ํ๋ค.
๊ธฐ๋ณธ์ ์ธ ์๋ฆฌ๋ ๋๊ฐ๋ค. ๋ ๋ฐ์ดํฐ๋ฅผ ๋ถ๋ฅํ ์ ์๋ ๊ฐ์ฅ ์ ์ ํ ์ดํ๋ฉด์ ๊ตฌํ๋ ๊ฒ์ด๋ค.
๋จผ์ ์ดํ๋ฉด์ด ๋ฌด์์ผ๊น..? ๋ก์ง์คํฑ ํ๊ท ๋๋ ํ๋ฒ ๋์๋ ๊ฐ๋ ์ด๋ค. ๊ทธ๋๋ ์ดํ๋ฉด x=0์ด๋ผ๊ณ ํ์น๊ณ ์ง๋๊ฐ๋๋ฐ ์ฌ๊ธฐ์๋ ๋๋ฌด๋ ์ค์ํด์ ๊ทธ๋ฅ ๋์ด๊ฐ ์๊ฐ ์๋ค. ์ฑ ์์๋ ์ด๋ ๊ฒ ์ค๋ช ํ๋ค.

์์์ ์ธ์๋ณด์. 2์ฐจ์ ๊ณต๊ฐ์์๋ b0+b1x1+b2x2=0์ ๋ง์กฑํ๋ x1๊ณผ x2๊ฐ ์ด๋ฃจ๋ ์ ์ด ์ดํ๋ฉด์ด ๋๋ค.
plt.axvline(x=0)
plt.xlim([-5, 5])

๊ทธ ๋ค์, 3์ฐจ์ ๊ณต๊ฐ์์๋ b0+b1x1+b2x2+b3x3=0์ ๋ง์กฑํ๋ x1๊ณผ x2๊ณผ x3๊ฐ ์ด๋ฃจ๋ ๋ฉด..?์ด ์ดํ๋ฉด์ด ๋๋ค.
โ ๏ธSVM๊ณผ ์ดํ๋ฉด์ ๊ฒ์ํ๋ฉด ๋๋ถ๋ถ ์ดํ๋ฉด์ ๋ ๊ณต๊ฐ์ ๋๋๋ ๊ฑฐ๋ผ๊ณ ๋ง ์ค๋ช ํ๊ณ ์์ธํ๊ฒ๋ ์จ์๋ ๊ณณ์ด ์์ด์, ์ดํ๋ฉด์ ๋ํด์๋ง ๊ฒ์ํด ๋ดค๋๋ ๊ด์ฐฎ์ ์๋ฃ๊ฐ ๋ง์๋ค. ๊ฐ๋จํ๊ฒ ์ ๋ฆฌํ๋ฉด,
2์ฐจ์ ๊ณต๊ฐ์ ๋๋๋ ์ดํ๋ฉด์ ์ ์ผ๋ก ax+by+c=0์ ๋ง์กฑํด์ผ ํ๋ค.
3์ฐจ์ ๊ณต๊ฐ์ ๋๋๋ ์ดํ๋ฉด์ ๋ฉด์ผ๋ก ax+by+cz+d=0์ ๋ง์กฑํด์ผ ํ๋ค.
์ด๋ฌ๋ฉด ์ดํด๊ฐ ํจ์ฌ ์ฌ์ ๋ค. ์ผ๋จ ๋ญ์ง๋ ๋ชจ๋ฅผ x1 x2๊ฐ ์๋๋ผ ๊ตฌ์ฒด์ ์ผ๋ก ์ถ ๋ณ์๋ผ๋ ๊ฑธ ์๊ฒ ๋๋ ์ ์๋ฟ๋๋ค.
๊ทธ๋ฌ๋ฉด ๋ค์ ๋จ๊ณ๋ก '๊ฐ์ฅ ์ ์ ํ ์ดํ๋ฉด'์ด ๋ฌด์์ผ๊น? ์ด ๋ต๋ณ์ ๊ทธ๋ฆผ ํ ์ฅ์ผ๋ก ์ดํดํ ์ ์๋ค.

2) ์ข ๋ฅ
1- ์ํฌํธ ๋ฒกํฐ ๋ถ๋ฅ๊ธฐ
๋ชจ๋ ๋ฐ์ดํฐ๊ฐ ์ดํ๋ฉด์ ์ํด ์๋ฒฝํ๊ฒ ๋ถ๋ฅ๋ ์๋ ์๊ธฐ ๋๋ฌธ์ ํญ์ ์ ์ฉํ ์๋ ์๋ค. ๋ ์๋ฒฝํ๊ฒ ๋ถ๋ฅํ๋๋ผ๋ ๊ณผ์ ํฉ, ์ด์์น์ ๋ฏผ๊ฐ ๋ฑ ๋จ์ ์ด ์๋ค. ๊ทธ๋์ SVC๋ ๋ฐ์ดํฐ๋ฅผ ๋ถ๋ฅํ๋ ์ผ๋ถ ๋ฐ์ดํฐ๋ค์ด ๋ฐ๋์ชฝ์ ์๋ ๊ฒ์ ํ์ฉํ๋ค. ์ด ํ์ฉ์น๋ ํ์ดํผํ๋ผ๋ฏธํฐ๋ก ๊ด๋ฆฌํ๋ฉฐ ๊ฐ์ด 0์ด๋ฉด ํ์ฉํ์ง ์๋๋ค.
2- ์ํฌํธ ๋ฒกํฐ ๋จธ์
๋น์ ํ ๋ฐ์ดํฐ์ผ ๊ฒฝ์ฐ์ ์ฌ์ฉ. ์ปค๋์ด๋ผ๋ ๊ธฐ์ ์ ํ์ฉํด ๋ฐ์ดํฐ๋ฅผ ๊ณ ์ฐจ์์ผ๋ก ๋ณํํด ๋ถ๋ฆฌํ๋ ๋ฐฉ๋ฒ์ด๋ผ๊ณ ํ๋ค.

2-1- ์ฝ๋๋ก ์ง๋ณด๊ธฐ
iris ๋ฐ์ดํฐ๋ก ์ค์ตํด๋ณด์
from sklearn.datasets import load_iris
iris = load_iris()
df_iris = pd.DataFrame(iris.data, columns=iris.feature_names)
df_iris['result'] = iris.target
sns.pairplot(data=df_iris, hue='result')

๋ฐ์ดํฐ๋ฅผ ํ๋ จ/๊ฒ์ฆ ์ธํธ๋ก ๋ถํ ํด์ค๋ค. ๊ทธ๋ฆฌ๊ณ ์ํฌํธ๋ฒกํฐ๋จธ์ ์ ๋ฏธ์ธํ ์ด์์น์๋ ์ํฅ์ ๋ฐ๊ธฐ ๋๋ฌธ์ ๋ฐ์ดํฐ๋ฅผ ์ ๊ทํํ๋ฉด ์กฐ๊ธ ๋ ๋ช ํํ ๊ฒฐ์ ๊ฒฝ๊ณ๋ฅผ ๊ตฌํ ์ ์๋ค.
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
x=df_iris.drop(columns=['result', 'sepal width (cm)', 'petal width (cm)'])
y=df_iris['result']
train_x, test_x, train_y, test_y = train_test_split(x, y, train_size=0.7, stratify=y)
stScaler = StandardScaler()
stScaler.fit(train_x, train_y)
train_x_scaled = stScaler.transform(train_x)
sns.pairplot(data=pd.concat([pd.DataFrame(train_x), train_y], axis=1), hue='result')

svc ๋ถ๋ฅ๋ชจ๋ธ์ importํ๊ณ ํ๋ จ ๋ฐ์ดํฐ๋ก ์์ธก, ๊ฒ์ฆ ๋ฐ์ดํฐ๋ก ์์ธก๊ฐ์ ๊ตฌํ๋ค. ๋ชจ๋ธ์ ์์ฑ C๋ ์์ธ๋ฅผ ํ์ฉํ๋ ์ ๋์ด๊ณ ๋์์ง์๋ก ๋ง์ ์์ธ๋ฅผ ํ์ฉํ๊ฒ ๋๋ค(์ ์ ๋์ด ๋ฐ๋์ชฝ์ผ๋ก ๊ฐ ์๋ ๊ฒฐ๊ณผ๊ฐ๋ค์ ํ์ฉ)
from sklearn.svm import SVC
clf = SVC(C=0.5)
clf.fit(train_x_scaled, train_y)
test_x_scaled=stScaler.transform(test_x)
pred = clf.predict(test_x_scaled)
์์ธก๊ฐ๊ณผ ์ค์ ๊ฐ์ ๋น๊ตํด ์ฑ๋ฅ์ ํ๊ฐํด ๋ณด์.
from sklearn.metrics import confusion_matrix, accuracy_score, precision_matrix, recall_matrix, f1_score
print(confusion_matrix(test_y, pred))
print(accuracy_score(test_y, pred))
print(precision_score(test_y, pred, average='macro'))
print(f1_score(test_y, pred, average='macro'))

์ข ์๋ณ์๊ฐ 3๊ฐ ์ด์์ธ ๊ฒฝ์ฐ์๋ ์ ํ๋๋ฅผ ์ ์ธํ ์ฑ๋ฅ ํ๊ฐ ํจ์๋ฅผ ์ฌ์ฉํ ๋ average๋ผ๋ ์์ฑ์ ๋ณ๋์ ๊ฐ์ ์ง์ ํด ์ฃผ์ด์ผ ํ๋ค. ์๋ํ๋ฉด ์์ฑ์ ๊ธฐ๋ณธ๊ฐ์ด binary(์ด์ง ๋ถ๋ฅ)๋ก ๋์ด์๊ธฐ ๋๋ฌธ์ 3๊ฐ ์ด์์ ์ข ์ ๋ณ์๋ฅผ ๊ณ์ฐํ ์ ์๊ธฐ ๋๋ฌธ์ด๋ค. ๊ทธ๋ผ ๋ค๋ฅธ ์์ฑ์ ๋ฌด์์ด ์์๊น?
macro : ์ข ์๋ณ์๋ณ๋ก ๋งคํธ๋ฆญ์ค๋ฅผ ๊ณ์ฐํด ์ฑ๋ฅํ๊ฐ์ ์๋ฅผ ๊ตฌํ ๋ค ๊ทธ ๊ฐ๋ค์ ํ๊ท ์ ๊ณ์ฐํ๋ค
micro : ๊ฐ ๋ ์ด๋ธ์ ๋งคํธ๋ฆญ์ค๋ฅผ ๊ณ์ฐํ๊ณ ๊ฐ์ค์ด ๋์ง ์๋ ํ๊ท ์ ์ฐพ๋๋ค(*๊ฐ์ค์ด ๋์ง ์๋ ํ๊ท ์ ์ฐพ๋๋ค๋ ๊ฒ ๋ญ์ผ?)
โก๏ธ macro๊ฐ ๊ฐ๊ฐ์ ๋งคํธ๋ฆญ์ค๋ก ๊ณ์ฐํ๋ค๋ฉด micro๋ ์ข ์๋ณ์ ์ ์ฒด์ ์ค์ฐจํ๋ ฌ์์ ํ๊ท ์ ๊ณ์ฐํ๋ค.
weightend : ์ข ์๋ณ์์ ํด๋์ค๋ณ ๋ถํฌ๋ฅผ ๊ณ ๋ คํด ํ๊ท ์ ๊ตฌํ๋ค.
(*==ํด๋์ค๋ณ ๋ถํฌ๊ฐ ๋ง์ด ์ฐจ์ด๋๋ ๊ฒฝ์ฐ์๋ micro๋ weightend๋ฅผ ํ์ฉํ๋ฉด ์ข๊ฒ ๋ค.)
3- ์ํฌํธ ๋ฒกํฐ ํ๊ท
์์ ๋๊ฐ๋ ๋ถ๋ฅ๊ธฐ, ๊ฐ์ ์๋ฆฌ์ด์ง๋ง ํ๊ท๋ ๊ฐ๋ฅํ๋ค. ๊ฐ์ด๋ฐ ์ ์ ์ค์ฌ์ผ๋ก ์์ชฝ์ ํฌ๋ฏธํ ์ ์ด ๋ง์ง ๊ฑฐ๋ฆฌ์ด๊ณ ์ด ์์ ์ต๋ํ ๋ง์ ์ ์ด ๋ค์ด๊ฐ๋๋ก ์ค์ฌ์ ์์ ๊ตฌํ๋ ๊ฒ์ด ๋ชฉ์ ์ด๋ค.

SVR์ ํ์ดํผ ํ๋ผ๋ฏธํฐ๋ ์ด๋ฐ๊ฐ ๋ ์ฐ๊ฒ ์ง๋ง ๊ทธ๋ํ๋ก ๋จผ์ ์์๋ณด์. ๊ทธ๋ฆผ์ฒ๋ผ ํ๊ท์ ๊ณผ ํ์ฉ ๋ฒ์๋ฅผ ๋์ด์ ์ ์ ๋ง์ง ์ค๋ฅ๋ผ๊ณ ์ธ์ํ๊ณ ํ์ฉ ์ต๋ ๋ฒ์์์ ๊ฐ์ฅ ๋จผ ์ํฌํธ ๋ฒกํฐ์์ ๊ฑฐ๋ฆฌ๊ฐ ์์ฑ์ผ๋ก ์ฐ์ธ๋ค.

3-2-์ฝ๋๋ก ์ง๋ณด๊ธฐ
๋ณ๋๋ก ์ฃผ์ด์ง ๋ฐ์ดํฐ ์์ด ๊ฐ๋จํ๊ฒ ๋ฐ์ดํฐ๋ฅผ ๋ง๋ค์ด์ ํด๋ณด์. ๋ ๋ฆฝ๋ณ์๋ 0~1 ์ฌ์ด์ ๋ถ๊ท์นํ ๊ฐ์ 5๋ฅผ ๊ณฑํด ๋ง๋ ๋ค.
์ค๋ฅ ๊ฐ์ ๋ง๋ค๊ธฐ ์ํด ์ข ์๋ณ์ ๋ฐ์ดํฐ์ ์ผ์ ์์๋ง๋ค ์ด์ ๋ฐ์ดํฐ๋ฅผ ๋ฃ์ด์ค๋ค.
import numpy as np
X = np.sort(5 * np.random.rand(40, 1), axis=0)
y = np.sin(X)
y[::5] += 3*(0.5-np.random.rand(8))
print(X[0:10])

์ํฌํธ ๋ฒกํฐ ํ๊ท๋ชจ๋ธ์ ์ฌ์ฉํ ๋ ์ฃผ๋ก ์กฐ์ ํ๋ ์์ฑ์ kernel, C, gamma, epsilon์ผ๋ก ์ด๊ฒ๋ง ์์๋ณด์.
C๋ ๋ถ๋ฅ๋ชจ๋ธ๊ณผ ๋ง์ฐฌ๊ฐ์ง๋ก ์์ธ ํ์ฉ์ ์ ๋์ด๊ณ ํด์๋ก ํ์ฉ ์ ๋๊ฐ ๋ฎ์์ง๋ค.
gamma : ๊ฐ์ฐ์์ ์ปค๋ ํจ์์ ๊ณ์(???)๋ก ์๋ฏธ ์์ฒด๋ ํ๋์ ๋ฐ์ดํฐ ์ํ์ด ํ์ฌํ๋ ์ํฅ๋ ฅ์ ๊ฑฐ๋ฆฌ์ด๊ณ ๊ฐ์ด ํด์๋ก ๊ฑฐ๋ฆฌ๊ฐ ์งง์์ง๋ค.
epsilon : ํ๊ท์์ ์ค์ฌ์ผ๋ก ๋ฐ์ดํฐ ํฌ์ธํธ๋ฅผ ํ์ฉํ๋ ๊ฑฐ๋ฆฌ
kernel : ์ฌ์ฉํ ์ปค๋ ํจ์๋ฅผ ๊ณ ๋ฅธ๋ค. rbf(radial basis function), linear(์ ํํ๊ท), poly(๋คํญํ๊ท) ๋ฑ๋ฑ
(*svr์ ์ฌ์ฉํ ๋ rbfํจ์๋ฅผ ์ ์ผ ๋ง์ด ์ด๋ค๊ณ ํ๋ค.)
๋ค์ํ ์ปค๋ ํจ์๊ฐ ์์ผ๋ ๋งํ ๊ฒ๋ค๋ก ๋ชจ๋ ๋ถ์ํด๋ณด์
from sklearn.svm import SVR
svr_rbf = SVR(kernel='rbf', C=100, gamma=0.1, epsilon=0.1)
svr_lin = SVR(kernel='linear', C=100, gamma='auto', epsilon=0.1)
svr_poly = SVR(kernel='poly', C=100, gamma='auto', epsilon=0.1)
svr_rbf.fit(X, y)
svr_lin.fit(X, y)
svr_poly.fit(X, y)
rbf_pred = svr_rbf.predict(X)
lin_pred = svr_lin.predict(X)
poly_pred = svr_poly.predict(X)
๋ถ๋ฅ๋ชจ๋ธ์ฒ๋ผ ๋๊ฐ์ด ์ฑ๋ฅ ํ๊ฐ๋ ํด๋ณด์
from sklearn.metrics import mean_absolute_error, mean_squared_error
preds = [rbf_pred, lin_pred, poly_pred]
kernel = ['rbf', 'Linear', 'Polynomial']
evls = ['mae', 'mse', 'rmse']
df_result = pd.DataFrame({'kernel':kernel})
for nm, pred in zip(kernel, preds):
mae = mean_absolute_error(y, pred)
mse = mean_squared_error(y, pred)
rmse = np.sqrt(mse)
df_result.loc[df_result['kernel']==nm, 'mae'] = round(mae, 2)
df_result.loc[df_result['kernel']==nm, 'mse'] = round(mse, 2)
df_result.loc[df_result['kernel']==nm, 'rmse'] = round(rmse, 2)
print(df_result)

๋!
ํ๊ท๋ชจ๋ธ์ ๋์ถฉ ๋ํ์ด๋ก ๋ฐ์ดํฐ ๋ง๋ค์ด์ ํ ๊ฒ์ด ์์ฝ๋ค. ์กฐ๋ง๊ฐ ๋ณต์ตํ ๋ ์ผ๊ธ์์ ์ธ๋งํ ๋ฐ์ดํฐ๋ฅผ ๊ธ์ด์์ ๋ค์ ๋ถ์ํด๋ด์ผ๊ฒ ๋ค
'Daily' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
| 23.02.04 ์์ฌ๊ฒฐ์ ๋๋ฌด (0) | 2023.02.04 |
|---|---|
| 23.01.31 KNN ์ต๊ทผ์ ์ด์ (0) | 2023.01.31 |
| 23.01.28 Logistic Regression๋ก์ง์คํฑ ํ๊ท (0) | 2023.01.29 |
| 23.01.27 Lasso, Elasticnet ๋ผ์, ์๋ผ์คํฑ๋ท (0) | 2023.01.28 |
| 23.01.25 Linear Regression, Ridge ๊ฒฝ์ฌํ๊ฐ๋ฒ, ๋ฆฟ์ง ํ๊ท (0) | 2023.01.25 |