
Multiclass SVM loss

hinge loss์ ์์

hinge loss์ ๊ทธ๋ํ
SVM์ hinge ์์ค ํจ์๋ฅผ ์ฌ์ฉํ๋ค.
์์ค ํจ์์ ๊ธฐ๋ณธํ์ด๋ผ๊ณ ํ ์ ์๋ค. ์ด๋ฏธ์ง ๋ถ๋ฅ์ ์ฑ๋ฅ์ด ์ข๋ค.
s: ๋ถ๋ฅ ๋ชจ๋ธ์ด ๋ถ๋ฅํ ์นดํ ๊ณ ๋ฆฌ์ ์์ธก score
sj: ์ค๋ต category์ score (multiclass ๋ถ๋ฅ์ธ ๊ฒฝ์ฐ๋ ์ค๋ต ์ค ์ ์ผ ํฐ ๊ฐ)
syi: ์ ๋ต category์ score
+1: safty margin
์ผ์ ์ฌ์ ๊ณต๊ฐ์ ์ค์ ํด์, ๋ชจ๋ธ์ด ๊ฒฐ์ ๊ฒฝ๊ณ์์ ์ผ์ ๊ฑฐ๋ฆฌ ์ด์ ๋จ์ด์ง ์ํ๋ค์ ๋ถ๋ฅํ๊ธฐ ์ํจ์ด๋ค.
๋ชจ๋ธ์ด ์ข ๋ ์ผ๋ฐํ๋ ๊ฒฐ์ ๊ฒฝ๊ณ๋ฅผ ํ์ตํ๊ณ , ์ก์ ์ด์์น์ ๋ฏผ๊ฐํ์ง ์๋๋ก ํ๋ค.
๊ณ์ฐ ๋ฐฉ๋ฒ ์์
๊ณ ์์ด ์ฌ์ง: ์ ๋ต์ด cat์ธ๋ฐ ์ค๋ต์ธ car ์ ์๊ฐ 5.1๋ก ๋ ๋์
sj: 5.1
syi: - 3.2 (์ ๋ถ๋ฅ ๊ฐ)
5.1 - 3.2 + 1 = 2.9
์ฐจ ์ฌ์ง: ์ ๋ต ๋ ์ด๋ธ์ธ car ์ ์๊ฐ ์ ์ผ ๋์ ๋ฐ๋ผ์ loss = 0
s_1: ๊ณ ์์ด ์ ์, s_2: ๊ฐ ์ ์
Y_i: ์ด๋ฏธ์ง์ ์ค์ ์ ๋ต ์นดํ ๊ณ ๋ฆฌ (์ ์ ๊ฐ)
s_y_i: train set์ i๋ฒ์งธ ์ด๋ฏธ์ง์ ์ ๋ต ํด๋์ค ์ค์ฝ์ด

๋ณต์กํด์ง ๋ชจ๋ธ์ ํ๋ํฐ๋ฅผ ์ค์ ์ต๋ํ ์ฌํํ๊ฒ ๋ง๋๋ ๊ณผ์ .
loss๊ฐ ์์ผ๋ฉด ์์์๋ก ์ข์ ๊ฒ ๋ง์ ์๋๋ค.(๊ณผ๋์ ํฉ) ํจ์๊ฐ ๋จ์ํด์ผ(์ฆ, ์ง์ ์ ๊ฐ๊น์์ผ) test data์ ์ ํฉํ ๊ฐ๋ฅ์ฑ ์ปค์ง๋ค.

๋ชจ๋ธ์ ๋ณต์กํจ, ๋จ์ํจ์ ํต์ ํ๊ธฐ ์ํด ์์ค ํจ์์ regularization term์ ์ถ๊ฐ
Data Loss ์ Regularization loss์ ํฉ์ผ๋ก ๋ณํ๊ณ , ํ์ดํผํ๋ผ๋ฏธํฐ์ธ ๋๋ค๋ก ๋ ํญ๊ฐ์ ํธ๋ ์ด๋์คํ๋ฅผ ์กฐ์

x: ์ด๋ฏธ์ง ํฝ์
๊ฐ์ด [1,1,1,1] ์ด๋ผ๊ณ ๊ฐ์ ํด๋ณด์.
๊ฐ์ค์น๊ฐ ๊ฐ๊ฐ w1, w2์ผ ๋ L1๊ณผ L2๋ ๊ฐ๊ฐ ์ด๋ค ๊ฐ์ค์น๋ฅผ ์ ํธํ ๊น?
L1: w1์ ์ ํธ
sparseํ๊ฑธ ๊ณ ๋ฆ
0์ด ๋ง์ผ๋ฉด ์ข๋ค๊ณ ํ๋จ
L2: w2๋ฅผ ์ ํธ
w2๊ฐ norm์ด ๋ ์๊ธฐ ๋๋ฌธ.
๋ชจ๋ ์์๊ฐ ๊ณจ๊ณ ๋ฃจ ์ํฅ์ ๋ฏธ์น๊ธธ ๋ฐ๋
๋ฅ๋ฌ๋์์ ์์ฃผ ์ฌ์ฉ๋จ.
Multi-class SVM loss์์๋ score ์์ฒด์ ๋ํ ํด์๋ณด๋ค๋ ์ ๋ต class์ ์ ๋ต์ด ์๋ class๋ค์ ๋น๊ตํ๋ ํ์์ด์๋ค.
softmax๋ ๊ทธ ์ฐจ์ด๋ฅผ ๋ชจ๋ ์์นํํ์ฌ score ์์ฒด์ ์ถ๊ฐ์ ์ธ ์๋ฏธ ๋ถ์ฌํ๋ค.


ํด๋์ค๋ณ ํ๋ฅ ๋ถํฌ๋ฅผ ๊ณ์ฐํ๊ณ ์ด๋ฅผ ์ด์ฉํด์ loss๋ฅผ ๊ณ์ฐํจ.
์ง์ํ โ ์ ๊ทํ โ -log
์ ๋ต ํด๋์ค์ ๊ฐ๊น์ฐ๋ฉด ํ๋ฅ ์ด 1์ ๊ฐ๊น์.
๋ฅ๋ฌ๋์ด๋ ์ต์ข
์์ค ํจ์๊ฐ ์ต์๊ฐ ๋๊ฒ ํ๋ ๊ฐ์ค์น ํ๋ ฌ์ด์ ํ๋ผ๋ฏธํฐ์ธ ํ๋ ฌ W๋ฅผ ๊ตฌํ๋ ๊ฒ์ธ๋ฐ, ์ค์ ๋ก ์ด๋ป๊ฒ loss๋ฅผ ์ค์ด๋ w๋ฅผ ์ฐพ์ ์ ์์๊น?
์ต์ ํ๋ ์ฐ์ ๊ณจ์ง๊ธฐ๋ฅผ ๋ด๋ ค๊ฐ๋ ๊ฒ๊ณผ ๊ฐ๋ค. loss๊ฐ ๋ฎ์ ์ํ์ธ ๋ฎ์ ์ง๋๋ฅผ ํฅํด..
๋ฎ์ ๊ณณ์ ํฅํด ๋์๊ฐ๊ธฐ ์ํด ๊ฒฝ์ฌ๋ฅผ ๋ฐ๋ผ ๋ด๋ ค๊ฐ๋ฉฐ ํ์ตํ๋ ๋ฐฉ๋ฒ
ํ์ฌ ์์น์ ์ด๋ํ ์์น์ ๋ฏธ๋ถ ๊ฐ์ ๊ณ์ฐํ๋ฉฐ ๋ฏธ๋ถ ๊ฐ์ ๋ฐ๋ ๋ฐฉํฅ์ผ๋ก ์ด๋ํ๋ฉด ์๋๋ฅผ ํฅํด ๋์๊ฐ๊ฒ ๋๋ค.
numerical ๋ฐฉ๋ฒ์ผ๋ก ๋ฏธ๋ถ ๊ฐ์ ๊ณ์ฐํ ์ ์์ ๊ทผ๋ฐ W๊ฐ ๋๋ฌด ๋ง์์ ํ๋ํ๋ ๊ณ์ฐํ๊ธฐ์ ์๊ฐ์ด ์ค๋๊ฑธ๋ฆผ. ๋ฐ๋ผ์ ๋ฏธ๋ถ์์ ์ด์ฉํด ๋ ๋น ๋ฅด๊ณ ์ฝ๊ฒ ๊ณ์ฐํ ์ ์๋ค.
ํ์ต ๋ฐ์ดํฐ์ ์ผ๋ถ(mini-batch)๋ฅผ ์ฌ์ฉํ์ฌ ํ๋ผ๋ฏธํฐ๋ฅผ ์
๋ฐ์ดํธ
๊ฑฐ์ ๋ชจ๋ DNN ์๊ณ ๋ฆฌ์ฆ์ ์ฌ์ฉ๋จ
# Vanilla Minibatch Gradient Descent
while True:
weights_grad = evaluate_gradient(loss_fun, data, weights)
weights += -step_size * weights_grad # perform parameter update
# step_size : learning rate. ํ๋ฒ์ ์ด๋ํ๋ ์ ๋
learning rate๊ฐ ๋๋ฌด ํฌ๋ฉด overshooting, ๋๋ฌด ์์ผ๋ฉด ์๊ฐ ์ค๋ ๊ฑธ๋ฆผ, global minimum์ด ์๋ local minimum์ ๋น ์ง ์ ์์.
์น๋ฐ๋ชจ ์ฌ์ดํธ Linear Classifier์ Gradient descent:
Multiclass SVM optimization demo (stanford.edu)

์ผ์ชฝ ์ขํ์ ์ด๋ฏธ์ง ํน์ฑ์ ์ ํ ๋ถ๋ฆฌ ํ ์ ์๋ค.
์ค๋ฅธ์ชฝ ์ขํ๋ ๊ฐ ์ ๋ค์ ๊ทน์ขํ๊ณ๋ก ๋ณํํ ๊ฒ์ด๋ค. ์ด๋ฌ๋ฉด ์ ํ ๋ถ๋ฆฌ๊ฐ ๊ฐ๋ฅํด์ง๋ค. ์ด๊ฒ์ ๋ชจํฐ๋ธ๋กํ์ฌ ๊ฐ ํน์ง๋ค์ ์ด์ฉํด ์ด๋ฏธ์ง๋ฅผ ๊ตฌ๋ถํ๋ ์์ด๋์ด๊ฐ ๋์ถ๋๋ค.
2012๋ ์ด์ ๊น์ง๋ ์ด๋ฏธ์ง ํน์ง ์ถ์ถ์ด ๋ง์ด ์ฐ๊ตฌ๋์๋ค. 2012๋ alexnet์ด ๋์จ ์ดํ์ layer๋ฅผ ์์ผ๋ฉด์ cnn์ด๋ dnn์ด ์ฌ์ฉ๋์๋ค. ๋ฐ๋ผ์ ๋ฐ์ดํฐ๋ก๋ถํฐ ํน์ง์ ์ง์ ์ถ์ถํ์ฌ ํ์ตํ๋ ๋ฐฉ์์ด ์ ์ฌ์ฉ๋์ง ์๊ฒ ๋์๋ค.


์ด๋ฏธ์ง๋ฅผ 8x8์ ์์ ์กฐ๊ฐ์ผ๋ก ๋๋์ด ๊ทธ ์กฐ๊ฐ ๋ด ๊ฐ์ฅ ์ง๋ฐฐ์ ์ธ edge(๊ฐ์ด ๊ธ๊ฒฉํ๊ฒ ๋ณํ๋ ์ง์ )๋ฅผ ์ฐพ๋๋ค. ๊ทธ edge๋ฅผ ์์ํํ์ฌ ๋ฐฉํฅ ํ์คํ ๊ทธ๋จ์ผ๋ก ํํํ๋ค. ์์ ์ ์์ ์ธ์์์ ๋ง์ด ์ฌ์ฉ๋์๋ค.

1๋จ๊ณ: ์ด๋ฏธ์ง๋ฅผ ์๊ฒ ์๋ผ ์๊ฐ ๋จ์ด๋ก ํํํ ํ(?) codebook์ ๋ถ์ธ๋ค. k means ์๊ณ ๋ฆฌ์ฆ์ผ๋ก 1์ฒ๊ฐ์ ์ค์ฌ์ ์ ๊ฐ๋๋ก ํ์ตํ๋ค. (์์ ๋ฐ๋ผ ๊ตฐ์งํํ๋ค)
2๋จ๊ณ: ์ด๋ฏธ์ง์ ์๊ฐ ๋จ์ด์ ๋ฐ์ ๋น๋๋ฅผ ์ธ์ฝ๋ฉํ์ฌ ์ด๋ฏธ์ง์ ํน์ง์ ์ถ์ถํ๋ค.