순환 신경망(Recurrent Neural Network) 구현

파이토치를 이용하여 순환 신경망(Recurrent Neural Network)를 구현할 것이다. 구현 과정은 다음과 같다.

 

1. 데이터 전처리

2. 모델 설정

3. 모델 학습

4. 학습 결과

 

1. 데이터 전처리

 

In:

import torch
import torch.nn as nn
import torch.optim as optim
import numpy as np

string = "To climb steep hills requires a slow pace at first."

chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz ?!.,:;'01"
char_list = [i for i in chars]

n_letter = len(chars)

def string_to_onehot(string):
    start = np.zeros(shape = len(char_list), dtype = int)
    end = np.zeros(shape = len(char_list), dtype = int)
    
    start[-2] = 1
    end[-1] = 1
    
    for i in string:
        idx = char_list.index(i)
        
        zero = np.zeros(shape = n_letter, dtype = int)
        zero[idx] = 1
        
        start = np.vstack([start, zero])
        
    output = np.vstack([start, end])
    
    return(output)

def onehot_to_word(onehot):
    onehot_ = torch.Tensor.numpy(onehot)
    
    return char_list[onehot_.argmax()]

 

▷ 학습에 이용될 문장은 "To climb steep hills requires a slow pace at first."로 RNN을 통해 이를 학습한 뒤, 예측할 것이다.

 

▷ 모델이 문장을 인식할 수 있도록 원핫 인코딩을 하였다. char_list는 문장에서 나올 수 있는 모든 글자의 경우로, 각 글자의 해당 위치에 1 또는 0으로 바꿀 수 있는 기준을 제시한다. 예를 들어, 글자 B는 char_list의 두 번째 위치에 해당하므로 원핫 인코딩의 결과는 [0, 1, ... , 0]가 된다.

 

▷ string_to_onehot 함수는 문장을 입력 받아서 원핫 인코딩된 결과를 출력한다.

 

▷ onehot_to_word 함수는 원핫 인코딩된 결과를 다시 원래의 문장으로 만들어 출력한다.

 

2. 모델 설정

 

In:

class RNN(nn.Module):
    def __init__(self, input_size, hidden_size, output_size):
        super(RNN, self).__init__()
        
        self.input_size = input_size
        self.hidden_size = hidden_size
        self.output_size = output_size
        
        self.ih = nn.Linear(input_size, hidden_size)
        self.hh = nn.Linear(hidden_size, hidden_size)
        self.io = nn.Linear(hidden_size, output_size)
        self.act_fn = nn.Tanh()
        
    def forward(self, input, hidden):
        hidden = self.act_fn(self.ih(input) + self.hh(hidden))
        output = self.io(hidden)
        
        return output, hidden
    
    def init_hidden(self):
        return torch.zeros(1, self.hidden_size)
 
epochs = 1000
n_hidden = 50
learning_rate = 0.01

rnn = RNN(n_letter, n_hidden, n_letter)

loss_func = nn.MSELoss()
optimizer = torch.optim.Adam(rnn.parameters(), lr = learning_rate)

 

▷ RNN은 인풋, 히든, 아웃풋 레이어로 구성된다. 각 레이어에서의 결과가 전달될 때, 세 가지 파라미터로 조절하게 된다.  인풋 레이어에서 히든 레이어로, 히든 레이어에서 히든 레이어로, 히든 레이어에서 아웃풋 레이어로 전달될 때이다. RNN 클래스 내부의 __init__ 함수는 이를 구현해 놓은 결과이다.

 

▷ 활성화 함수는 하이퍼볼릭 탄젠트로 설정하였다.

 

▷ init_hidden 함수는 초기 히든 레이어 생성하기 위한 것이다.

 

▷ 에폭, 히든 레이어의 수와 학습률을 epochs, n_hidden, learning_rate를 통해 설정한 뒤, RNN 함수를 이용하여 RNN의 구조를 생성하였다.

 

▷ 모델의 손실 함수는 MSE로, 최적화에는 Adam 알고리즘으로 설정하였다.

 

3. 모델 학습

 

In:

one_hot = torch.from_numpy(string_to_onehot(string)).type_as(torch.FloatTensor())

for i in range(epochs):
    rnn.zero_grad()
    total_loss = 0
    hidden = rnn.init_hidden()
    
    for j in range(one_hot.size()[0]-1):
        input_char = one_hot[j:j+1,:]
        target = one_hot[j+1]
        
        output, hidden = rnn.forward(input_char, hidden)
        loss = loss_func(output.view(-1), target.view(-1))
        total_loss += loss
        
    total_loss.backward()
    optimizer.step()
    
    if i % 10 == 0:
        print(total_loss)

 

Out:

tensor(1.6622, grad_fn=<AddBackward0>)
tensor(0.5862, grad_fn=<AddBackward0>)
tensor(0.3629, grad_fn=<AddBackward0>)
tensor(0.2178, grad_fn=<AddBackward0>)
tensor(0.1408, grad_fn=<AddBackward0>)
tensor(0.0931, grad_fn=<AddBackward0>)
tensor(0.0806, grad_fn=<AddBackward0>)
tensor(0.0560, grad_fn=<AddBackward0>)
tensor(0.0423, grad_fn=<AddBackward0>)
tensor(0.0358, grad_fn=<AddBackward0>)
tensor(0.0256, grad_fn=<AddBackward0>)
tensor(0.0201, grad_fn=<AddBackward0>)
tensor(0.0204, grad_fn=<AddBackward0>)
tensor(0.0149, grad_fn=<AddBackward0>)
tensor(0.0115, grad_fn=<AddBackward0>)
tensor(0.0093, grad_fn=<AddBackward0>)
tensor(0.0079, grad_fn=<AddBackward0>)
tensor(0.0092, grad_fn=<AddBackward0>)
tensor(0.0072, grad_fn=<AddBackward0>)
tensor(0.0058, grad_fn=<AddBackward0>)
tensor(0.0082, grad_fn=<AddBackward0>)
tensor(0.0051, grad_fn=<AddBackward0>)
tensor(0.0043, grad_fn=<AddBackward0>)
tensor(0.0035, grad_fn=<AddBackward0>)
tensor(0.0031, grad_fn=<AddBackward0>)
tensor(0.0027, grad_fn=<AddBackward0>)
tensor(0.0033, grad_fn=<AddBackward0>)
tensor(0.0053, grad_fn=<AddBackward0>)
tensor(0.0027, grad_fn=<AddBackward0>)
tensor(0.0022, grad_fn=<AddBackward0>)
tensor(0.0019, grad_fn=<AddBackward0>)
tensor(0.0017, grad_fn=<AddBackward0>)
tensor(0.0015, grad_fn=<AddBackward0>)
tensor(0.0014, grad_fn=<AddBackward0>)
tensor(0.0013, grad_fn=<AddBackward0>)
tensor(0.0016, grad_fn=<AddBackward0>)
tensor(0.0041, grad_fn=<AddBackward0>)
tensor(0.0020, grad_fn=<AddBackward0>)
tensor(0.0014, grad_fn=<AddBackward0>)
tensor(0.0011, grad_fn=<AddBackward0>)
tensor(0.0010, grad_fn=<AddBackward0>)
tensor(0.0009, grad_fn=<AddBackward0>)
tensor(0.0008, grad_fn=<AddBackward0>)
tensor(0.0008, grad_fn=<AddBackward0>)
tensor(0.0007, grad_fn=<AddBackward0>)
tensor(0.0025, grad_fn=<AddBackward0>)
tensor(0.0020, grad_fn=<AddBackward0>)
tensor(0.0012, grad_fn=<AddBackward0>)
tensor(0.0013, grad_fn=<AddBackward0>)
tensor(0.0007, grad_fn=<AddBackward0>)
tensor(0.0006, grad_fn=<AddBackward0>)
tensor(0.0005, grad_fn=<AddBackward0>)
tensor(0.0005, grad_fn=<AddBackward0>)
tensor(0.0004, grad_fn=<AddBackward0>)
tensor(0.0004, grad_fn=<AddBackward0>)
tensor(0.0004, grad_fn=<AddBackward0>)
tensor(0.0004, grad_fn=<AddBackward0>)
tensor(0.0011, grad_fn=<AddBackward0>)
tensor(0.0013, grad_fn=<AddBackward0>)
tensor(0.0006, grad_fn=<AddBackward0>)
tensor(0.0004, grad_fn=<AddBackward0>)
tensor(0.0003, grad_fn=<AddBackward0>)
tensor(0.0003, grad_fn=<AddBackward0>)
tensor(0.0003, grad_fn=<AddBackward0>)
tensor(0.0003, grad_fn=<AddBackward0>)
tensor(0.0002, grad_fn=<AddBackward0>)
tensor(0.0002, grad_fn=<AddBackward0>)
tensor(0.0029, grad_fn=<AddBackward0>)
tensor(0.0006, grad_fn=<AddBackward0>)
tensor(0.0004, grad_fn=<AddBackward0>)
tensor(0.0022, grad_fn=<AddBackward0>)
tensor(0.0004, grad_fn=<AddBackward0>)
tensor(0.0002, grad_fn=<AddBackward0>)
tensor(0.0002, grad_fn=<AddBackward0>)
tensor(0.0002, grad_fn=<AddBackward0>)
tensor(0.0002, grad_fn=<AddBackward0>)
tensor(0.0005, grad_fn=<AddBackward0>)
tensor(0.0004, grad_fn=<AddBackward0>)
tensor(0.0003, grad_fn=<AddBackward0>)
tensor(0.0002, grad_fn=<AddBackward0>)
tensor(0.0002, grad_fn=<AddBackward0>)
tensor(0.0001, grad_fn=<AddBackward0>)
tensor(0.0002, grad_fn=<AddBackward0>)
tensor(0.0024, grad_fn=<AddBackward0>)
tensor(0.0004, grad_fn=<AddBackward0>)
tensor(0.0003, grad_fn=<AddBackward0>)
tensor(0.0002, grad_fn=<AddBackward0>)
tensor(0.0001, grad_fn=<AddBackward0>)
tensor(0.0001, grad_fn=<AddBackward0>)
tensor(0.0001, grad_fn=<AddBackward0>)
tensor(0.0001, grad_fn=<AddBackward0>)
tensor(9.7875e-05, grad_fn=<AddBackward0>)
tensor(0.0001, grad_fn=<AddBackward0>)
tensor(0.0025, grad_fn=<AddBackward0>)
tensor(0.0004, grad_fn=<AddBackward0>)
tensor(0.0002, grad_fn=<AddBackward0>)
tensor(0.0001, grad_fn=<AddBackward0>)
tensor(9.9047e-05, grad_fn=<AddBackward0>)
tensor(8.2265e-05, grad_fn=<AddBackward0>)
tensor(7.6619e-05, grad_fn=<AddBackward0>)

 

▷ one_hot은 학습 데이터를 원핫 인코딩으로 바꾼 후, 학습할 수 있도록 텐서의 형태로 바꾸어 놓은 것이다.

 

▷ for i in range(epochs) 문 이하는 모델을 학습하기 위한 코드이고, 모델의 학습 결과가 에폭이 매 10회 지날 떄마다 출력하도록 구현하였다.

 

▷ 학습 문장의 길이가 짧아, MSE가 0에 수렴하는 것을 확인할 수 있다.

 

4. 학습 결과

 

In:

start = torch.zeros(1, len(char_list))
start[:, -2] = 1

with torch.no_grad():
    hidden = rnn.init_hidden()
    input_char = start
    output_string = ""
    
    for i in range(len(string)):
        output, hidden = rnn.forward(input_char, hidden)
        output_string += onehot_to_word(output.data)
        input_char = output
        
print(output_string)

 

Out:

To climb steep hills ples ereerereareirii1i pilim

 

▷ 모델의 결과를 확인하기 위해 문장의 첫 시작을 나타내는 [0, ..., 1, 0]을 입력값으로 주었다.

 

▷ rnn.init_hidden 함수를 이용하여 초기 히든 레이어를 생성하고, 입력값과 히든 레이어를 rnn.forward 함수에 인자로 주어 출력값과 히든 레이어를 얻는다. 이 출력값과 히든 레이어는 다음 출력값을 얻기 위한 rnn.forward 함수의 인자로 사용되고, 이러한 과정을 기존 학습 문장의 길이만큼 실시하여 모델의 결과를 얻는다.

 

▷ 단순한  버전인 만큼 만족스러운 결과는 아니지만, 원래 문장과 비슷한 형태를 얻을 수 있다.

 

---

Reference:

최건호, 「파이토치 첫걸음」, 한빛미디어(2019)