- ์ด๋ฒ ๊ธ์์๋ ์ถ๋ก ๊ธฐ๋ฐ ๊ธฐ๋ฒ๊ณผ Neural Network(์ ๊ฒฝ๋ง)์ ๋ฐํ์ฌ ํ๋ฒ ์์ ๋ณด๊ฒ ์ต๋๋ค.

ํต๊ณ ๊ธฐ๋ฐ ๊ธฐ๋ฒ์ ๋ฌธ์ ์
๋จ์ด๋ฅผ Vector๋ก ํํํ๋ ๋ฐฉ๋ฒ์ ์ต๊ทผ์๋ ํฌ๊ฒ ๋ ๋ถ๋ฅ๋ก ๋๋ ์ ์์ต๋๋ค. 'ํต๊ณ ๊ธฐ๋ฐ ๊ธฐ๋ฒ'๊ณผ '์ถ๋ก ๊ธฐ๋ฐ ๊ธฐ๋ฒ' ์ ๋๋ค.
- ๋ ๋ฐฉ๋ฒ์ด ๋จ์ด์ ์๋ฏธ๋ฅผ ์ป๋ ๋ฐฉ์์ ์๋ก ๋ค๋ฅด์ง๋ง, ๊ทธ ๋ฐฐ๊ฒฝ์๋ ๋ชจ๋ ๋ถํฌ ๊ฐ์ค์ด ์์ต๋๋ค.
- ํต๊ณ ๊ธฐ๋ฐ ๊ธฐ๋ฒ์์๋ ์ฃผ๋ณ ๋ฐ์ด์ ๋น๋๋ฅผ ๊ธฐ์ด๋ก ๋จ์ด๋ฅผ ํํ ํ์ต๋๋ค.
- ๊ตฌ์ฒด์ ์ผ๋ก๋ ๋จ์ด์ Co-Occurance Matrix(๋์ ๋ฐ์ ํ๋ ฌ)์ ๋ง๋ค๊ณ ๊ทธ ํ๋ ฌ์ ํน์๊ฐ๋ถํด(Singular Value Decomposition, SVD)๋ฅผ ์ ์ฉํ์ฌ ๋ฐ์ง๋ฒกํฐ๋ฅผ ์ป์ต๋๋ค.
- ๊ทธ๋ฌ๋, ์ด ๋ฐฉ์์ ๋๊ท๋ชจ Corpus(๋ง๋ญ์น)๋ฅผ ๋ค๋ฃฐ ๋ ๋ฌธ์ ๊ฐ ๋ฐ์ํฉ๋๋ค.
- ์ผ๋จ, ํต๊ณ ๊ธฐ๋ฐ ๊ธฐ๋ฒ์ Corpus(๋ง๋ญ์น) ์ ์ฒด์ ํต๊ณ(Co-Occurance Matrix(๋์ ๋ฐ์ ํ๋ ฌ), PPMI)๋ฅผ ์ด์ฉํด์ ๋จ ํ๋ฒ์ ์ฒ๋ฆฌ SVD ๋ฑ)๋ง์ ๋จ์ด์ ๋ถ์ฐ ํํ์ ์ป์ต๋๋ค.
- ์ถ๋ก ๊ธฐ๋ฐ ๊ธฐ๋ฒ, ์ฆ Neural Network(์ ๊ฒฝ๋ง)์ ์ด์ฉํ๋ ๊ฒฝ์ฐ๋ Mini-Batch๋ก ํ์ต ํ๋๊ฒ์ด ์ผ๋ฐ์ ์
๋๋ค.
- Mini-Batch ํ์ต์์๋ Neural Network(์ ๊ฒฝ๋ง)์ด ํ๋ฒ์ Mini-Batch(์๋)์ ํ์ต ์ํ์ฉ ๋ฐ๋ณตํ์ฌ ํ์ต ํ, Weight(๊ฐ์ค์น)๋ฅผ ๊ฐฑ์ ํด๊ฐ๋๋ค.

- ์ถ๋ก ๊ธฐ๋ฐ ๊ธฐ๋ฒ์ Corpus(๋ง๋ญ์น)์ ์ดํ๊ฐ ๋ง์ ํฐ ์์ ์ ์ฒ๋ฆฌํ๊ธฐ ์ด๋ ค์ด ๊ฒฝ์ฐ์๋ Neural Network(์ ๊ฒฝ๋ง)์ ํ์ต ์ํฌ ์ ์์ต๋๋ค.
- ๋ฐ์ดํฐ๋ฅผ ์๊ฒ ๋๋ ์ ํ์ตํ๊ธฐ ๋๋ฌธ์ ๋๋ค. ๊ทธ๋ฆฌ๊ณ ๋ณ๋ ฌ ๊ณ์ฐ๋ ๊ฐ๋ฅํ๊ธฐ ๋๋ฌธ์ ํ์ต ์๋๋ ๋์ผ ์ ์์ต๋๋ค.
- ์์๋ก ์ถ๋ก ๊ธฐ๋ฐ ๊ธฐ๋ฒ์ ์ฌ์ฉํ ๊ฒ์ Word2Vec ์ ๋๋ค. ์๋์ ์ค๋ช ๊ธ์ ๋ฌ์๋์์ผ๋, ์ฐธ๊ณ ํ์ค ๋ถ๋ค์ ์ฐธ๊ณ ํ์ธ์!
[NLP] Word2Vec, CBOW, Skip-Gram - ๊ฐ๋ & Model
1. What is Word2Vec? Word2Vec์ ๋จ์ด๋ฅผ ๋ฒกํฐ๋ก ๋ณํํ๋๋ฐ ์ฌ์ฉ๋๋ ์ธ๊ธฐ์๋ ์๊ณ ๋ฆฌ์ฆ ์ ๋๋ค. ์ฌ๊ธฐ์ ๋จ์ด๋ ๋ณดํต 'Token' ํ ํฐ ์ ๋๋ค. ์ด ์๊ณ ๋ฆฌ์ฆ์ ๋จ์ด(Token)๋ค ์ฌ์ด์ ์๋ฏธ์ ๊ด๊ณ๋ฅผ Vector ๊ณต๊ฐ์
daehyun-bigbread.tistory.com
์ถ๋ก ๊ธฐ๋ฐ ๊ธฐ๋ฒ ๊ฐ์
์ถ๋ก ๊ธฐ๋ฐ ๊ธฐ๋ฒ์์๋ '์ถ๋ก '์ด ์ฃผ๋ ์์ ์ ๋๋ค.
- ์ถ๋ก ์ด๋? ์ฃผ๋ณ ๋จ์ด(๋งฅ๋ต)์ด ์ฃผ์ด์ก์๋ "?" ์ ๋ฌด์จ ๋จ์ด๊ฐ ๋ค์ด๊ฐ๋์ง๋ฅผ ์ถ์ธกํ๋ ์์ ์ ๋๋ค.

- ์์ ๊ทธ๋ฆผ์ฒ๋ผ ์ถ๋ก ๋ฌธ์ ๋ฅผ ํ๊ณ ํ์ตํ๋ ๊ฒ์ด '์ถ๋ก ๊ธฐ๋ฐ ๊ธฐ๋ฒ'์ด ๋ค๋ฃจ๋ ๋ฌธ์ ์ ๋๋ค.
- ์ด๋ฌํ ์ถ๋ก ๋ฌธ์ ๋ฅผ ๋ฐ๋ณตํด์ ํ๋ฉด์ ๋จ์ด์ ์ถํ ํจํด์ ํ์ตํ๋ ๊ฒ์ ๋๋ค.

- ์ฌ๊ธฐ์ ๋ชจ๋ธ์ Neural Network(์ ๊ฒฝ๋ง)์ ์ฌ์ฉํ๊ณ , ๋งฅ๋ต ์ ๋ณด๋ฅผ ๋ฐ์์ ๊ฐ ๋จ์ด์ ์ถํ ํ๋ฅ ์ ์ถ๋ ฅํฉ๋๋ค.
- ์ด๋ฌํ ํ ์์์ Corpus๋ฅผ ์ฌ์ฉํด ๋ชจ๋ธ์ด ์ฌ ๋ฐ๋ฅธ ์ถ์ธก์ ๋ด๋๋๋ก ํ์ต์ํต๋๋ค.
- ๊ทธ๋ฆฌ๊ณ ๊ทธ ํ์ต์ ๊ฒฐ๊ณผ๋ก ๋จ์ด์ ๋ถ์ฐ ํํ์ ์ป๋ ๊ฒ์ด ์ถ๋ก ๊ธฐ๋ฐ ๊ธฐ๋ฒ์ ์ ์ฒด์ ์ธ ํ๋ฆ์ ๋๋ค.
Neural Network(์ ๊ฒฝ๋ง)์์์ ๋จ์ด ์ฒ๋ฆฌ
์ง๊ธ๋ถํฐ Neural Network(์ ๊ฒฝ๋ง)์ ์ด์ฉํด '๋จ์ด'๋ฅผ ์ฒ๋ฆฌํฉ๋๋ค.
- ๊ทผ๋ฐ, ์ ๊ฒฝ๋ง์ "you", "say"๊ฐ์ ๋จ์ด๋ฅผ ๊ทธ๋๋ก ์ฒ๋ฆฌ ํ ์ ์์ต๋๋ค.
- ๊ทธ๋์ ๋จ์ด๋ฅผ "๊ณ ์ ๋ ๊ธธ์ด์ Vector"๋ก ๋ณํํด์ผ ํฉ๋๋ค. ์ด๋ ๋ํ์ ์ผ๋ก ์ฌ์ฉํ๋ ๋ฐฉ๋ฒ์ด One-Hot Vector๋ก ๋ณํํ๋ ๊ฒ์ ๋๋ค.
One-Hot Vector๋ Vector์ ์์์ค ํ๋๋ง 1์ด๊ณ ๋๋จธ์ง๋ 0์ธ ๋ฒกํฐ๋ฅผ ๋งํฉ๋๋ค.
- ํ๋ฒ ์์๋ฅผ ๋ค์ด๋ณด๊ฒ ์ต๋๋ค.
"You say goodbye and I say hello" - ์์ ๋ฌธ์ฅ
- ์์ ๋ฌธ์ฅ์ ๋ณด๋ฉด ์ดํ๊ฐ 7๊ฐ๊ฐ ๋ฑ์ฅํฉ๋๋ค. "You", "say", "goodbye", "and", "I", "say", "hello"
- ์ด์ค ๋ ๋จ์ด์ One-Hot ํํ์ ๊ทธ๋ฆผ์ ๋ํ๋ด์ด ๋ดค์ต๋๋ค.

- ์์ ๊ทธ๋ฆผ์ฒ๋ผ ๋จ์ด๋ Text, ๋จ์ด ID, ๊ทธ๋ฆฌ๊ณ One-Hot ํํ ํํ๋ก ๋ํ๋ผ ์ ์์ต๋๋ค.
- ํํํ๋ ๋ฐฉ๋ฒ์ ์ด ์ดํ์๋งํผ ์์๋ฅผ ๊ฐ์ง๋ Vector๋ฅผ ์ค๋นํ, Index๊ฐ ๋จ์ด ID์ ๊ฐ์ ์์๋ฅผ 1, ๋๋จธ์ง๋ ๋ชจ๋ 0์ผ๋ก ์ค์ ํฉ๋๋ค.
- ์ด์ฒ๋ผ ๋จ์ด๋ฅผ ๊ณ ์ ๊ธธ์ด ๋ฒกํฐ๋ก ๋ณํํ๋ฉด Neural Network(์ ๊ฒฝ๋ง)์ Input Layer๋ ์๋์ ๊ทธ๋ฆผ์ฒ๋ผ Neuron(๋ด๋ฐ)์ ์๋ฅผ ๊ณ ์ ํ ์ ์์ต๋๋ค.

- ์์ ๊ทธ๋ฆผ์ฒ๋ผ Input Layer(์ ๋ ฅ์ธต)์ ๋ด๋ฐ์ 7๊ฐ ์ ๋๋ค.
- ์ด 7๊ฐ์ ๋ด๋ฐ์ ์ฐจ๋ก๋ก 7๊ฐ์ ๋จ์ด๋ค์ ๋์ํฉ๋๋ค.
- ๊ทธ๋ฆฌ๊ณ ์ ๊ฒฝ๋ง์ Layer๋ Vector ์ฒ๋ฆฌ๊ฐ ๊ฐ๋ฅํ๋ฏ๋ก, One-Hot ํํ์ผ๋ก ๋ ๋จ์ด๋ฅผ Fully-Connected Layer(์์ -์ฐ๊ฒฐ ๊ณ์ธต)์ ํตํด ์ฌ์ฉํ ์ ์์ต๋๋ค.

- ์ฌ๊ธฐ์ Neural Network(์ ๊ฒฝ๋ง)์ Fully-Connected Layer(์์ -์ฐ๊ฒฐ ๊ณ์ธต)์ด๋ฏ๋ก ๊ฐ๊ฐ์ ๋ ธ๋๊ฐ ์ด์ ์ธต์ ๋ชจ๋ ๋ ธ๋์ ํ์ดํ๋ก ์ฐ๊ฒฐ๋์ด ์์ต๋๋ค.
- ์ด ํ์ดํ์ Weight(๊ฐ์ค์น)๊ฐ ์กด์ฌํ๋ฉฐ, Input Layer์ Neuron(๋ด๋ฐ)๊ณผ Weight(๊ฐ์ค์น)์ ํฉ์ด Hidden Layer Neuron(์๋์ธต ๋ด๋ฐ)์ด ๋ฉ๋๋ค.

Fully-Connected Layer์ ์ํ ๋ณํ Code (by Python)
Fully-Connected Layer์ ์ํ ๋ณํ๋ ์ฝ๋๋ ์ด๋ ๊ฒ ์ ์์ ์์ต๋๋ค.
import numpy as np
c = np.array([[1, 0, 0, 0, 0, 0, 0]]) # Input(์
๋ ฅ)
W = np.random.randn(7, 3) # Weight(๊ฐ์ค์น)
h = np.matmul(c, W) # ์ค๊ฐ ๋
ธ๋
print(h)
# [[-0.70012195 0.25204755 -0.79774592]]
- ์ด ์ฝ๋๋ ๋จ์ด ID๊ฐ 0์ธ ๋จ์ด๋ฅผ One-Hot ํํ์ผ๋ก ํํํ ๋ค์, Fully-Connected Layer๋ฅผ ํต๊ณผํ์ฌ ๋ณํํ๋ ๋ชจ์ต์ ๋ณด์ฌ์ค๋๋ค.
- c๋ One-Hot ํํ์ด๋ฉฐ, ๋จ์ด ID์ ๋์ํ๋ ์์๋ง 1์ด๊ณ ๋๋จธ์ง๋ 0์ธ Vector์ ๋๋ค.

- ๊ทธ๋ฆฌ๊ณ ์์์ ๊ตฌํํ Fully-Connected Layer์ ์ํ ๋ณํ๋ ์ฝ๋๋ MatMul ๊ณ์ธต์ผ๋ก ์ํํ ์ ์์ต๋๋ค.
import sys
sys.path.append('..')
import numpy as np
from common.layers import MatMul
c = np.array([[1, 0, 0, 0, 0, 0, 0]])
W = np.random.randn(7, 3)
layer = MatMul(W)
h = layer.forward(c)
print(h)
# [[-0.70012195 0.25204755 -0.79774592]]
- ์ด ์ฝ๋๋ MatMul Layer์ Weight(๊ฐ์ค์น) W๋ฅผ ์ค์ ํ๊ณ forward() Method๋ฅผ ํธ์ถํด Forward Propagation(์์ ํ)๋ฅผ ์ํํฉ๋๋ค.
MatMul Layer
๊ธฐ๋ณธ์ ์ธ ์ ๊ฒฝ๋ง Layer์์ ํ๋ ฌ ๊ณฑ์ ์ฐ์ฐ์ ์ํํ๊ณ , Backpropagation(์ญ์ ํ)๋ฅผ ํตํด Gradient(๊ธฐ์ธ๊ธฐ)๋ฅผ ๊ณ์ฐํ๋ ์ญํ ์ ํฉ๋๋ค.
import numpy as np
class MatMul:
def __init__(self, W):
"""
ํด๋์ค ์ด๊ธฐํ ๋ฉ์๋. ๊ฐ์ค์น ํ๋ ฌ W๋ฅผ ๋ฐ์ ์ด๊ธฐํํฉ๋๋ค.
Parameters:
W (numpy.ndarray): ๊ฐ์ค์น ํ๋ ฌ
"""
self.params = [W] # ๊ฐ์ค์น ํ๋ ฌ W๋ฅผ ํ๋ผ๋ฏธํฐ๋ก ์ ์ฅ
self.grads = [np.zeros_like(W)] # W์ ๊ฐ์ ํํ์ ์ํ๋ ฌ๋ก ๊ธฐ์ธ๊ธฐ๋ฅผ ์ด๊ธฐํ
self.x = None # ์
๋ ฅ x๋ฅผ ์ ์ฅํ ๋ณ์ ์ด๊ธฐํ
def forward(self, x):
"""
์๋ฐฉํฅ ์ ํ ๋ฉ์๋. ์
๋ ฅ x์ ๊ฐ์ค์น W์ ํ๋ ฌ ๊ณฑ์ ๊ณ์ฐํฉ๋๋ค.
Parameters:
x (numpy.ndarray): ์
๋ ฅ ๋ฐ์ดํฐ
Returns:
out (numpy.ndarray): ์
๋ ฅ๊ณผ ๊ฐ์ค์น์ ํ๋ ฌ ๊ณฑ ๊ฒฐ๊ณผ
"""
W, = self.params # ํ๋ผ๋ฏธํฐ์์ ๊ฐ์ค์น W๋ฅผ ๊บผ๋
out = np.dot(x, W) # ์
๋ ฅ x์ ๊ฐ์ค์น W์ ํ๋ ฌ ๊ณฑ ์ํ
self.x = x # ์
๋ ฅ x๋ฅผ ์ธ์คํด์ค ๋ณ์์ ์ ์ฅ
return out # ๊ฒฐ๊ณผ ๋ฐํ
def backward(self, dout):
"""
์ญ๋ฐฉํฅ ์ ํ ๋ฉ์๋. ์ถ๋ ฅ์ ๋ํ ๊ธฐ์ธ๊ธฐ dout์ ๋ฐ์ ์
๋ ฅ๊ณผ ๊ฐ์ค์น์ ๊ธฐ์ธ๊ธฐ๋ฅผ ๊ณ์ฐํฉ๋๋ค.
Parameters:
dout (numpy.ndarray): ์ถ๋ ฅ ๊ธฐ์ธ๊ธฐ
Returns:
dx (numpy.ndarray): ์
๋ ฅ์ ๋ํ ๊ธฐ์ธ๊ธฐ
"""
W, = self.params # ํ๋ผ๋ฏธํฐ์์ ๊ฐ์ค์น W๋ฅผ ๊บผ๋
dx = np.dot(dout, W.T) # ์ถ๋ ฅ ๊ธฐ์ธ๊ธฐ์ ๊ฐ์ค์น์ ์ ์น ํ๋ ฌ์ ๊ณฑํ์ฌ ์
๋ ฅ ๊ธฐ์ธ๊ธฐ ๊ณ์ฐ
dW = np.dot(self.x.T, dout) # ์
๋ ฅ์ ์ ์น ํ๋ ฌ๊ณผ ์ถ๋ ฅ ๊ธฐ์ธ๊ธฐ๋ฅผ ๊ณฑํ์ฌ ๊ฐ์ค์น ๊ธฐ์ธ๊ธฐ ๊ณ์ฐ
self.grads[0][...] = dW # ๊ณ์ฐ๋ ๊ฐ์ค์น ๊ธฐ์ธ๊ธฐ๋ฅผ grads ๋ฆฌ์คํธ์ ์ ์ฅ
return dx # ์
๋ ฅ ๊ธฐ์ธ๊ธฐ ๋ฐํ
- __init__ : ํด๋์ค์ ์ด๊ธฐํ Method๋ก, ๊ฐ์ค์น ํ๋ ฌ W๋ฅผ ๋ฐ์์ ์ด๋ฅผ params ๋ฆฌ์คํธ์ ์ ์ฅํฉ๋๋ค.
- ๋ํ, W์ ๊ฐ์ ํํ์ ์ํ๋ ฌ์ grads ๋ฆฌ์คํธ์ ์ ์ฅํ์ฌ ๊ธฐ์ธ๊ธฐ๋ฅผ ์ด๊ธฐํํฉ๋๋ค.
- x๋ ๋์ค์ ์๋ฐฉํฅ ์ ํ ์ ์ ๋ ฅ ๊ฐ์ ์ ์ฅํ๊ธฐ ์ํด ์ด๊ธฐํ๋ฉ๋๋ค.
- forward : Forward Propagation(์์ ํ)๋ฅผ ์ํํ๋ Method ์
๋๋ค.
- ์ ๋ ฅ x์ ๊ฐ์ค์น W์ ํ๋ ฌ ๊ณฑ์ ๊ณ์ฐํ๊ณ ๊ทธ ๊ฒฐ๊ณผ๋ฅผ ๋ฐํํฉ๋๋ค.
- ์ด ๊ณผ์ ์์ ์ ๋ ฅ x๋ฅผ ์ธ์คํด์ค ๋ณ์์ ์ ์ฅํ์ฌ ๋์ค์ ์ญ๋ฐฉํฅ ์ ํ์์ ์ฌ์ฉํ ์ ์๋๋ก ํฉ๋๋ค.
- backward: Back Propagation(์ญ์ ํ)๋ฅผ ์ํํ๋ Method ์
๋๋ค.
- ์ถ๋ ฅ์ ๋ํ ๊ธฐ์ธ๊ธฐ dout์ ์ ๋ ฅ๋ฐ์, ์ ๋ ฅ์ ๋ํ ๊ธฐ์ธ๊ธฐ dx์ ๊ฐ์ค์น์ ๋ํ ๊ธฐ์ธ๊ธฐ dW๋ฅผ ๊ณ์ฐํฉ๋๋ค.
- ๊ณ์ฐ๋ dW๋ grads ๋ฆฌ์คํธ์ ์ ์ฅ๋๊ณ , dx๋ ๋ฐํ๋ฉ๋๋ค.
๋ถ์ฌ: ๋ค๋ก, ๊ฑฐ๊พธ๋ก, ๋ค๋ก ํฅํ์ฌ ํ์ฉ์ฌ: ์ซ์ดํ๋, ๋ค๋ฆ์, ๋ค์ชฝ์
'๐ NLP (์์ฐ์ด์ฒ๋ฆฌ) > ๐ Natural Language Processing' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
[NLP] RNNLM - RNN์ ์ฌ์ฉํ Language Model (0) | 2024.06.02 |
---|---|
[NLP] BPTT (Backpropagation Through Time) (0) | 2024.05.23 |
[NLP] ํต๊ณ ๊ธฐ๋ฐ ๊ธฐ๋ฒ ๊ฐ์ ํ๊ธฐ (0) | 2024.05.20 |
[NLP] Thesaurus(์์๋ฌ์ค), Co-occurence Matrix(๋์๋ฐ์ ํ๋ ฌ) (0) | 2024.05.18 |
[NLP] Transformer Model - ํธ๋์คํฌ๋จธ ๋ชจ๋ธ ์์๋ณด๊ธฐ (0) | 2024.03.07 |