๋ณธ ๋ด์ฉ์ ํธ์ฆ์จ ๋จธ์ ๋ฌ๋2 ๋ฅผ ๊ธฐ๋ฐ์ผ๋ก ์์ฑํ์์ผ๋ฉฐ, ์๋ต๋ ๋ด์ฉ์ด๋ ์ถ๊ฐ๋ ๋ด์ฉ์ด ์์ต๋๋ค.
[5.1] ์ํฌํธ ๋ฒกํฐ ๋จธ์ (SVM)
- ์ ํ์ด๋ ๋น์ ํ ๋ถ๋ฅ, ํ๊ท, ์ด์์น ํ์์๋ ์ฌ์ฉ๊ฐ๋ฅํ ๋ค๋ชฉ์ ๋จธ์ ๋ฌ๋ ๋ชจ๋ธ
- SVM์ ๊ธฐ๋ณธ ์์ด๋์ด๋ ๋ผ์ง ๋ง์ง ๋ถ๋ฅ๋ก ๋ํ๋ธ๋ค.
- ๊ฐ ํด๋์ค ์ฌ์ด์ ๊ฐ์ฅ ํญ์ด ๋์ ๋๋ก๋ฅผ ์ฐพ๋ ๊ฒ
- ๋๋ก ๊ฒฝ๊ณ์ ์์นํ ์ํ์ ์ํฌํธ ๋ฒกํฐ๋ผ๊ณ ํ๋ค.
- SVM์ ํน์ฑ์ ์ค์ผ์ผ์ ๋ฏผ๊ฐํ๋ค. ๋ฐ๋ผ์ ์ฌ์ดํท๋ฐ์ StandardScaler๋ฅผ ์ฌ์ฉํด๋ณด์
- ํ๋ ๋ง์ง ๋ถ๋ฅ
- ๋ชจ๋ ์ํ์ด ๋๋ก ๋ฐ๊นฅ์ชฝ์ ์ฌ๋ฐ๋ฅด๊ฒ ๋ถ๋ฅ
- ๋ฐ์ดํฐ๊ฐ ์ ํ์ ์ผ๋ก ๊ตฌ๋ถ๋ ์ ์์ด์ผ ์๋ํจ
- ์ด์์น์ ๋ฏผ๊ฐํ๋ค.

- ์ํํธ ๋ง์ง ๋ถ๋ฅ
- ํ๋ ๋ง์ง์์ ์ข ๋ ์ ์ฐํ ํํ์ ๋ชจ๋ธ
- ์ํ์ด ๋๋ก ์ค๊ฐ์ ์๊ฑฐ๋, ๋ฐ๋์ชฝ์ ์๋ ๊ฒฝ์ฐ์ธ ๋ง์ง ์ค๋ฅ ์ฌ์ด์ ์ ์ ํ ๊ท ํ์ ์ก์์ผํ๋ค.
- ์ฌ์ดํท๋ฐ์ SVM ๋ชจ๋ธ์์๋ ํ์ดํผ ํ๋ผ๋ฏธํฐ๋ฅผ ์ง์ ํ ์ ์๋๋ฐ, ๊ทธ ์ค C์ ๊ฐ์ ์กฐ์ ํ๋ฉด ์๋ ๊ทธ๋ฆผ๊ณผ ๊ฐ์ ๊ฒฐ๊ณผ๋ฅผ ์ป๋๋ค.

- ์ผ์ชฝ ๋ชจ๋ธ์ ๊ฒฝ์ฐ ๋ง์ง ์ค๋ฅ๊ฐ ๋ง์ง๋ง ์ผ๋ฐํ๊ฐ ์ ๋จ
- ์ค๋ฅธ์ชฝ ๋ชจ๋ธ์ ๊ฒฝ์ฐ ๋ง์ง ์ค๋ฅ๊ฐ ์ ์ง๋ง ์ผ๋ฐํ๊ฐ ์ผ์ชฝ์ ๋นํด ๋ถ์กฑํจ
- ๊ณผ๋์ ํฉ์ด๋ผ๋ฉด C๋ฅผ ๊ฐ์์์ผ์ ๋ชจ๋ธ์ ๊ท์ ํ ์ ์๋ค.
import numpy as np
from sklearn import datasets
from sklearn.pipeline import Pipeline
from sklearn.preprocesing import StardardScaler
from sklearn.svm import LinearSVC
iris = datasets.load_iris() #iris ๋ฐ์ดํฐ ๋ก๋
X = iris["data"][: ,(2, 3)] #๊ฝ์ ๊ธธ์ด์ ๊ฝ์ ๋๋น
y = (iris["target"] == 2) #Iris-Virginica
svm_clf = Pipeline([
("scaler", StandardScaler()),
("linear_svc", LinearSVC(C=1, loss="hinge")), #ํ์ง์์ค ํจ์ ์ฌ์ฉ
])
svm_clf.fit(X, y)
svm_clf.predict([[5.5, 1.7]]) #๊ธธ์ด๊ฐ 5.5์ด๊ณ ๋๋น๊ฐ 1.7์ธ ๊ฒ์ ๋ํ ์์ธก
- LinearSVC ํด๋์ค ๋์
SVC(kernel="linear", C=1) #์ผ๋ก ๋์ฒด ๊ฐ๋ฅ
SGDClassifier(loss="hinge", alpha = 1(m*C)) # m์ ์ํ ์
# ํ๋ฅ ์ ๊ฒฝ์ฌํ๊ฐ๋ฒ์ ์ ์ฉํ์ฌ ๋์ฒด ๊ฐ๋ฅ
[5.2] ๋น์ ํ SVM ๋ถ๋ฅ
- ๋น์ ํ ๋ฐ์ดํฐ์
์ ๋ค๋ฃจ๋ ํ ๊ฐ์ง ๋ฐฉ๋ฒ์ ๋คํญ ํน์ฑ๊ณผ ๊ฐ์ ํน์ฑ์ ์ถ๊ฐํ๋ ๊ฒ

- PolynimialFeatures์ StadardScaler, LinearSVC๋ฅผ ์ฐ๊ฒฐํ์ฌ ์ฌ์ฉํด๋ณด์
from sklearn.datasets import make_moons
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import PolynomialFeatures
#make_moos๋ ๋ ๊ฐ์ ๋ฐ๋ฌ ๋ชจ์ ๋ฐ์ดํฐ์
์ด๋ค.
X, y = make_moons(n_samples = 100, noise = 0.15)
polynomial_svm_clf = Pipeline([
("poly_features", PolynomialFeatures(degree=3)),
("scaler", StandardScaler()),
("svm_clf", LinearSVC(C=10, loss="hinge"))
])
polynomial_svm_clf.fit(X,y)
๋คํญ์ ์ปค๋
- SVM์ ์ฌ์ฉํ ๋ ์ปค๋ ํธ๋ฆญ(Kernel trick)์ ์ฌ์ฉํ์ฌ ์ค์ ๋ก๋ ํน์ฑ์ ์ถ๊ฐํ์ง ์์ผ๋ฉด์ ๋คํญ์ ํน์ฑ์ ์ถ๊ฐํ ๊ฒ๊ณผ ๊ฐ์ ๊ฒฐ๊ณผ๋ฅผ ์ป์ ์ ์๋ค.
from sklearn.svm import SVC
poly_kernel_svm_clf = Pipeline([
("scaler", StandardScaler()),
("svm_clf", SVC(kernel="poly", degree=3, coef0=1, C=5))
#๋ชจ๋ธ์ด ๊ณผ๋์ ํฉ -> ์ฐจ์๋ฅผ ์ค์ฌ์ผํจ
#๋ชจ๋ธ์ด ๊ณผ์์ ํฉ -> ์ฐจ์๋ฅผ ๋๋ ค์ผํจ
#coef0๋ ๋ชจ๋ธ์ด ๋์ ์ฐจ์์ ๋ฎ์ ์ฐจ์์ ์ผ๋ง๋ ์ํฅ์ ๋ฐ์์ง ์กฐ์
])
poly_kernel_svm_clf.fit(X, y)

์ ์ฌ๋ ํน์ฑ
- ๋น์ ํ ํน์ฑ์ ๋ค๋ฃจ๋ ๋ค๋ฅธ ๊ธฐ๋ฒ์ ๊ฐ ์ํ์ด ํน์ง ๋๋๋งํฌ์ ์ผ๋ง๋ ๋ฎ์๋์ง ์ธก์ ํ๋ ์ ์ฌ๋ ํจ์๋ก ๊ณ์ฐํ ํน์ฑ์ ์ถ๊ฐํ๋ ๊ฒ์ด๋ค
๊ฐ์ฐ์์ RBF ์ปค๋
- ์ ์ฌ๋ ํน์ฑ์ ๋ง์ด ์ถ๊ฐํ๋ ๊ฒ๊ณผ ๋น์ทํ ๊ฒฐ๊ณผ๋ฅผ ์ป์ ์ ์๋ค.
- ์๋ ์ฝ๋๋ ๊ฐ์ฐ์์ RBF ์ปค๋์ ์ฌ์ฉํ SVC๋ชจ๋ธ
rbf_kernel_svm_clf = Pipeline([
("scaler", StandardScaler()),
("svm_clf", SVC(kernel="rbf", gamma = 5, C = 0.001))
])
rbf_kernel_svm_clf.fit(X, y)

๊ณ์ฐ ๋ณต์ก๋
๋ชจ๋ธ |
๊ณ์ฐ๋ณต์ก๋ |
LinearSVC |
$O(m × n)$ |
SGDClassifier |
$O(m × n)$ |
SVC |
$O(m^2 × n)$ ~ $O(m^3 × n)$ |
[5.3] SVM ํ๊ท
- ์์ ๋งํ๊ฒ์ฒ๋ผ SVM์ ์ ํ, ๋น์ ํ ๋ถ๋ฅ๋ฟ๋ง ์๋๋ผ ์ ํ, ๋น์ ํ ํ๊ท์๋ ์ฌ์ฉ์ด ๊ฐ๋ฅ
- SVM ํ๊ท๋ ์ ํ๋ ๋ง์ง ์ค๋ฅ ์์์ ๋๋ก ์์ ๊ฐ๋ฅํ ๋ง์ ์ํ์ด ๋ค์ด๊ฐ๋๋ก ํ์ตํ๋ค.
- ๋๋ก์ ํญ์ ํ์ดํผ ํ๋ผ๋ฏธํฐ๋ก ์กฐ์ ํ๋ค.

- ์ผ์ชฝ์ ๋ง์ง์ ํฌ๊ฒ, ์ค๋ฅธ์ชฝ์ ๋ง์ง์ ์๊ฒํ์ฌ ๋ง๋ฆ
- ์ด ๋ชจ๋ธ์ $\varepsilon$์ ๋ฏผ๊ฐํ์ง ์๋ค
- ๋ง์ง ์์์๋ ํ๋ จ ์ํ์ด ์ถ๊ฐ๋์ด๋ ๋ชจ๋ธ์ ์์ธก์๋ ์ํฅ์ด ์๊ธฐ ๋๋ฌธ
from sklearn.svm import LinearSVR
svm_reg = LinearSVR(epslion = 1.5)
svm_reg.fit(X, y)

- ๊ท์ (C)๋ฅผ ๋ค๋ฅด๊ฒ ํ์ฌ ์ ์ฉํ ๋ชจ์ต
from sklearn.svm import SVR
svm_poly_reg = SVR(kernel = "poly", degree = 2, C = 100, epsilon = 0.1)
svm_poly_reg.fit(X, y)
- SVR์ SVM์ ํ๊ท ๋ฒ์ , LinearSVR์ LinearSVM์ ํ๊ท ๋ฒ์
- LinearSVR์ ํ์ํ ์๊ฐ์ด ํ๋ จ ์ธํธ์ ํฌ๊ธฐ์ ๋น๋กํด์ ์ ํ์ ์ผ๋ก ๋์ด๋จ. ํ์ง๋ง SVR์ ํ๋ จ ์ธํธ๊ฐ ์ปค์ง๋ฉด ํจ์ฌ ๋๋ ค์ง๋ค.
- LinearSVC : SVC์์ ์ ํ ์ปค๋ ํจ์๋ก ๊ฐ์ ํด ์ปค๋์ ์งํํ๋ ๊ฒ
- ์ ํ ์ปค๋๋ก ๋ถ๋ฅํ ๋ ๋ ๋น ๋ฅด๊ฒ ์คํํ๋ค๋ ์ฅ์ ์ด ์๋ค.
- ๊ท์ ์ ํธํฅ์ ํฌํจํ๊ธฐ ๋๋ฌธ์, StandardScaler๋ฅผ ์ํํด์ผ ํ๋ค.
- ํ๋ จ๋ณด๋ค ์ํ์ด ์ ๋ค๋ฉด, ์ฑ๋ฅ์ ๋์ด๊ธฐ ์ํด dual ๋งค๊ฐ๋ณ์๋ฅผ False๋ก ์ง์ ํด์ผ ํ๋ค.
- LinearSVC๋ kernel์ด๋ผ๋ ํ๋ผ๋ฏธํฐ๋ฅผ ๋ฐ์ง ์๋๋ค. ๊ทธ ์ด์ ๋ ์ด๋ฏธ ์ ํ ์ปค๋(Linear Kernel)๋ก ๊ฐ์ ํ๊ธฐ ๋๋ฌธ
- SVC์์ ์ ํ ์ปค๋ ํจ์๋ก ๊ฐ์ ํด ์ปค๋์ ์งํํ๋ ๊ฒ
[5.4] SVM ์ด๋ก
- ์ ํ SVM ๋ถ๋ฅ๊ธฐ ๋ชจ๋ธ์ ์์ธก
- $W^TX^+b < 0$ ์ผ๋ 0์ผ๋ก ์์ธก
- $W^TX^+b >= 0$ ์ผ๋ 1์ผ๋ก ์์ธก
- ์ ํ SVM ๋ถ๋ฅ๊ธฐ๋ฅผ ํ๋ จํ๋ค๋ ๊ฒ์ ๋ง์ง ์ค๋ฅ๋ฅผ ํ๋๋ ๋ฐ์์ํค์ง ์๊ฑฐ๋(ํ๋ ๋ง์ง), ์ ํ์ ์ธ ๋ง์ง ์ค๋ฅ๋ฅผ ๊ฐ์ง๋ฉด์(์ํํธ ๋ง์ง) ๊ฐ๋ฅํ ๋ง์ง์ ํฌ๊ฒํ๋ $W$์ $b$๋ฅผ ์ฐพ๋ ๊ฒ์ด๋ค.
- ๊ฐ์ค์น ๋ฒกํฐ๊ฐ ์์์๋ก ๋ง์ง์ ์ปค์ง๋ค. ๋ง์ง์ ํฌ๊ฒํ๊ธฐ ์ํด $W$๋ฅผ ์ต์ํํ๋ ค๊ณ ํ๋ค.
- ์ํํธ ๋ง์ง ๋ถ๋ฅ๊ธฐ์ ๋ชฉ์ ํจ์๋ฅผ ๊ตฌ์ฑํ๊ธฐ ์ํด ๊ฐ ์ํ์ ๋ํด ์ฌ๋ํจ์๋ฅผ ๋์
- ์ฌ๋ํจ์๋ $i$๋ฒ์งธ ์ํ์ด ์ผ๋ง๋ ๋ง์ง์ ์๋ฐํ ์ง ์ ํ๋ค.
- ํ๋ ๋ง์ง๊ณผ ์ํํธ ๋ง์ง ๋ฌธ์ ์๋ ๋ชจ๋ ์ ํ์ ์ธ ์ ์ฝ ์กฐ๊ฑด์ด ์๋ ๋ณผ๋ก ํจ์์ ์ด์ฐจ ์ต์ ํ ๋ฌธ์ ์ด๋ค.
- ์ด๋ฐ ๋ฌธ์ ๋ฅผ ์ฝฐ๋๋ผํฑ ํ๋ก๊ทธ๋๋ฐ(QP) ๋ฌธ์ ๋ผ๊ณ ํ๋ค.

- ํ์ง ์์ค ํจ์
- SVM ์๊ณ ๋ฆฌ์ฆ์ ์ํ ์์ค ํจ์
- $t<1$์ด๋ฉด ๊ธฐ์ธ๊ธฐ๋ -1, $t>1$์ด๋ฉด ๊ธฐ์ธ๊ธฐ๋ 0
- SGDClassifier์์ loss ๋งค๊ฐ๋ณ์์ hinge๋ก ์ง์ ํ๋ฉด ์ ํ SVM ๋ฌธ์ ๊ฐ ๋๋ค.
- SGDClassifier์์ $t=1$์ผ๋ -1์ ์ฌ์ฉํจ.
- SVM
- SVC : Classification ์ ์ฌ์ฉ๋๋ SVM ๋ชจ๋ธ์ ์๋ฏธ
- SVR : Regression ์ ์ฌ์ฉ๋๋ SVM ๋ชจ๋ธ์ ์๋ฏธ
- SVC vs SVR
- SVM์ ํ๊ท์ ์ ์ฉํ๋ ๋ฐฉ๋ฒ์ SVC์ ๋ชฉํ๋ฅผ ๋ฐ๋๋ก ๊ฐ์ง๋ ๊ฒ์ด๋ค. ์ฆ, ๋ง์ง ๋ด๋ถ์ ๋ฐ์ดํฐ๊ฐ ์ต๋ํ ๋ง์ด ๋ค์ด๊ฐ๋๋ก ํ์ต
- SVC
- boundary์ ๊ฒฐ์ ์ ์์ ๊ทธ๋ฆผ๊ณผ ๊ฐ์ด, ๊ฐ ๋ถํฌ๋ก๋ถํฐ margin์ ์ต๋ํํ๋ ๊ฒ์ ๋ชฉํ๋ก ๊ฒฐ์ ํ๊ฒ ๋๋ค. ์ฆ boundary์ ์ ์ margin์ ๋ง๋ถ์ฌ์ ์ต๋ํ ์ ์ ๋ฟ์ง ์๋๋ก margin์ ํค์ฐ๋ ๊ฒ์ด๋ค
- SVC์ ๊ฒฝ์ฐ Margin์์ ํฌํจ๋ ์ ๋ค์ error๋ฅผ ๊ธฐ์ค์ผ๋ก model cost๋ฅผ ๊ณ์ฐํ๋ค. ๊ฑฐ๊ธฐ์ ๋ฐ๋๋ฐฉํฅ์ผ๋ก ๋ถ๋ฅ๋, ์ฆ ๋ฐ์ด๋๋ฆฌ๋ฅผ ๋์ด์ ์กด์ฌํ๋ ์ ๋ค์ error๋ง์ ์ถ๊ฐํ๋ค. ๊ทธ๋ฆผ์ ๋ณด๋ฉด ์๋ ๋
ธ๋ ๋ถ๋ถ์ ํฌํจ๋ ์ ๋ค๊ณผ boundary์ ์ค์ฌ์ ์์นํ ์ง์ ๊ณผ์ error๋ฅผ ๊ณ์ฐํ๋ ๊ฒ์ด๋ค.
- SVR
- ์ด์ ๋ฌ๋ฆฌ SVR์ ์ผ์ Margin์ ๋ฒ์๋ฅผ ๋์ด์ ์ ๋ค์ ๋ํ error๋ฅผ ๊ธฐ์ค์ผ๋ก model cost๋ฅผ ๊ณ์ฐํ๋ค. ์๋ ๊ทธ๋ฆผ์ผ๋ก ๋ณธ๋ค๋ฉด margin ๋ฐ๊นฅ์ ์์นํ ์ ๋ค๊ณผ ์ฐจ์ด๋ฅผ ๊ณ์ฐํ๋ ๋นจ๊ฐ์ ์ด ๊ณง ํ ์ ์ ์์ด์ error๋ก ๊ณ์ฐ๋๋ ๊ฒ์ด๋ค.
- ๊ฒฐ๋ก ์ ์ผ๋ก SVM์ ๊ฐ cost๋ฅผ ์ต์ํํ๋ boundary๋ฅผ ์ฐพ์๋ด๋ ์์
์ด๋ค.