【ディープラーニングの基本】RNN,LSTMの特徴を簡単に説明｜Pytorchでサンプル実装

import numpy as np
import matplotlib.pyplot as plt
import torch
from torch.utils.data import DataLoader
import torch.nn as nn
import torch.nn.functional as F
from torch import optim

# コサイン関数にノイズを与える
cos_x = np.linspace(0, 4*np.pi, 120) 
cos_y = np.cos(cos_x)  + np.random.randn(len(cos_x)) * 0.3

# データの表示
plt.plot(cos_x, cos_y)
plt.show()

# データを利用できる形に変更
# 与えるデータ数
origin_data_num = 30
# 予測していくデータ数
prd_data_num = len(cos_y) - origin_data_num

# 入力データの用意：予測していくデータ数だけ、与えるデータを用意
input_data = np.zeros((prd_data_num, origin_data_num, 1)) 
# 正解データ：予測していくデータの数用意
correct_data = np.zeros((prd_data_num, 1))

for i in range(prd_data_num):
    input_data[i] = cos_y[i : i + origin_data_num].reshape(-1, 1)
    # 正解データは１つ次のデータ
    correct_data[i] = cos_y[i + origin_data_num : i + origin_data_num + 1]
    
# PyTorchで使用する形に変更
input_data = torch.tensor(input_data, dtype=torch.float)
correct_data = torch.tensor(correct_data, dtype=torch.float)

# DataLoaderでバッチに合わせて取得
dataset = torch.utils.data.TensorDataset(input_data, correct_data)
train_loader = DataLoader(dataset, batch_size=8, shuffle=True) 

# モデルの作成
class Model(nn.Module):
    def __init__(self, input_size, hidden_size):
        # 親クラスのコンストラクタ
        super().__init__()
        
        # RNN
        self.rnn = nn.RNN(
            input_size= input_size,  # 入力サイズ
            hidden_size= hidden_size,  # ニューロン数
            batch_first=True,  # 入力をバッチサイズ, 与えるデータの数, 入力の数にする
        )
        self.output = nn.Linear(hidden_size, 1)
        
    def forward(self, x, h=None):
        # output : 全ての時刻の出力
        # hn : 次の時刻に渡される値
        output, hn = self.rnn(x, h)
        # y : 最後の時刻の出力
        y = self.output(output[:, -1, :])  
        return y
        
model = Model(1, 64)

# 交差エントロピー誤差関数
loss_fnc = nn.MSELoss()

# 最適化アルゴリズム
optimizer = optim.SGD(model.parameters(), lr=0.01)  # 学習率は0.01

# 表示領域、配置領域の確保
fig, axs = plt.subplots(2,5, figsize=(15.0, 5.0))

# 学習:エポックの数ループ
for i in range(1000):  # 50エポック学習
    # 訓練モード
    model.train()
    
    # ミニバッチで回す
    for j, (x, t) in enumerate(train_loader):
        # 順伝播
        y = model(x)
        # 誤差関数
        loss = loss_fnc(y, t)
        # 勾配の初期化
        optimizer.zero_grad()
        # 逆伝播
        loss.backward()
        # パラメータの更新
        optimizer.step()

    if i%100 == 0:
        # 最初の学習データ
        predicted = list(input_data[0].reshape(-1))
        for t in range(prd_data_num):
            # 近い時系列を取り出す
            x = torch.tensor(predicted[-origin_data_num:])
            # 引数：バッチサイズ, 時系列の数, 入力の数
            x = x.reshape(1, origin_data_num, 1) 
            y = model(x)
            predicted.append(y[0].item())
        fig_num = int(i / 100)
        fig.axes[fig_num].plot(range(len(cos_y)), cos_y, label="Correct")
        fig.axes[fig_num].plot(range(len(predicted)), predicted, label="Predicted")
        fig.axes[fig_num].tick_params(length=0)
plt.show()