PyTorchでシンプルなLSTMを構築：Sequentialモジュールを用いた解説

2024-07-27

Long Short-Term Memory (LSTM) は、再帰ニューラルネットワーク (RNN) の一種であり、時系列データ の処理に特に優れています。 従来の RNN と異なり、LSTM は長期的な依存関係を学習することができ、自然言語処理や音声認識などの分野で幅広く活用されています。

必要なライブラリ

このチュートリアルでは、以下のライブラリを使用します。

  • torch - PyTorch の主要モジュール
  • torch.nn - ニューラルネットワーク構築のためのモジュール
  • torch.optim - 最適化アルゴリズムのためのモジュール

データ準備

まず、学習データと検証データを用意する必要があります。 ここでは、簡単な例として、以下の時系列データを使用します。

import numpy as np

# データ生成
data = np.sin(np.linspace(0, 2*np.pi, 100))

# データ分割
train_data = data[:70]
val_data = data[70:]

モデル構築

次に、LSTMネットワークを構築します。 ここでは、Sequential モジュールを使用して、シンプルなLSTMモデルを構築します。

import torch
import torch.nn as nn

# モデル定義
class LSTMModel(nn.Module):
  def __init__(self, input_dim, hidden_dim, output_dim):
    super().__init__()

    self.lstm = nn.LSTM(input_dim, hidden_dim)
    self.fc = nn.Linear(hidden_dim, output_dim)

  def forward(self, x):
    # LSTM層を通す
    output, _ = self.lstm(x)

    # 全結合層を通す
    output = self.fc(output[-1])
    return output

# モデルインスタンス化
model = LSTMModel(1, 10, 1)

モデル学習

モデルを学習させるには、損失関数と最適化アルゴリズムを定義する必要があります。 ここでは、Mean Squared Error (MSE) 損失関数と Adam 最適化アルゴリズムを使用します。

# 損失関数と最適化アルゴリズム定義
criterion = nn.MSELoss()
optimizer = torch.optim.Adam(model.parameters())

学習ループ

学習ループでは、モデルに入力データを送り、損失を計算し、最適化アルゴリズムを使用してモデルのパラメータを更新します。

# 学習ループ
num_epochs = 100

for epoch in range(num_epochs):
  # データをバッチに変換
  train_loader = torch.utils.data.DataLoader(train_data, batch_size=10)

  # 各バッチに対して処理
  for i, (data) in enumerate(train_loader):
    # データをモデルに入力
    x = data.view(-1, 1)

    # モデルの予測
    y_pred = model(x)

    # 損失計算
    loss = criterion(y_pred, x)

    # 勾配計算
    optimizer.zero_grad()
    loss.backward()

    # パラメータ更新
    optimizer.step()

    # ログ出力
    if (i + 1) % 10 == 0:
      print(f'Epoch [{epoch + 1}/{num_epochs}], Step [{i + 1}/{len(train_loader)}], Loss: {loss.item():.4f}')

モデル評価

学習完了後、モデルを検証データで評価します。

# モデル評価
with torch.no_grad():
  # データをモデルに入力
  x = torch.from_numpy(val_data).view(-1, 1)

  # モデルの予測
  y_pred = model(x)

  # 損失計算
  loss = criterion(y_pred, x)
  print(f'Validation Loss: {loss.item():.4f}')

説明

このチュートリアルでは、PyTorch の Sequential モジュールを用いて、シンプルなLSTMモデルを構築する方法を解説しました。

  • Sequential モジュールは、ニューラルネットワークの層を簡単に積み重ねることができます。


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

# データ生成
data = np.sin(np.linspace(0, 2*np.pi, 100))

# データ分割
train_data = data[:70]
val_data = data[70:]

# モデル定義
class LSTMModel(nn.Module):
  def __init__(self, input_dim, hidden_dim, output_dim):
    super().__init__()

    self.lstm = nn.LSTM(input_dim, hidden_dim)
    self.fc = nn.Linear(hidden_dim, output_dim)

  def forward(self, x):
    # LSTM層を通す
    output, _ = self.lstm(x)

    # 全結合層を通す
    output = self.fc(output[-1])
    return output

# モデルインスタンス化
model = LSTMModel(1, 10, 1)

# 損失関数と最適化アルゴリズム定義
criterion = nn.MSELoss()
optimizer = torch.optim.Adam(model.parameters())

# 学習ループ
num_epochs = 100

for epoch in range(num_epochs):
  # データをバッチに変換
  train_loader = torch.utils.data.DataLoader(train_data, batch_size=10)

  # 各バッチに対して処理
  for i, (data) in enumerate(train_loader):
    # データをモデルに入力
    x = data.view(-1, 1)

    # モデルの予測
    y_pred = model(x)

    # 損失計算
    loss = criterion(y_pred, x)

    # 勾配計算
    optimizer.zero_grad()
    loss.backward()

    # パラメータ更新
    optimizer.step()

    # ログ出力
    if (i + 1) % 10 == 0:
      print(f'Epoch [{epoch + 1}/{num_epochs}], Step [{i + 1}/{len(train_loader)}], Loss: {loss.item():.4f}')

# モデル評価
with torch.no_grad():
  # データをモデルに入力
  x = torch.from_numpy(val_data).view(-1, 1)

  # モデルの予測
  y_pred = model(x)

  # 損失計算
  loss = criterion(y_pred, x)
  print(f'Validation Loss: {loss.item():.4f}')

このコードは、以下の内容を順番に実行します。

  1. データ準備: numpy ライブラリを使用して、学習データと検証データを生成します。
  2. モデル定義: LSTMModel クラスを定義し、LSTM層と全結合層を含むモデルを構築します。
  3. モデルインスタンス化: LSTMModel クラスのインスタンスを作成します。
  4. 損失関数と最適化アルゴリズム定義: nn.MSELoss 関数と torch.optim.Adam クラスを使用して、損失関数と最適化アルゴリズムを定義します。
  5. 学習ループ: 以下の処理を num_epochs 回実行します。
    • データをバッチに変換します。
    • 各バッチに対して、モデルに入力し、予測を行い、損失を計算します。
    • 勾配を計算し、パラメータを更新します。
    • ログを出力します。
  6. モデル評価: 検証データでモデルを評価し、損失を出力します。
  • このコードは、あくまでシンプルな例です。実際のアプリケーションでは、データの種類やタスクに合わせて、モデルや学習方法を調整する必要があります。


PyTorchには、Functional APIと呼ばれる、ニューラルネットワークを関数的に構築するためのAPIが用意されています。 Sequential モジュールよりも柔軟性が高いのが特徴です。

import torch
import torch.nn as nn
import torch.nn.functional as F

# モデル定義
class LSTMModel(nn.Module):
  def __init__(self, input_dim, hidden_dim, output_dim):
    super().__init__()

    self.lstm_cell = nn.LSTMCell(input_dim, hidden_dim)
    self.fc = nn.Linear(hidden_dim, output_dim)

  def forward(self, x):
    # LSTMセルを展開
    hidden = torch.zeros(x.size(0), hidden_dim)
    cell_state = torch.zeros(x.size(0), hidden_dim)

    for i in range(x.size(1)):
      hidden, cell_state = self.lstm_cell(x[:, i], hidden, cell_state)

    # 全結合層を通す
    output = self.fc(hidden)
    return output

# モデルインスタンス化
model = LSTMModel(1, 10, 1)

Custom Module

独自のモジュールを作成することもできます。 これは、複雑なモデルや、特定のニーズに合わせたモデルを構築する場合に役立ちます。

import torch
import torch.nn as nn

# カスタムモジュール定義
class LSTMLayer(nn.Module):
  def __init__(self, input_dim, hidden_dim):
    super().__init__()

    self.w_ih = nn.Parameter(torch.randn(input_dim, hidden_dim))
    self.w_hh = nn.Parameter(torch.randn(hidden_dim, hidden_dim))
    self.b_ih = nn.Parameter(torch.zeros(hidden_dim))
    self.b_hh = nn.Parameter(torch.zeros(hidden_dim))

  def forward(self, x, hidden, cell_state):
    # LSTMセルを計算
    i = torch.sigmoid(self.w_ih * x + self.b_ih)
    f = torch.sigmoid(self.w_hh * hidden + self.b_hh)
    o = torch.sigmoid(self.w_hh * hidden + self.b_hh)
    g = torch.tanh(self.w_ih * x + self.b_ih)

    new_cell_state = f * cell_state + i * g
    hidden = o * torch.tanh(new_cell_state)

    return hidden, new_cell_state

# モデル定義
class LSTMModel(nn.Module):
  def __init__(self, input_dim, hidden_dim, output_dim):
    super().__init__()

    self.lstm_layer = LSTMLayer(input_dim, hidden_dim)
    self.fc = nn.Linear(hidden_dim, output_dim)

  def forward(self, x):
    # LSTMセルを展開
    hidden = torch.zeros(x.size(0), hidden_dim)
    cell_state = torch.zeros(x.size(0), hidden_dim)

    for i in range(x.size(1)):
      hidden, cell_state = self.lstm_layer(x[:, i], hidden, cell_state)

    # 全結合層を通す
    output = self.fc(hidden)
    return output

# モデルインスタンス化
model = LSTMModel(1, 10, 1)

Pre-trained Models

PyTorchには、pre-trained modelsと呼ばれる、すでに学習済みのモデルが用意されています。 これらのモデルを微調整することで、新しいタスクに適用することができます。

import torch
from torch import nn
import torchvision.models as models

# モデル定義
model = models.lstm(pretrained=True, num_classes=1)

# モデルを微調整
for param in model.parameters():
  param.requires_grad = False

# 最後の全結合層を書き換える
model.fc = nn.Linear(model.fc.in_features, 1)

# モデルを学習
...

それぞれの方法の利点と欠点

  • Sequential モジュール: 最

deep-learning torch lstm

deep learning torch lstm

PyTorchでオートエンコーダの損失を計算する3つの方法と、それぞれのメリット・デメリット
PyTorchでオートエンコーダの損失を計算する3つの方法と、それぞれのメリット・デメリット

このチュートリアルでは、PyTorchでオートエンコーダの損失を計算するためにBCELoss関数を使用する方法について説明します。BCELossとは？BCELoss（Binary Cross Entropy Loss）は、2値分類問題における損失関数を計算するために使用されます。オートエンコーダは、入力と出力が同じであることを学習するニューラルネットワークアーキテクチャです。BCELossは、オートエンコーダの出力と入力の間にどれだけ差異があるかを測定するために使用できます。