[NLP] RNNLM - RNN을 사용한 Language Model

RNNLM (RNN을 사용한 Language (언어) 모델)

이번에는 RNN을 사용하여 Language Model(언어 모델)을 구현해 보겠습니다.

• 그 전에 먼저 사용되는 Neural Network(신경망)을 한번 보고 시작해보겠습니다.
• 왼쪽은 RNNLM의 계층 구성이고, 오른쪽에는 이를 시간축으로 펼친 Neural Network(신경망)입니다.

RNNLM의 신경망 (왼쪽이 펼치기 전, 오른쪽은 펼친 후)

• 그림의 Embedding Layer(계층)은 단어 ID의 분산 표현 (단어 Vector)로 변환됩니다.
• 그리고 그 분산 표현이 RNN Layer(RNN 계층)로 입력됩니다.
• RNN 계층은 Hidden State(은닉 상태)를 다음 Layer(층)으로 출력함과 동시에, 다음 시각의 RNN 계층(오른쪽)으로 출력됩니다.
• 그리고 RNN 계층이 위로 출력한 Hidden State(은닉 상태)는 Affine 계층을 거쳐 Softmax 계층으로 전해집니다.
• 그러면 한번 Sample Corpus(말뭉치)를 한번 줘서 사용해 보겠습니다.

"You say goodbye and I say hello"

샘플 Corpus(말뭉치)를 처리하는 RNNLM의 예시

• 위의 그림은 RNNLM(순환 신경망 언어모델)의 작동 방식을 설명합니다
• 입력 데이터는 단어 ID 배열로, 처음에는 단어 "you"가 입력되고, Softmax 계층이 "say"를 예측합니다
• 두 번째 단어 "say"를 입력하면, Softmax 계층은 "goodbye"와 "hello" 중 높은 확률로 "goodbye"를 예측합니다.
• RNN 계층은 이전 단어 "you say"를 기억하여 다음 단어를 예측하는 데 중요한 역할을 합니다.
• RNN은 과거 데이터를 은닉 상태 벡터로 저장하고, 이를 통해 과거의 정보를 바탕으로 현재와 미래의 단어를 예측합니다.

 

Time 계층 구현

시계열 데이터를 한꺼번에 처리하는 계층을 Time RNN 이라는 이름의 계층으로 구현합니다.

• 이번에도 마찬가지로, 시계열 데이터를 한꺼번에 처리하는 계층을 Time Embedding, Time Affine 형태의 이름으로 구현하겠습니다.

시계열 데이터를 한꺼번에 처리하는 계층을 Time XX 계층으로 구현

T개분의 시계열 데이터를 처리하는 계층을 Time XX 계층 이라고 부르겠습니다.
이러한 계층들이 구현되어 있다면 그 계층들을 레고 블럭처럼 조립하는 것으로 시계열 데이터를 다루는 신경망을 완성할 수 있습니다.

• Time 계층은 간단하게 구현할 수 있습니다.
• Time Affine 계층은 아래의 그림처럼 Affine 계층을 T개 준비해서, 각 시각의 데이터를 개별적으로 처리합니다.

Time Affine 계층은 T개의 Affine 계층의 집합으로 구현됩니다.

• Time Embedding 계층 역시 Forward Propagation(순전파) 시에 T개의 Embedding 계층을 준비하고 각 Embedding 계층이 각 시각의 데이터를 처리합니다.
• Time Embedding 계층은 단순히 Affine 계층 T개를 이용하는 방식 대신 행렬 계산으로 한꺼번에 처리하는, 효율 좋은 방식으로 구현했습니다.

 

Time Affine Class Source Code (by Python)

import numpy as np

class TimeAffine:
    def __init__(self, W, b):
        """
        클래스 초기화 메서드.
        
        파라미터:
        W (numpy.ndarray): 가중치 행렬
        b (numpy.ndarray): 바이어스 벡터
        """
        self.params = [W, b]  # 가중치와 바이어스를 리스트로 저장
        self.grads = [np.zeros_like(W), np.zeros_like(b)]  # 가중치와 바이어스에 대한 그라디언트 초기화
        self.x = None  # 순전파 시 입력값을 저장할 변수

    def forward(self, x):
        """
        순전파 메서드.
        
        파라미터:
        x (numpy.ndarray): 입력 데이터. (배치 크기, 시퀀스 길이, 특성 차원)
        
        반환값:
        out (numpy.ndarray): 출력 데이터. (배치 크기, 시퀀스 길이, 출력 차원)
        """
        N, T, D = x.shape  # 입력 데이터의 형상 (배치 크기, 시퀀스 길이, 특성 차원)
        W, b = self.params  # 가중치와 바이어스
        
        rx = x.reshape(N*T, -1)  # 입력 데이터를 2차원으로 변환 (N*T, D)
        out = np.dot(rx, W) + b  # 선형 변환 수행
        self.x = x  # 입력 데이터를 저장하여 역전파 시 사용
        return out.reshape(N, T, -1)  # 출력 데이터를 원래 형상으로 변환하여 반환

    def backward(self, dout):
        """
        역전파 메서드.
        
        파라미터:
        dout (numpy.ndarray): 출력에 대한 그라디언트. (배치 크기, 시퀀스 길이, 출력 차원)
        
        반환값:
        dx (numpy.ndarray): 입력에 대한 그라디언트. (배치 크기, 시퀀스 길이, 특성 차원)
        """
        x = self.x  # 저장된 입력 데이터
        N, T, D = x.shape  # 입력 데이터의 형상
        W, b = self.params  # 가중치와 바이어스
        
        dout = dout.reshape(N*T, -1)  # 출력에 대한 그라디언트를 2차원으로 변환 (N*T, 출력 차원)
        rx = x.reshape(N*T, -1)  # 입력 데이터를 2차원으로 변환 (N*T, D)
        
        db = np.sum(dout, axis=0)  # 바이어스에 대한 그라디언트 계산
        dW = np.dot(rx.T, dout)  # 가중치에 대한 그라디언트 계산
        dx = np.dot(dout, W.T)  # 입력에 대한 그라디언트 계산
        dx = dx.reshape(*x.shape)  # 입력에 대한 그라디언트를 원래 형상으로 변환
        
        self.grads[0][...] = dW  # 가중치에 대한 그라디언트를 저장
        self.grads[1][...] = db  # 바이어스에 대한 그라디언트를 저장
        
        return dx  # 입력에 대한 그라디언트를 반환

• Time Affine 클래스의 코드를 한번 보겠습니다.
• __init__ 메서드:
  • Weight(가중치) W와 Bias(편향) b를 인자로 받아 초기화합니다.
  • Weight(가중치)와 Bias(편향)에 대한 Gradient(기울기)를 저장할 변수를 초기화합니다.
  • Forward Propagation(순전파)시 입력 데이터를 저장할 변수를 초기화합니다.
• forward 메서드:
  • 입력 데이터 x를 받아 Forward Propagation(순전파)를 수행합니다.
  • 입력 데이터의 형상 (N, T, D)을 구합니다.
  • 입력 데이터를 2차원 형태로 변환하여 (N*T, D)로 만듭니다.
  • Weight(가중치) W와 Bias(편향) b를 이용해 선형 변환을 수행합니다.
  • 변환된 출력을 원래의 3차원 형상으로 변환하여 반환합니다.
• backward 메서드:
  • 출력에 대한 Gradient(기울기) dout을 받아 Backpropagation(역전파)를 수행합니다.
  • 저장된 입력 데이터를 이용해 입력 데이터의 형상을 구합니다.
  • 출력에 대한 Gradient(기울기)를 2차원 형태로 변환합니다.
  • 입력 데이터를 2차원 형태로 변환합니다.
  • Bias(편향)에 대한 Gradient(기울기)를 계산합니다.
  • Weight(가중치)에 대한 Gradient(기울기)를 계산합니다.
  • 입력에 대한 Gradient(기울기)를 계산하고 원래의 3차원 형상으로 변환하여 반환합니다.

 

Time Softmax with Loss 계층

Softmax 계층을 구현할 때 손실 오차를 구하는 *Cross Entropy Error 계층도 구현합니다.

Time Softmax with Loss 계층의 전체 그림

*Cross Entropy Loss Function: 모델의 예측 확률 분포와 실제 레이블 사이의 차이를 측정하는 데 사용됩니다.
주어진 예측 확률 분포 𝑝와 실제 레이블 𝑞 사이의 Cross-Entropy는 다음과 같이 계산됩니다.
CrossEntropy(𝑝,𝑞)=−∑𝑖 𝑞𝑖 log⁡(𝑝𝑖)
여기서 𝑞𝑖는 실제 레이블의 𝑖번째 요소(일반적으로 원-핫 인코딩된 벡터), 𝑝𝑖는 예측 확률 분포의 𝑖i번째 요소입니다.

• 위의 그림에서 X0, X1등의 데이터는 아래층에서 전해지는 'Score(점수)'를 나타냅니다.
  • 'Score(점수)'는 확률로 정규화되기 전의 값입니다.
• 또한 t0, t1등의 데이터는 정답 레이블을 나타냅니다.
• 그림에서 보듯이, T개의 Softmax with Loss 계층이 각각의 Loss를 산출후, 합산해 평균낸 값이 최종 손실이 됩니다.
• 이때 수행하는 수식은 아래와 같습니다.

• 여기서 Softmax with Loss 계층은 Mini-Batch에 해당하는 Loss의 평균을 구했습니다.
• 데이터 N개 짜리 Mini-Batch는 N개의 손실을 더해 다시 N개로 나워서 데이터당 한개당 평균 손실을 구했습니다.
• 이와 마찬가지로 Time Softmax with Loss 계층도 시계열에 데한 평균을 구하는 것으로, 데이터 1개당 평균 Loss를 구해 최종 출력으로 내보냅니다.

---

RNNLM 학습 및 평가

한번 RNNLM을 한번 구현을 해보겠습니다. 계층 구성은 아래의 사진과 같습니다.

• 보면, 이렇게 RNNLM 클래스는 4개의 Time 계층을 쌓은 Neural Network(신경망)입니다. 한번 코드를 보겠습니다.

import sys
sys.path.append('..')
import numpy as np
from common.time_layers import *


class SimpleRnnlm:
    def __init__(self, vocab_size, wordvec_size, hidden_size):
        V, D, H = vocab_size, wordvec_size, hidden_size
        rn = np.random.randn

        # 가중치 초기화
        embed_W = (rn(V, D) / 100).astype('f')
        rnn_Wx = (rn(D, H) / np.sqrt(D)).astype('f')
        rnn_Wh = (rn(H, H) / np.sqrt(H)).astype('f')
        rnn_b = np.zeros(H).astype('f')
        affine_W = (rn(H, V) / np.sqrt(H)).astype('f')
        affine_b = np.zeros(V).astype('f')

        # 계층 생성
        self.layers = [
            TimeEmbedding(embed_W),
            TimeRNN(rnn_Wx, rnn_Wh, rnn_b, stateful=True),
            TimeAffine(affine_W, affine_b)
        ]
        self.loss_layer = TimeSoftmaxWithLoss()
        self.rnn_layer = self.layers[1]

        # 모든 가중치와 기울기를 리스트에 모은다.
        self.params, self.grads = [], []
        for layer in self.layers:
            self.params += layer.params
            self.grads += layer.grads

    def forward(self, xs, ts):
        for layer in self.layers:
            xs = layer.forward(xs)
        loss = self.loss_layer.forward(xs, ts)
        return loss

    def backward(self, dout=1):
        dout = self.loss_layer.backward(dout)
        for layer in reversed(self.layers):
            dout = layer.backward(dout)
        return dout

    def reset_state(self):
        self.rnn_layer.reset_state()

• 이 코드는 각 계층에서 사용하는 Parameter (Weight-가중치 & Bias-편향)을 초기화 하고 필요한 계층을 생성합니다.
• 또한 *Truncated BPTT(Backpropagation Through Time)로 학습한다고 가정해서 Time RNN 계층의 stateful을 True로 설정했습니다.
• 그 결과 Time RNN은 이전 시각의 Hidden State(은닉 상태)를 계승할 수 있습니다.
• 또한 특징은 RNN & Affine 계층에서 Xavier 초기값을 이용했습니다.

*Xavier 초기값: 이전 계층의 node가 n개라면 표준편차가 1/√n인 분포로 초기화합니다.

Xavier 초깃값: 이전 계층의 노드가 n개라면 표준편차가 1/ √n인 분포를 초기값으로 사용

RNN에서 Weight의 초깃값은 어떻게 설정하느냐에 따라 학습이 진행되는 방법 & 최종 정확도가 크게 달라집니다.

• 계속해서 forward(), backward(), reset_state() Method의 구현을 보겠습니다.

def forward(self, xs, ts):
    """
    순전파 메서드.
    
    파라미터:
    xs (numpy.ndarray): 입력 데이터
    ts (numpy.ndarray): 실제 레이블
    
    반환값:
    loss (float): 계산된 손실 값
    """
    for layer in self.layers:
        xs = layer.forward(xs)  # 각 레이어에 대해 순전파 수행
    loss = self.loss_layer.forward(xs, ts)  # 손실 레이어에서 손실 계산
    return loss  # 계산된 손실 값 반환

def backward(self, dout=1):
    """
    역전파 메서드.
    
    파라미터:
    dout (float): 상위 계층에서 전파된 그라디언트 (기본값: 1)
    
    반환값:
    dout (numpy.ndarray): 입력 데이터에 대한 그라디언트
    """
    dout = self.loss_layer.backward(dout)  # 손실 레이어에서 역전파 수행
    for layer in reversed(self.layers):
        dout = layer.backward(dout)  # 각 레이어에 대해 역전파 수행
    return dout  # 입력 데이터에 대한 그라디언트 반환

def reset_state(self):
    """
    상태 초기화 메서드.
    
    순환 신경망(RNN) 레이어의 상태를 초기화합니다.
    """
    self.rnn_layer.reset_state()  # RNN 레이어의 상태 초기화

---

Language Model(언어모델)의 평가 - Perplexity

Language Model(언어 모델)은 주어진 과거단어(정보)로 부터 다음에 출현한 단어의 확률분포를 출력합니다. 이때, Language Model(언어 모델)의 예측 성능을 평가하는 척도로 Perplexity(퍼플렉시티-혼란도)를 자주 이용합니다.

• Perplexity(퍼플렉시티)는 간단히 말하면 '확률의 역수'입니다. 이 내용의 해석은 데이터가 하나일때 정확히 일치합니다.
• 예를 들어서 "you say goodbye and i say hello"라는 Corpus(말뭉치)로 예를 들면 "you"라는 단어 다음에 출력할 단어가 "say'라고 하면, 확률은 0.8입니다.
• 이때 Perplexity(퍼플렉시티-혼란도)는 확률의 역수, 즉 1/0.8 = 1.25 로 볼 수 있습니다.
• 모델 2에서 "정답인 "say"의 확률이 0.2라고 하면, 1/0.2 = 5 로 볼 수 있습니다.
• 그리고 Perplexity(퍼플렉시티-혼란도)는 작을수록 좋다는 것을 알 수 있습니다.

• 그렇다면 1.25나 5.0이라는 값은 직관적으로는 어떻게 해석할 수 있을까요?
• 이 값은 '분기 수(number of branches)'로 해석할 수 있습니다.
• 분기 수란 다음에 취할 수 있는 선택사항의 수(구체적으로 말하면, 다음에 출현할 수 있는 단어의 후보 수)를 말합니다.
• 앞의 예에서, 좋은 모델이 예측한 '분기 수'가 1.25라는 것은 다음에 출현할 수 있는 단어의 후보를 1개 정도로 좁혔다는 뜻이 되고, 반면 나쁜 모델에서는 후보가 아직 5개나 된다는 의미입니다.

예처럼 Perplexity(퍼플렉시티)로 모델의 예측 성능을 평가할 수 있습니다. 좋은 모델은 정답 단어를 높은 확률로 예측할 수 있습니다.
따라서 Perplexity(퍼플렉시티) 값이 작아집니다.(최소값은 1.0). 한편, 나쁜 모델은 정답 단어를 낮은 확률로 예측하므로 Perplexity(퍼플렉시티) 값이 큽니다.

• 입력 데이터가 하나일 때의 Perplexity(퍼플렉시티)를 이야기했습니다.
• 그렇다면 입력 데이터가 여러 개일 때는 어떻게 될까요? 이럴 때는 아래의 공식에 따라 계산합니다.

L = −1/N ​∑n​∑k ​tnk ​log y nk​, perplexity = 𝑒𝐿

• N은 데이터의 총개수입니다. 𝑡𝑛​은 One-Hot Vector 로 나타낸 정답 레이블이며, 𝑡𝑛𝑘t는 n개째 데이터의 k번째 값을 의미합니다.
• 그리고 𝑦𝑛𝑘는 확률 분포를 나타냅니다.(Neural Network-신경망 에서는 Softmax의 출력). L은 Neural Network(신경망)의 Loss을 뜻하며, Cross-Entropy-Error(교차 엔트로피 오차)와 완전히 같은 식입니다. 이 L을 사용해 𝑒−𝐿 를 계산한 값이 곧 Perplexity(퍼플렉시티입니다.

---

RNNLM의 Code (by Python)

PTB 데이터셋을 이용해서 RNNLM 학습을 수행해 보겠습니다.

• 단 모든 데이터셋을 이용해서 학습을 하게 되면, 좋은 결과가 안나올수도 있기 때문에, 1000개의 단어만 이용해 보겠습니다.

# coding: utf-8
import sys
sys.path.append('..')
import matplotlib.pyplot as plt
import numpy as np
from common.optimizer import SGD
from dataset import ptb
from simple_rnnlm import SimpleRnnlm


# 하이퍼파라미터 설정
batch_size = 10
wordvec_size = 100
hidden_size = 100 # RNN의 은닉 상태 벡터의 원소 수
time_size = 5     # Truncated BPTT가 한 번에 펼치는 시간 크기
lr = 0.1
max_epoch = 100

# 학습 데이터 읽기(전체 중 1000개만)
corpus, word_to_id, id_to_word = ptb.load_data('train')
corpus_size = 1000
corpus = corpus[:corpus_size]
vocab_size = int(max(corpus) + 1)

xs = corpus[:-1]  # 입력
ts = corpus[1:]   # 출력(정답 레이블)
data_size = len(xs)
print('말뭉치 크기: %d, 어휘 수: %d' % (corpus_size, vocab_size))

# 학습 시 사용하는 변수
max_iters = data_size // (batch_size * time_size)
time_idx = 0
total_loss = 0
loss_count = 0
ppl_list = []

# 모델 생성
model = SimpleRnnlm(vocab_size, wordvec_size, hidden_size)
optimizer = SGD(lr)

# 1. 미니배치의 각 샘플의 읽기 시작 위치를 계산
jump = (corpus_size - 1) // batch_size
offsets = [i * jump for i in range(batch_size)]

for epoch in range(max_epoch):
    for iter in range(max_iters):
        # 2. 미니배치 취득
        batch_x = np.empty((batch_size, time_size), dtype='i')
        batch_t = np.empty((batch_size, time_size), dtype='i')
        for t in range(time_size):
            for i, offset in enumerate(offsets):
                batch_x[i, t] = xs[(offset + time_idx) % data_size]
                batch_t[i, t] = ts[(offset + time_idx) % data_size]
            time_idx += 1

        # 기울기를 구하여 매개변수 갱신
        loss = model.forward(batch_x, batch_t)
        model.backward()
        optimizer.update(model.params, model.grads)
        total_loss += loss
        loss_count += 1

    # 3. 에폭마다 퍼플렉서티 평가
    ppl = np.exp(total_loss / loss_count)
    print('| 에폭 %d | 퍼플렉서티 %.2f'
          % (epoch+1, ppl))
    ppl_list.append(float(ppl))
    total_loss, loss_count = 0, 0

• 이 코드는 학습을 수행하는 코드입니다. 우리가 일반적으로 본 Neural Network(신경망) 학습과 거이 비슷합니다.
• 다만 큰 관점에서 '데이터 제공 방법', 'Perplexity 계산' 부분을 보면서 코드를 한번 보겠습니다.

 

데이터 제공 방법

데이터 제공 방법에서 여기선 Truncated BPTT 방식으로 학습을 수행합니다.
Truncated BPTT 방식에 데한 개념은 아래에 링크 달아놓을께요!

[NLP] BPTT (Backpropagation Through Time)

• Truncated BPTT 방식에서는 데이터를 순차적으로 주고, 각각의 Mini-Batch에서 데이터를 읽는 시작 위치를 조정해야 합니다.
• 전체 학습 코드 1번 부분에서 각 Mini-Batch에서 데이터를 읽는 시작 위치를 offset에 저장합니다.

# 1. 미니배치의 각 샘플의 읽기 시작 위치를 계산
jump = (corpus_size - 1) // batch_size
offsets = [i * jump for i in range(batch_size)]

 

• 전체 학습 코드 2번 부분에서는 데이터를 순차적으로 읽습니다.
• 그릇의 역할을 하는 batch_x, batch_t를 준비하고, time_idx를 1씩 늘리면서 Corpus(말뭉치)에서 time_idx위치의 데이터를 얻습니다.
• 여기서 1번 소스 코드에서 계산한 offset을 이용하여 각 mini_batch에서 offset을 추가합니다.
• 그리고, 만약 Corpus(말뭉치)를 읽는 위치가 Corpus(말뭉치) 크기를 넘어설 경우에 Corpus(말뭉치)의 처음으로 돌아와야 하는데, 이를 위해서 Corpus(말뭉치)의 크기로 나눈 나머지를 Index로 사용합니다.

        # 2. 미니배치 취득
        batch_x = np.empty((batch_size, time_size), dtype='i')
        batch_t = np.empty((batch_size, time_size), dtype='i')
        for t in range(time_size):
            for i, offset in enumerate(offsets):
                batch_x[i, t] = xs[(offset + time_idx) % data_size]
                batch_t[i, t] = ts[(offset + time_idx) % data_size]
            time_idx += 1

 

• 3번 코드 부분에서는 *Perplexity(퍼플렉시티)를 계산합니다.
• 여기서는 Epoch마다 Perplexity(퍼플렉시티)를 구하기 위해서 Epoch마다 Loss의 평균을 구하고, 구한 값을 이용해서 Perplexity(퍼플렉시티)를 구합니다.

Language Model(언어 모델)은 주어진 과거단어(정보)로 부터 다음에 출현한 단어의 확률분포를 출력합니다.
이때, Language Model(언어 모델)의 예측 성능을 평가하는 척도로 Perplexity(퍼플렉시티-혼란도)를 자주 이용합니다.

    # 3. 에폭마다 퍼플렉서티 평가
    ppl = np.exp(total_loss / loss_count)
    print('| 에폭 %d | 퍼플렉서티 %.2f'
          % (epoch+1, ppl))
    ppl_list.append(float(ppl))
    total_loss, loss_count = 0, 0

Perplexity (퍼플렉시티) 추이

---

RNNLM의 Trainer Class

이번에는 RNNLM을 수행해주는 Trainer 클래스를 한번 보겠습니다.

• 이 부분은 RNNLM을 수행하는 학습부분은 클래스 안으로 숨겨주는 역할을 합니다. 한번 코드를 보겠습니다.

import sys
sys.path.append('..')
from common.optimizer import SGD
from common.trainer import RnnlmTrainer
from dataset import ptb
from simple_rnnlm import SimpleRnnlm


# 하이퍼파라미터 설정
batch_size = 10
wordvec_size = 100
hidden_size = 100  # RNN의 은닉 상태 벡터의 원소 수
time_size = 5  # RNN을 펼치는 크기
lr = 0.1
max_epoch = 100

# 학습 데이터 읽기
corpus, word_to_id, id_to_word = ptb.load_data('train')
corpus_size = 1000  # 테스트 데이터셋을 작게 설정
corpus = corpus[:corpus_size]
vocab_size = int(max(corpus) + 1)
xs = corpus[:-1]  # 입력
ts = corpus[1:]  # 출력（정답 레이블）

# 모델 생성
model = SimpleRnnlm(vocab_size, wordvec_size, hidden_size)
optimizer = SGD(lr)
trainer = RnnlmTrainer(model, optimizer)

trainer.fit(xs, ts, max_epoch, batch_size, time_size)
trainer.plot()

 

• 이와 같이, 먼저 RnnlmTrainer 클래스에 model과 optimizer를 주어 초기화합니다. 그런 다음 fit() 메서드를 호출해 학습을 수행합니다.
• 이때 그 내부에서는 앞 절에서 수행한 일련의 작업이 진행되는데, 그 내용을 상세히 적어보면 다음과 같습니다.
  
  • Mini-Batch를 '순차적'으로 만들어
  • 모델의 Forward Propagation(순전파)와 Backpropagation(역전파)를 호출하고
  • Optimizer(옵티마이저)로 Weight(가중치)를 갱신하고
  • Perplexity(퍼플렉서티)를 구합니다.

NOTE. RnnlmTrainer 클래스는 앞에서 설명한 Trainer 클래스와 똑같은 API를 제공합니다.
신경망의 일반적인 학습은 Trainer 클래스를 사용하고, RNNLM 학습에는 RnnlmTrainer 클래스를 사용하면 됩니다.

---

Summary

Language Model(언어 모델)은 단어 Sequence를 확률로 해석한다.
RNN 계층을 이용한 조건부 Language Model(언어 모델)은 (이론적으로는) 그때까지 등장한 모든 단어의 정보를 기억할 수 있다.