[Deep Learning from Scratch 2] chapter 5. 순환신경망(RNN)

• 피드 포워드(feed forward) 신경망 : 흐름인 단방향인 신경망
• feed forward 신경망은 시계열 데이터의 성질을 충분히 학습할 수 없음

확률과 언어모델¶

언어모델¶

• 언어모델(Language Model): 단어 나열에 확률을 부여, 특정 단어의 시퀀스에 대해 그 시퀀스가 일어날 가능성이 어느정도인지 확률로 평가
• 단어 순서의 자연스러움을 확률적으로 평가 , 확률분포에 따라 다음으로 적합한 단어를 샘플링 할 수 있음
• 동시확률 : 여러 사건이 동시에 일어날 확률

• 조건부 언어 모델(conditional language Model) $$ P(w_1, ..., w_m) = P(w_m| w_1, ...,w_{m-1})P(w_{m-1}| w_1, ...,w_{m-2})...p(w_3|w_1,w_2)P(w_2|w_1)P(w_1)=\prod_{i=1}^m P(w_t| w_1, ...,w_{t-1})$$

  • 사후확률은 타깃단어보다 왼쪽에 있는 모든 단어를 조건으로 했을 때의 확률

• 확률의 곱셉정리 $$P(A, B) =P(A|B)P(B) = P(B|A)P(A)$$

CBOW 모델을 언어모델로¶

$$ P(w_1, ..., w_m) =\prod_{i=1}^m P(w_t| w_1, ...,w_{t-1}) \approx \prod_{i=1}^m P(w_t| w_{t-2}w_{t-1})$$

• Markov chain(마르코브 연쇄), Markov model(마르코브 모델): 미래의 상태가 현재 상태에만 의존해 결정되는 것
• 확률이 그 직전 N개의 사건에만 의존할 때, 'N층 마르코프 연쇄'
• CBOW: bag of words는 가방속 단어를 뜻하며, 가방 속 단어 순서는 무시된다는 뜻도 내포 (순서 대신 분포)
• CBOW 모델의 은닉층에서는 단어벡터들이 더해지므로 맥락의 단어순서는 무시됨

• CBOW

• 언어모델(Nueral Probabilistic language model)

• 신경 확률론적 언어모델(Nueral Probabilistic language model)에서 제안한 모델은 단어 백터를 은닉층에서 연결하는 방식을 취함 $\rightarrow$ 맥락의 크기에 비례하여 가중치 매개변수도 늘어남 $\rightarrow$ 맥락이 길더라도 그 맥락의 정보를 기억하는 매커니즘 (RNN)

RNN¶

• Recurrent Neural Network: 순환신경망
• 순환은 반복해서 되돌아감을 의미하므로 순환하기 위해서는 닫힌 경로가 필요 즉 닫힌 경로, 순환하는 경로가 존재해야 데이터가 같은 장소를 반복해서 왕래할 수 있음
• 데이터가 순환하기 때문에 과거를 정보를 기억하는 동시에 최신 데이터로 갱신될 수 있음
• 시간방향으로 데이터가 나열됨
• 각 시간의 RNN 계층은 그 계층으로의 입력과 1개 전의 RNN계층으로부터 출력을 받음, 두 정보를 바탕으로 현 시각의 출력을 계산
• 다수의 RNN계층 모두가 실제로는 같은 계층

$$h_t = tanh(h_{t-1}W_h + x_tW_x+b)$$

• $W_x$: 입력 x를 출력 h로 변환하기 위한 가중치
• $W_h$: 다른 시각의 출력으로 변환하기 위한 가중치
• 현재의 출력은 한 시각 이전 출력에 기초해 계산, h라는 상태를 가지고 갱신: RNN을 상태를 가지는 계층, 메모리(기억력)을 가지는 계층

BPTT¶

• BPTT(Backpropagation Through Time) 시간방향으로 펼친 신경망의 오차역전파법
• 시간의 크기가 커지면 역전파시 기울기가 불안정해짐

Truncated BPTT¶

• 시간축 발향으로 너무 길어진 신경망을 적당한 지점에서 잘라네어 작은 신경망 여러개로 만듬 $\rightarrow$ 역전파의 연결만 끊음, 각 블록 단위로 미래의 블록과는 독립적으로 오차역전파법을 완결시킴

RNN 계층 구현¶

$$h_t = tanh(h_{t-1}W_h + x_tW_x+b)$$

In [1]:

class RNN:
    def __init__(self, Wx, Wh, b):
        self.params = [Wx, Wh, b]
        self.grads = [np.zeros_like(Wx), np.zeros_like(Wh), np.zeros_like(b)]
        self.cache = None
        
    def forward(self, x, h_prev):
        Wx , Wh, b = self.params
        t = np.dot(h_prev, Wh) + np.dot(x, Wx) + b
        h_next = np.tanh(t)
        
        self.cache = (x, h_prev, h_next)
        return h_next
    
    def backward(self, dh_next):
        Wx, Wh, b = self.params
        x, h_prev, h_next = self.cache
        
        dt = dh_next * (1-h_next**2) # tanh 미분
        db = np.sum(dt, axis=0)
        dWh = np.dot(h_prev.T, dt)
        dh_prev = np.dot(dt, Wh.T)
        dWx = np.dot(x.T, dt)
        dx = np.dot(dt, Wx.T)
        
        self.grads[0][...] =dWx
        self.grads[1][...] = dWh
        self.grads[2][...] = db
        
        return dx, dh_prev

Time RNN계층 구현¶

• RNN계층 T개를 연결한 신경망 (시계열 데이터를 한꺼번에 처리)

  • stateful = True:Time RNN계층이 있는 상태(은닉상태를 유지)
  • stateful = False: 은닉생태를 영행렬로 초기화
  • layers : 다수의 RNN계층을 리스트로 저장

In [2]:

class TimeRNN:
    def __init__(self, Wx, Wh, b, stateful=False):
        self.params = [Wx, Wh, b]
        self.grads = [np.zeros_like(Wx), np.zeros_like(Wh), np.zeros_like(b)]
        self.layers = None
        self.h, self.dh = None, None
        self.stateful = stateful
        
    def forward(self, xs):
        Wx, Wh, b = self.params
        N, T, D = xs.shape # N:미니배치크기, T: T개 분량의 시계열, D: 입력벡터 차원수
        D, H = Wx.shape
        
        self.layers = []
        hs = np.empty((N, T, H), dtype ='f') # 출력값을 담을 그릇
        
        if not self.stateful or self.h is None:
            self.h = np.zeros((N, H), dtype='f')
            
        for t in range(T):
            layer = RNN(*self.params)
            self.h = layer.forward(xs[:, t, :], self.h)
            hs[:, t, :] = self.h
            self.layers.append(layer)
            
        return hs
    
    def backward(self, dhs):
        Wx, Wh, b = self.params
        N, T, H = dhs.shape
        D, H = Wx.shape
        
        dxs = np.empty((N, T, D), dtype ='f')
        dh = 0
        grads = [0, 0, 0]
        
        for t in reversed(range(T)):
            layers = self.layer[t]
            dx, dh = layer.backward(dhs[:, t, :] + dh)
            dxs[:, t, :] = dx
            
            for i, grad in enumerate(layer.grads):
                grads[i] += grad
                
        for i, grad in enumerate(grads):
            self.grads[i][...] = grad
        
        self.dh = dh
        
        return dxs     
    
    # Time RNN은닉상태를 성정하는 매서드
    def set_state(self, h): 
        self.h = h
        
    # 은닉상태 초기화
    def reset_state(self):
        self.h = None

언어모델 평가¶

• 언어 모델은 주어진 과거 단어로부터 다음에 출현할 단어의 확률분포를 출력
• 퍼플렉서티(perplexity, 혼란도): 언어모델의 예측성능을 평가하는 척도, 확률의 역수
• 해석=> 분기수(number of branches)로 해석, 즉 다음에 취할 수 있는 선택사항의 수, 분기수가 1.25라면 다음에 출현할 단어의 후보를 1개로 좁혔다는 뜻이고 5라면 후보가 5개임을 뜻함. $$L =-\frac{1}{N} \sum_n \sum_t t_{nk}log y_{nk}$$ $$perplexity = e^L$$

  • N: 총 데이터 갯수
  • $t_n$: 원핫벡터 정답레이블
  • $t_{nk}$ : n개째 데이터의 k번째 값
  • $y_{nk}$: 확률분포
  • L : 신경망 손실

• 퍼플렉서티가 작아질수록 분기수가 줄어 좋은 모델

Summary

• RNN은 순환하는 경로가 았고, 이를 통해 내부에 은닉상태를 기억할수 있음.
• RNN의 순환 경로를 펼침으로써 다수의 RNN 계층이 연결된 신경망으로 해석할 수 있으며, 보통의 오차역전파법으로 학습할 수 있음(=BPTT)
• 긴 시계열 데이터를 학습할 때는 데이터를 적당한 길있기 모으고(블록), 블록단위로 BPTT에 의한 학습을 수행(=Truncated BPTT)
• Truncated BPTT에서는 역전파의 연결만 끊음
• Truncated BPTT에서는 순전파의 연결을 유지하기 위해 데이터를 순차적으로 입력해야함
• 언어 모델은 단어 시퀀스를 확률로 해석
• RNN계층을 이용한 조건부 언어모델은 이론적으로는 그때까지 등장한 모든 단어의 정보를 기억할 수 있음