[Deep Learning from Scratch 2] chapter 4. word2vec 속도개선

In [1]:

import numpy as np
import collections

• CBOW의 가장큰 문제는 말뭉치에 포함된 어휘의 수가 많아지면 계산량도 커짐
  $\rightarrow$ Embedding계층추가
  $\rightarrow$ 네거티브 샘플링 (새로운 손실함수)도입

Embedding계층¶

• 가중치 매개변수로 부터 단어ID에 해당하는 행(벡터)를 추출하는 계층, Embedding계층에 단어 임베딩을 저장
• word embedding(단어 임베딩)은 자연어 처리 분야에서 단어의 밀집벡터 표현을 말함 (단어의 분산표현, distributed representation)

  • distributional representation: 통계기반기법으로 얻은 단어벡터
  • distributed representation: 추론기반기법으로 얻은 단어벡터

Embedding 계층 구현¶

In [2]:

W = np.arange(21).reshape(7,3)
print('=====W전체======')
print(W)
print('=====W[2]행=====')
print(W[2])

=====W전체======
[[ 0  1  2]
 [ 3  4  5]
 [ 6  7  8]
 [ 9 10 11]
 [12 13 14]
 [15 16 17]
 [18 19 20]]
=====W[2]행=====
[6 7 8]

In [3]:

idx = np.array([1, 0, 3, 0])
W[idx]

Out[3]:

array([[ 3,  4,  5],
       [ 0,  1,  2],
       [ 9, 10, 11],
       [ 0,  1,  2]])

In [4]:

class Embedding:
    def __init__(self, W):
        self.params = [W]
        self.grads = [np.zeros_like(W)]
        self.idx = None
        
    def forward(self, idx):
        W, = self.params
        self.idx = idx
        out = W[idx]
        return out
    
    def backward(self, dout):
        dW, = self.grads
        dW[...] = 0 # dW의 형상을 유지한채 그 원소들을 0으로 덮어씀
        np.add.at(dW, self.idx, dout)
        return None

• Embedding은 계층의 순전파는 가중치 W의 특정행을 추출하여 특정 행의 뉴런만을 다음 층으로 흘려보냄
• 따라서, Embedding역전파는 출력층으로 부터 전해진 기울기를 다음층으로 그대로 보내주면 됨(앞 층으로부터 전해진 기울기를 가중치 기울기 dW의 특정행에 설정)

np.add.at(A, idx, B): B를 A의 idx번째 행에 더해줌

In [5]:

# # np.add.at 동일한 표현
# for i, word_id in enumerate(self.idx):
#     dW[word_id] += dout[i]

네거티브 샘플링¶

• 은닉층 뉴런과 가중치 행렬 곱의 처리, softmax계층 계산을 개선
• softmax대신 네거티브 샘플링을 이용하면 어휘가 많아져도 계산량을 낮은 수준에서 일정하게 억제할 수 있음
• 다중 분류(multi-class classification) $\rightarrow$ 이진분류(binomial classification)로 근사하는 것
• 출력측 가중치에서 단어 하나에 주목하여 그 점수만을 계산하고 시그모이드 함수를 이용해 그 해당 점수를 확률로 변환

  • 다중분류: 출력층 $\rightarrow$ softmax함수, 손실함수$\rightarrow$ 교차 엔트로피 오차를 이용
  • 이진분류: 출력층 $\rightarrow$ 시그모이드 함수, 손실함수$\rightarrow$ 교차 엔트로피 오차를 이용
  • Sigmoid $$ y = \frac{1}{1+exp(-x)}$$
  • 교차 엔트로피 오차 $$ L = -(tlogy +(1-t)log(1-y))$$
  • 시그모이드와 교차엔트로피 오차를 조합하여 역전파의 값이 $y-t$임

다중분류에서 이진분류로 구현¶

In [6]:

class EmbeddingDot:
    def __init__(self, W):
        self.embed = Embedding(W)
        self.params = self.embed.params # 매개변수 저장
        self.grads = self.embed.grads # grad저장
        self.cache = None # 순전파시 계산결과를 잠시 유지
        
    def forward(self, h, idx):
        target_W = self.embed.forward(idx)
        out = np.sum(target_W * h, axis=1)
        self.cache = (h, target_W)
        return out
    
    def backward(self, dout):
        h, target_W = self.cache
        dout = dout.reshape(dout.shape[0], 1)
        dtarget_W = dout * h 
        self.embed.backward(dtarget_W)
        dh = dout * target_W
        return dh    

네거티브 샘플링¶

• 긍정적인 예에 대해서는 sigmoid계층의 출력을 1에 가깝게 만들고 부정적인 예에 대해서는 sigmoid출력을 0에 가깝게 만드는 것
• ex) You say goodbye and I say hello. 예에서 맥락이 you, goodbye일때, target이 say인 긍정적인 경우 출력이 1이고 hello의 경우 출력을 0으로 해주는 결과를 만들어내는 가중치가 필요
• 모든 부정적인 어휘에 대해서 할수 없으므로 근사적으로 (적은 수의 부정적인 예를 샘플링하여) 사용
• 긍정적인 예를 타깃으로 한 경우 손실과 부정적인 예를 몇개 샘플링 하여 손실을 구하고 각 데이터의 손실을 더한값을 최종 손실로 함
• 네거티브 부정적인 예를 샘플링 하는 방법

  • 말뭉치 통계데이터를 기초로 말뭉치에서 자중 등장하는 단어를 많이 추출하고 드물게 등장하는 단어를 적게 추출
  • 말뭉치에서 단어별 출현횟수를 바탕으로 확률분포를 구한다음 그 확률분포에서 샘플링
  • 확률분포대로 샘플링 하므로 말뭉치에서 자주 등장하는 단어는 선택될 가능성이 높고 희소단어는 선택되기 어려움

In [7]:

words = ['you', 'say', 'goodbye', 'I', 'hello', '.']
print(np.random.choice(words)) # 무작위로 하나만 샘플링
print(np.random.choice(words, size=5)) # 중복가능하며 5개를 샘플링
print(np.random.choice(words, size=5, replace=False)) #중복 불가능 하고 5개를 샘플링

hello
['I' 'say' '.' 'you' 'goodbye']
['goodbye' 'hello' '.' 'you' 'I']

In [8]:

p = [0.5, 0.1, 0.05, 0.2, 0.05, 0.1 ] #word에 대한 확률분포
np.random.choice(words, p=p) # 확률분포에 따라 샘플링

Out[8]:

'I'

word2vec 수정 권고사항

• 기본확률에 0.75를 제곱하는 것

$$P'(w_i) = \frac{P(w_i)^{0.75}}{\sum_j^nP(w_j)^{0.75}}$$

• 확률분포의 각 요서를 0.75제곱 $\rightarrow$ 출현 확률이 낮은 단어를 버리지 않기 위해

In [9]:

p = [0.7, 0.29, 0.01]
new_p = np.power(p, 0.75)
new_p/= np.sum(new_p)
new_p

Out[9]:

array([0.64196878, 0.33150408, 0.02652714])

• 낮은 확률 (0.01)이 수정 후에는 0.0265 (2.65%)로 증가 하였다. 즉 낮은 확률의 단어가 조금 더 쉽게 샘플링 되도록 하기 위한 구제조치임.
• 0.75제곱의 수치는 이론적 의미는 없으므로 다른 값을 설정해도 됨

네거티브 샘플¶

In [15]:

## Unigram: 하나의 연속된 단어
# 말뭉치에서 단어의 확률분포를 만들고 0.75를 제곱한 후 random sampling으로 부정적인 예를 샘플링
class UnigramSampler:
    def __init__(self, corpus, power, sample_size):
        self.sample_size = sample_size
        self.vocab_size = None
        self.word_p = None
        
        counts = collections.Counter()
        for word_id in corpus:
            counts[word_id] +=1
            
        vocab_size = len(counts)
        self.vocab_size = vocab_size
        
        self.word_p = np.zeros(vocab_size)
        for i in range(vocab_size):
            self.word_p[i] = counts[i]
        
        self.word_p = np.power(self.word_p, power)
        self.word_p /= np.sum(self.word_p)
        
    def get_negative_sample(self, target):
        batch_size = target.shape[0]
        
        # not GPU
        negative_sample = np.zeros((batch_size, self.sample_size), dtype = np.int32)
        
        for i in range(batch_size):
            p = self.word_p.copy()
            target_idx = target[i]
            p[target_idx] = 0
            p /= np.sum()
            negative_sample[i, :] =np.random,choice(self.vocab_size, size = self.sample_size,\
                                                   replace=False, p=p)
            
        return negative_sample

네거티브 샘플링¶

In [16]:

class NegativeSamplingLoss:
    def __init__(self, W, corpus, power=0.75, sample_size=5):
        self.sample_size = sample_size
        self.sampler = UnigramSampler(corpus, power, sample_size)
        # 긍정 & 부정적 예 다루는 계층 
        self.loss_layers = [SigmoidWithLoss() for _ in range(sample_size + 1)] 
        self.embed_dot_layers = [Embedding(W) for _ in range(sample_size + 1)]
        
        self.params , self.grads = [], []
        for layer in self.embed_dot_layers:
            self.params += layer.params
            self.grads += layer.grads
            
    def forward(self, h, target):
        batch_size = target.shape[0]  #긍정적인 예의 target
        negative_sample = self.sampler.get_negative_sample(target) #부정적인 예 샘플링하여 저장
        
        # 긍정적예 순전파 loss[0]
        score = self.embed_dot_layers[0].forward(h,target) 
        correct_label = np.ones(batch_size, dtype=np.int32) 
        loss = self.loss_layers[0].forward(score, correct_label) # sigmoid with loss
        
        # 부정적예 순전파
        negative_label = np.zeros(batch_size, dtype = np.int32)
        for i in range(self.sample_size):
            negative_target = negative_sample[:, i]
            score = self.embed_dot_layers[1+i].forward(h, negative_target)
            loss += self.loss_layers[1 + i].forward(score, negative_label)
            
        return loss
    
    def backward(self, dout=1):
        dh = 0
        for l0, l1 in zip(self.loss_layers, self.embed_dot_layers):
            dscore = l0.backward(dout)
            dh += l1.backward(dscore)
            
        return dh            

Sum Node forward and backward 이해¶

In [17]:

d, n = 8,7
x = np.random.randn(n,d)
y = np.sum(x , axis=0, keepdims=True)
print(x)
print(y)

[[ 0.24453787 -0.44849193  2.37522443  0.81504681 -1.88463415  0.85739727
   2.05532778 -0.55448243]
 [ 1.56730253 -0.40965908  0.92791671 -0.47426427  0.95591712 -0.38568626
   1.77193157 -0.78366005]
 [ 0.71945694 -1.0606031   1.25095535 -0.11832978 -0.13193915 -1.62376702
   0.85949455  0.72669345]
 [ 0.41205819 -0.73944381  0.51007843 -1.22023915  0.6461321   2.09379106
  -0.45638718  1.16144043]
 [-0.28008634  0.13319037 -0.59215464  0.09939126 -1.41104754 -2.65212158
  -1.57646526  0.32816065]
 [ 0.20450405  1.20728376  0.10172982  0.3677373   1.02890643  1.02949509
   0.47006649 -0.15169109]
 [ 0.18547259  0.11150395  1.46767237 -0.64790412 -0.91240906 -0.21748425
   0.23730154  0.82145199]]
[[ 3.05324583 -1.20621984  6.04142247 -1.17856196 -1.70907424 -0.8983757
   3.3612695   1.54791295]]

In [18]:

dy = np.random.randn(1, d)
dx = np.repeat(dy, n, axis=0)
print(dy)
print(dx)

[[-2.17736513 -0.27087786  0.40784092 -0.52614058 -2.29841372 -0.10212383
   0.22914595  1.12607409]]
[[-2.17736513 -0.27087786  0.40784092 -0.52614058 -2.29841372 -0.10212383
   0.22914595  1.12607409]
 [-2.17736513 -0.27087786  0.40784092 -0.52614058 -2.29841372 -0.10212383
   0.22914595  1.12607409]
 [-2.17736513 -0.27087786  0.40784092 -0.52614058 -2.29841372 -0.10212383
   0.22914595  1.12607409]
 [-2.17736513 -0.27087786  0.40784092 -0.52614058 -2.29841372 -0.10212383
   0.22914595  1.12607409]
 [-2.17736513 -0.27087786  0.40784092 -0.52614058 -2.29841372 -0.10212383
   0.22914595  1.12607409]
 [-2.17736513 -0.27087786  0.40784092 -0.52614058 -2.29841372 -0.10212383
   0.22914595  1.12607409]
 [-2.17736513 -0.27087786  0.40784092 -0.52614058 -2.29841372 -0.10212383
   0.22914595  1.12607409]]

Summary

• Embedding계층은 단어의 분산표현을 담고 있고, 순전파 시 지정한 단어ID의 벡터를 추출한다
• word2vec은 어휘 수의 증가에 비례하여 계산량도 증가하므로 근사치로 계산하는 빠른 기법을 사용하면 좋다.
• 네거티브 샘픓링은 부정적 에를 몇개 샘플링 하는 기법으로 이를 이용하면 다중 불류를 이진 분류처럼 취급할 수 있다.
• word2vec으로 얻은 단어의 분산 표혀냐에는 단어의 의미가 녹아들어 있으며 비슷한 맬락에서 사용되는 단어는 벡터 공간에서 가까이 위치한다.
• word2vec의 단어의 분산표현을 이용하면 유추 문제를 벡터의 덧셈과 뺄셈으로 풀수 있다.