LSTM(Long Short-Term Memories model) 구현

파이토치를 이용하여 LSTM(Long Short-Term Memories model)을 구현할 것이다. 사용될 데이터는 아마존의 주가로 종가와 거래량을 이용하여, 일주일 뒤의 종가를 예측하는 것이 목적이다. 데이터는 여기(www.kaggle.com/camnugent/sandp500)에서 얻을 수 있다.

 

데이터구현 과정은 다음과 같다.

 

1. 데이터 전처리

2. 모델 설정

3. 모델 학습

4. 학습 결과

 

1. 데이터 전처리

 

In:

import pandas as pd
from numpy import array
from numpy import hstack
import matplotlib.pyplot as plt
import torch

def min_max_scaler(arr):
    min_arr = min(arr)
    max_arr = max(arr)
    
    return (arr-min_arr)/(max_arr-min_arr), min_arr, max_arr

def split_seq(seq, n_step):
    X, y = list(), list()
    
    for i in range(len(seq)):
        end_idx = i+n_step
        
        if end_idx > len(seq):
            break
            
        seq_x, seq_y = seq[i:end_idx, :-1], seq[end_idx-1, -1]
        
        X.append(seq_x)
        y.append(seq_y)
        
    return array(X), array(y)

 

▷ min_max_scaler 함수는 변수의 스케일을 가장 큰 값은 1로 가장 작은 값은 0으로 변환하여 준다.

 

▷ split_seq 함수는 데이터의 크기를 n_step 변수만큼 잘라준다.

 

In:

data_stock = pd.read_csv('../input/all_stocks_5yr.csv')

in_seq_p = array(data_stock.loc[data_stock['Name'] == 'AMZN', 'close'])
in_seq_v = array(data_stock.loc[data_stock['Name'] == 'AMZN', 'volume'])

pred_day = 7

out_seq = array([in_seq_p[i-1] for i in range(pred_day, len(in_seq_p))])
in_seq_p = in_seq_p[:-pred_day]
in_seq_v = in_seq_v[:-pred_day]

out_seq, min_out, max_out = min_max_scaler(out_seq)
in_seq_p, min_p, max_p = min_max_scaler(in_seq_p)
in_seq_v, min_v, max_v = min_max_scaler(in_seq_v)

in_seq_p = in_seq_p.reshape(len(in_seq_p), 1)
in_seq_v = in_seq_v.reshape(len(in_seq_p), 1)
out_seq = out_seq.reshape(len(out_seq), 1)

dataset = hstack((in_seq_p, in_seq_v, out_seq))

seq_len = 7

X, y = split_seq(dataset, seq_len)

 

▷ S&P 500의 주식 데이터를 불러온 후, 아마존 주식의 종가와 거개량만 뽑아서 in_seq_p, in_seq_v 변수에 할당한다.

 

▷ pred_day 변수에 예측 날짜를 할당하고, 일주일 뒤의 종가의 데이터만 뽑아서 out_seq 변수에 할당한다.

 

▷ out_seq, in_seq_p, in_seq_v 변수의 스케일을 min_max_scaler를 이용하여 0과 1사이로 맞춘다.

 

▷ hstack 함수를 이용하여 세 변수를 하나로 합친 뒤, dataset 변수에 할당한다.

 

▷ 마지막으로 split_seq 함수를 이용하여 dataset을 입력값과 출력값으로 나눈 뒤, 각 값을 시퀀스의 길이로 끊어준다.

 

2. 모델 설정

 

In:

class MV_LSTM(torch.nn.Module):
    def __init__(self, n_feat, seq_len):
        super(MV_LSTM, self).__init__()
        
        self.n_feat = n_feat
        self.seq_len = seq_len
        self.n_hidden = 50
        self.n_layer = 5
        
        self.l_lstm = torch.nn.LSTM(input_size = n_feat, 
                                   hidden_size = self.n_hidden, 
                                   num_layers = self.n_layer, 
                                   batch_first = True)
        
        self.l_linear = torch.nn.Linear(self.n_hidden*self.seq_len, 1)
        
    def init_hidden(self, batch_size):
        hidden_state = torch.zeros(self.n_layer, batch_size, self.n_hidden)
        cell_state = torch.zeros(self.n_layer, batch_size, self.n_hidden)
        self.hidden = (hidden_state, cell_state)
        
    def forward(self, X):
        batch_size, seq_len, _ = X.size()
        
        lstm_out, self.hidden = self.l_lstm(X, self.hidden)
        
        X = lstm_out.contiguous().view(batch_size, -1)
        
        return self.l_linear(X)

 

▷ torch.nn.LSTM 함수를 이용하여, LSTM의 구조를 세팅한다. 이때, batch_first 인자를 True로 설정하여, 배치 단위의 학습을 먼저할 수 있도록 지정해주었다.

 

▷ torch.nn.Linear 함수를 이용하여, 결과값의 크기를 1로 설정하였다.

 

▷ init_hidden 함수를 이용하여, 첫 학습시의 히든 스테이를 만들어 준다.

 

▷ forward 함수에서 학습 진행 방향을 설정한다.

 

3. 모델 학습

 

In:

n_feat = 2
seq_len = 7

mv_lstm = MV_LSTM(n_feat, seq_len)
loss_fun = torch.nn.MSELoss()
optim = torch.optim.Adam(mv_lstm.parameters(), lr = 1e-3)

epoch = 500
batch_size = int(len(dataset)/5)

mv_lstm.train()

for t in range(epoch):
    batch_loss = 0
    
    for b in range(0, len(X), batch_size):
        input_ = X[b:b+batch_size, :, :]
        target = y[b:b+batch_size]
        
        X_batch = torch.tensor(input_, dtype = torch.float32)
        y_batch = torch.tensor(target, dtype = torch.float32)
        
        mv_lstm.init_hidden(X_batch.size(0))
        output = mv_lstm(X_batch)
        loss = loss_fun(output.view(-1), y_batch)
        
        loss.backward()
        optim.step()
        optim.zero_grad()
        
        batch_loss += loss.item()
    
    if t%10 == 0:
        print('Step:', t, 'Loss:', batch_loss)

 

Out:

Step: 0 Loss: 0.49312681483570486
Step: 10 Loss: 0.276709976606071
Step: 20 Loss: 0.03958324994891882
Step: 30 Loss: 0.011060289776651189
Step: 40 Loss: 0.008034420054173097
Step: 50 Loss: 0.010796168557135388
Step: 60 Loss: 0.00563392968615517
Step: 70 Loss: 0.006591864308575168
Step: 80 Loss: 0.008238963724579662
Step: 90 Loss: 0.004256958898622543
Step: 100 Loss: 0.0048738375917309895
Step: 110 Loss: 0.0047946782724466175
Step: 120 Loss: 0.003956006024964154
Step: 130 Loss: 0.006989476649323478
Step: 140 Loss: 0.00544810012797825
Step: 150 Loss: 0.0037749825860373676
Step: 160 Loss: 0.004278417211025953
Step: 170 Loss: 0.010671858908608556
Step: 180 Loss: 0.0039105534087866545
Step: 190 Loss: 0.0036512921506073326

 

▷ 학습 시, 배치 크기를 지정한 뒤, 각 에폭에서 모든 배치에 대한 학습을 진행하도록 구현하였다.

 

▷ 학습 결과, 각 에폭에서의 오차가 줄어들고 있는 것을 확인할 수 있다.

 

4. 학습 결과

 

In:

pred_y = list()

with torch.no_grad():
    for b in range(0, len(X), batch_size):
        input_ = X[b:b+batch_size, :, :]
        target = y[b:b+batch_size]
        
        X_batch = torch.tensor(input_, dtype = torch.float32)
        y_batch = torch.tensor(target, dtype = torch.float32)
        
        mv_lstm.init_hidden(X_batch.size(0))
        output = mv_lstm(X_batch)
        
        for i in output.tolist():
            pred_y.append(i[0])

pred_y = array(pred_y)

plt.figure()

plt.plot(pred_y)
plt.plot(y)

plt.show()

 

Out:

 

▷ 파란색 선이 실제 아마존의 종가이고, 주황색 선이 일주일 전 예측된 종가이다. 그래프에서 보다시피 학습이 잘 된 것을 알 수 있다.