PyTorchとは？深層学習フレームワークの特徴と入門ガイド

PyTorchでMLPを構築する：nn.ModuleからDataLoader・学習ループまで

PyTorchの基本であるnn.Moduleを継承したMLP（多層パーセプトロン）の定義から、DataLoaderによるミニバッチ学習、損失の推移確認までを一貫して実装します。

import torch
import torch.nn as nn
import torch.optim as optim
from torch.utils.data import DataLoader, TensorDataset
from sklearn.datasets import make_classification
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
import matplotlib.pyplot as plt

# データ準備
X, y = make_classification(
    n_samples=2000, n_features=20, n_informative=15,
    n_classes=2, random_state=42
)
X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.2, random_state=42
)

scaler = StandardScaler()
X_train = scaler.fit_transform(X_train)
X_test = scaler.transform(X_test)

# NumPy → PyTorch Tensor
X_train_t = torch.FloatTensor(X_train)
y_train_t = torch.FloatTensor(y_train)
X_test_t = torch.FloatTensor(X_test)
y_test_t = torch.FloatTensor(y_test)

# DataLoaderの作成
train_dataset = TensorDataset(X_train_t, y_train_t)
train_loader = DataLoader(train_dataset, batch_size=64, shuffle=True)

# nn.Moduleを継承したMLPモデル
class MLP(nn.Module):
    def __init__(self, input_dim, hidden_dims, output_dim, dropout_rate=0.3):
        super(MLP, self).__init__()
        layers = []
        prev_dim = input_dim
        for h_dim in hidden_dims:
            layers.append(nn.Linear(prev_dim, h_dim))
            layers.append(nn.BatchNorm1d(h_dim))
            layers.append(nn.ReLU())
            layers.append(nn.Dropout(dropout_rate))
            prev_dim = h_dim
        layers.append(nn.Linear(prev_dim, output_dim))
        self.network = nn.Sequential(*layers)

    def forward(self, x):
        return self.network(x).squeeze(-1)

# モデル・損失関数・最適化手法の設定
model = MLP(input_dim=20, hidden_dims=[128, 64, 32], output_dim=1)
criterion = nn.BCEWithLogitsLoss()
optimizer = optim.Adam(model.parameters(), lr=0.001, weight_decay=1e-4)
scheduler = optim.lr_scheduler.StepLR(optimizer, step_size=20, gamma=0.5)

# 学習ループ
num_epochs = 50
train_losses = []
test_losses = []

for epoch in range(num_epochs):
    model.train()
    epoch_loss = 0.0
    for batch_X, batch_y in train_loader:
        optimizer.zero_grad()
        outputs = model(batch_X)
        loss = criterion(outputs, batch_y)
        loss.backward()
        optimizer.step()
        epoch_loss += loss.item() * batch_X.size(0)

    train_loss = epoch_loss / len(train_dataset)
    train_losses.append(train_loss)

    # テスト損失の計算
    model.eval()
    with torch.no_grad():
        test_outputs = model(X_test_t)
        test_loss = criterion(test_outputs, y_test_t).item()
        test_losses.append(test_loss)

    scheduler.step()

    if (epoch + 1) % 10 == 0:
        preds = (torch.sigmoid(test_outputs) > 0.5).float()
        acc = (preds == y_test_t).float().mean()
        print(f"Epoch [{epoch+1}/{num_epochs}] "
              f"Train Loss: {train_loss:.4f} "
              f"Test Loss: {test_loss:.4f} "
              f"Test Acc: {acc:.4f}")

# 学習曲線の可視化
plt.figure(figsize=(10, 5))
plt.plot(train_losses, label="Train Loss")
plt.plot(test_losses, label="Test Loss")
plt.xlabel("Epoch")
plt.ylabel("Loss")
plt.title("MLP Training Curve (PyTorch)")
plt.legend()
plt.grid(True, alpha=0.3)
plt.tight_layout()
plt.savefig("pytorch_mlp_training.png", dpi=150)
plt.show()

このコードで押さえるべきポイントは4つあります。第一に、nn.Moduleを継承してモデルを定義する際、nn.Sequentialでレイヤーを動的に構築することで隠れ層の数を柔軟に変更できます。第二に、DataLoaderでバッチサイズ64・シャッフル有りとすることでミニバッチSGDによる効率的な学習が実現します。第三に、model.train()とmodel.eval()を切り替えることでDropoutやBatchNormの挙動を訓練時と推論時で適切に制御しています。第四に、StepLRスケジューラで20エポックごとに学習率を半減させ、学習後半での振動を抑制しています。