PyTorch モデル評価とデバッグ

深層学習モデルのトレーニングと最適化には、体系的な評価とデバッグ方法が必要です。このセクションでは、Loss 曲線の分析、過学習と未学習の識別、混同行列による分類モデルの評価、および一般的なデバッグテクニックについて説明します。


1. 損失関数 (Loss) の分析

損失関数はトレーニングプロセスにおける中核的な指標であり、モデルの予測と真の値との差を反映します。Loss 曲線を正しく分析することがモデルデバッグの鍵です。

1.1 トレーニングと検証の Loss 比較

トレーニング Loss と検証 Loss を比較することで、モデルの状態を判断できます:

  • トレーニング Loss が下降し、検証 Loss も下降:正常、モデルが学習していることを示します
  • トレーニング Loss が下降し、検証 Loss が安定または上昇:過学習、正則化が必要
  • トレーニング Loss が下降しない:学習率の問題またはモデルアーキテクチャの問題
  • トレーニング Loss が振動する:学習率が大きすぎるか、batch size が小さすぎる

1.2 Loss 曲線の可視化

例

import matplotlib.pyplot as plt
import numpy as np

def plot_training_history(history):
    """
トレーニング履歴の描画
history: 'train_loss', 'val_loss', 'train_acc', 'val_acc' を含む辞書
    """

    fig, axes = plt.subplots(1, 2, figsize=(14, 5))

    # Loss 曲線
    axes[0].plot(history['train_loss'], label='Train Loss', alpha=0.8)
    axes[0].plot(history['val_loss'], label='Val Loss', alpha=0.8)
    axes[0].set_xlabel('Epoch')
    axes[0].set_ylabel('Loss')
    axes[0].set_title('Training and Validation Loss')
    axes[0].legend()
    axes[0].grid(True, alpha=0.3)

    # Accuracy 曲線
    axes[1].plot(history['train_acc'], label='Train Acc', alpha=0.8)
    axes[1].plot(history['val_acc'], label='Val Acc', alpha=0.8)
    axes[1].set_xlabel('Epoch')
    axes[1].set_ylabel('Accuracy')
    axes[1].set_title('Training and Validation Accuracy')
    axes[1].legend()
    axes[1].grid(True, alpha=0.3)

    plt.tight_layout()
    plt.show()


# トレーニングデータのシミュレーション
history = {
    'train_loss': np.linspace(2.0, 0.2, 50) + np.random.normal(0, 0.05, 50),
    'val_loss': np.linspace(2.0, 0.3, 50) + np.random.normal(0, 0.08, 50),
    'train_acc': np.linspace(0.3, 0.95, 50),
    'val_acc': np.linspace(0.3, 0.88, 50),
}

plot_training_history(history)

1.3 過学習の識別

検証 Loss が上昇し始め、トレーニング Loss が引き続き下降するときが、過学習の始まりです。このときモデルは一般的なパターンを学習するのではなく、トレーニングデータを「記憶」し始めます。

例

import matplotlib.pyplot as plt
import numpy as np

def detect_overfitting(history, patience=5):
    """
過学習の検出
patience: 連続して何エポック検証 loss が上昇したらトレーニングを停止するか
    """

    val_loss = history['val_loss']
    best_loss = float('inf')
    best_epoch = 0
    early_stop_epoch = None

    for epoch in range(patience, len(val_loss)):
        # 直近の patience エポックを確認
        recent_losses = val_loss[epoch - patience:epoch]
        current_loss = val_loss[epoch]

        # 現在の loss が直近の最低 loss より高い場合
        if min(recent_losses) < current_loss:
            early_stop_epoch = epoch
            break

        if current_loss < best_loss:
            best_loss = current_loss
            best_epoch = epoch

    if early_stop_epoch:
        print(f"過学習を検出!最適な epoch: {best_epoch}、epoch {early_stop_epoch} で停止すべき")
    else:
        print("過学習は検出されませんでした")

    return early_stop_epoch, best_epoch


# 過学習の例
overfitting_history = {
    'train_loss': np.linspace(1.5, 0.1, 30),
    'val_loss': np.concatenate([np.linspace(1.5, 0.3, 15), np.linspace(0.3, 0.8, 15)]),
}

detect_overfitting(overfitting_history)

2. 過学習と未学習の対処

2.1 過学習の解決策

方法 説明 コード実装
データ量の増加 より多くのトレーニングデータを収集 データ拡張
Dropout ニューロンのランダムドロップアウト nn.Dropout(0.5)
重み減衰 L2正則化 weight_decay=1e-4
早期停止 (Early Stopping) 検証 loss が下降を停止したらトレーニングを停止 patience パラメータ
モデル複雑度の削減 層またはニューロンの削減 hidden_size を小さくする
データ拡張 ランダム変換でデータの多様性を向上 回転、反転、クロップ

2.2 未学習の解決策

方法 説明
モデル複雑度の追加 層数またはニューロン数の増加
より長くトレーニング トレーニングエポック数を増加
正則化の低減 Dropout または weight_decay を低減
学習率の調整 より大きな学習率を試す

2.3 早期停止メカニズムの実装

例

import torch
import torch.nn as nn
import torch.optim as optim

class EarlyStopping:
    """
早期停止メカニズム:検証 loss が連続して下降しない場合にトレーニングを停止
    """

    def __init__(self, patience=7, min_delta=0, mode='min'):
        """
patience: 連続して何エポック改善がない場合に停止するか
min_delta: 改善とみなされる最小変化量
mode: 'min' または 'max'、指標が小さいほど良いか大きいほど良いか
        """

        self.patience = patience
        self.min_delta = min_delta
        self.mode = mode
        self.counter = 0
        self.best_score = None
        self.early_stop = False

    def __call__(self, val_loss):
        score = -val_loss if self.mode == 'min' else val_loss

        if self.best_score is None:
            self.best_score = score
        elif score < self.best_score + self.min_delta:
            self.counter += 1
            if self.counter >= self.patience:
                self.early_stop = True
        else:
            self.best_score = score
            self.counter = 0

        return self.early_stop


# 早期停止を使用
def train_with_early_stopping(model, train_loader, val_loader, patience=7):
    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
    model = model.to(device)

    criterion = nn.CrossEntropyLoss()
    optimizer = optim.Adam(model.parameters(), lr=1e-3)
    early_stopping = EarlyStopping(patience=patience, mode='min')

    best_val_loss = float('inf')
    best_model_state = None

    for epoch in range(100):
        # トレーニング
        model.train()
        train_loss = 0
        for inputs, labels in train_loader:
            inputs, labels = inputs.to(device), labels.to(device)
            optimizer.zero_grad()
            outputs = model(inputs)
            loss = criterion(outputs, labels)
            loss.backward()
            optimizer.step()
            train_loss += loss.item()

        # 検証
        model.eval()
        val_loss = 0
        with torch.no_grad():
            for inputs, labels in val_loader:
                inputs, labels = inputs.to(device), labels.to(device)
                outputs = model(inputs)
                loss = criterion(outputs, labels)
                val_loss += loss.item()

        val_loss /= len(val_loader)

        print(f"Epoch {epoch+1}: Train Loss={train_loss:.4f}, Val Loss={val_loss:.4f}")

        # 早期停止チェック
        if early_stopping(val_loss):
            print(f"早期停止発動!連続 {patience} エポック、検証 loss が下降しませんでした")

        # 最良モデルの保存
        if val_loss < best_val_loss:
            best_val_loss = val_loss
            best_model_state = model.state_dict().copy()

    # 最良モデルの復元
    model.load_state_dict(best_model_state)
    return model

3. 混同行列 (Confusion Matrix)

混同行列は分類モデルを評価するための重要なツールであり、モデルの予測と正解ラベルの関係を示します。

3.1 混同行列の計算

例

import torch
import numpy as np
from sklearn.metrics import confusion_matrix
import matplotlib.pyplot as plt
import seaborn as sns

def calculate_confusion_matrix(model, dataloader, device, num_classes):
    """
混同行列の計算
    """

    model.eval()
    all_preds = []
    all_labels = []

    with torch.no_grad():
        for inputs, labels in dataloader:
            inputs = inputs.to(device)
            outputs = model(inputs)
            _, preds = torch.max(outputs, 1)

            all_preds.extend(preds.cpu().numpy())
            all_labels.extend(labels.numpy())

    cm = confusion_matrix(all_labels, all_preds)
    return cm


def plot_confusion_matrix(cm, class_names):
    """
混同行列の描画
    """

    plt.figure(figsize=(10, 8))
    sns.heatmap(cm, annot=True, fmt='d', cmap='Blues',
                xticklabels=class_names, yticklabels=class_names)
    plt.xlabel('Predicted Label')
    plt.ylabel('True Label')
    plt.title('Confusion Matrix')
    plt.tight_layout()
    plt.show()


# 使用例
# 10 個のクラスがあると仮定
class_names = [f'Class {i}' for i in range(10)]
cm = np.array([
    [45, 1, 0, 0, 0, 0, 2, 1, 1, 0],
    [0, 42, 2, 0, 0, 0, 0, 3, 2, 1],
    [1, 1, 38, 3, 0, 0, 0, 2, 3, 2],
    [0, 0, 1, 41, 2, 1, 0, 1, 1, 3],
    [0, 0, 0, 1, 44, 0, 1, 0, 2, 2],
    [1, 0, 0, 0, 0, 43, 2, 1, 1, 2],
    [2, 1, 0, 0, 1, 1, 39, 2, 2, 2],
    [0, 2, 1, 1, 0, 0, 1, 40, 3, 2],
    [1, 2, 2, 0, 1, 1, 1, 2, 36, 4],
    [0, 1, 1, 2, 2, 2, 2, 1, 2, 37],
])

plot_confusion_matrix(cm, class_names)

3.2 分類評価指標

混同行列からさまざまな評価指標を計算できます:

例

import numpy as np

def classification_metrics(cm):
    """
混同行列から各種評価指標を計算
    """

    # 正解率 (Accuracy)
    accuracy = np.trace(cm) / np.sum(cm)

    # 各クラスについて適合率、再現率、F1 を計算
    num_classes = cm.shape[0]
    precisions = []
    recalls = []
    f1s = []

    for i in range(num_classes):
        tp = cm[i, i]
        fp = np.sum(cm[:, i]) - tp
        fn = np.sum(cm[i, :]) - tp

        precision = tp / (tp + fp) if (tp + fp) > 0 else 0
        recall = tp / (tp + fn) if (tp + fn) > 0 else 0
        f1 = 2 * precision * recall / (precision + recall) if (precision + recall) > 0 else 0

        precisions.append(precision)
        recalls.append(recall)
        f1s.append(f1)

    # マクロ平均 (Macro Average)
    macro_precision = np.mean(precisions)
    macro_recall = np.mean(recalls)
    macro_f1 = np.mean(f1s)

    # 加重平均 (Weighted Average)
    class_counts = np.sum(cm, axis=1)
    weights = class_counts / np.sum(class_counts)
    weighted_precision = np.average(precisions, weights=weights)
    weighted_recall = np.average(recalls, weights=weights)
    weighted_f1 = np.average(f1s, weights=weights)

    return {
        'accuracy': accuracy,
        'macro_precision': macro_precision,
        'macro_recall': macro_recall,
        'macro_f1': macro_f1,
        'weighted_precision': weighted_precision,
        'weighted_recall': weighted_recall,
        'weighted_f1': weighted_f1,
    }


# 指標の計算
metrics = classification_metrics(cm)

print("=" * 50)
print("分類評価指標")
print("=" * 50)
print(f"正解率 (Accuracy): {metrics['accuracy']:.4f}")
print(f"マクロ平均適合率 (Macro Precision): {metrics['macro_precision']:.4f}")
print(f"マクロ平均再現率 (Macro Recall): {metrics['macro_recall']:.4f}")
print(f"マクロ平均 F1 (Macro F1): {metrics['macro_f1']:.4f}")
print(f"加重平均適合率 (Weighted Precision): {metrics['weighted_precision']:.4f}")
print(f"加重平均再現率 (Weighted Recall): {metrics['weighted_recall']:.4f}")
print(f"加重平均 F1 (Weighted F1): {metrics['weighted_f1']:.4f}")

3.3 分類レポート

例

from sklearn.metrics import classification_report

# sklearn の分類レポートを使用
y_true = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] * 10  # 正解ラベルをシミュレーション
y_pred = [0, 1, 2, 3, 4, 5, 6, 7, 8, 8] * 10  # 予測をシミュレーション

report = classification_report(y_true, y_pred, digits=4)
print(report)

4. 学習率スケジューリング

学習率は深層学習モデルのトレーニングにおいて最も重要なハイパーパラメータの1つです。適切な学習率スケジューリングにより、トレーニング効果を大幅に向上させることができます。

4.1 学習率スケジューリング戦略

戦略 説明 適用シーン
StepLR 固定ステップ減衰 最適な学習率が既知の場合
MultiStepLR 指定エポック減衰 非一様減衰
CosineAnnealingLR コサインアニーリング スムーズな収束
ReduceLROnPlateau 検証lossが下がらないときに減衰 自動チューニング
Warmup 最初に増加し、その後減少 訓練初期の安定化

4.2 学習率スケジューリングの実装

例

import torch
import torch.optim as optim
import matplotlib.pyplot as plt

# 訓練エポックのシミュレーション
epochs = 50

# 1. Step LR:10エポックごとに半分に減衰
scheduler_step = optim.lr_scheduler.StepLR(
    optim.SGD(torch.nn.Linear(10, 10).parameters(), lr=0.1),
    step_size=10, gamma=0.5
)

# 2. MultiStep LR:指定エポックで減衰
scheduler_multistep = optim.lr_scheduler.MultiStepLR(
    optim.SGD(torch.nn.Linear(10, 10).parameters(), lr=0.1),
    milestones=[15, 30, 45], gamma=0.1
)

# 3. Cosine Annealing
scheduler_cosine = optim.lr_scheduler.CosineAnnealingLR(
    optim.SGD(torch.nn.Linear(10, 10).parameters(), lr=0.1),
    T_max=50
)

# 4. ReduceLROnPlateau
scheduler_plateau = optim.lr_scheduler.ReduceLROnPlateau(
    optim.SGD(torch.nn.Linear(10, 10).parameters(), lr=0.1),
    mode='min', factor=0.5, patience=5
)

# 学習率曲線の描画
fig, axes = plt.subplots(2, 2, figsize=(14, 10))

# Step LR
lr_history = []
for _ in range(epochs):
    lr_history.append(optimizer.param_groups[0]['lr'])
    scheduler_step.step()
axes[0, 0].plot(lr_history)
axes[0, 0].set_title('Step LR')

# 再初期化
optimizer = optim.SGD(torch.nn.Linear(10, 10).parameters(), lr=0.1)
scheduler = optim.lr_scheduler.MultiStepLR(optimizer, milestones=[15, 30, 45], gamma=0.1)
lr_history = []
for _ in range(epochs):
    lr_history.append(optimizer.param_groups[0]['lr'])
    scheduler.step()
axes[0, 1].plot(lr_history)
axes[0, 1].set_title('MultiStep LR')

# Cosine
optimizer = optim.SGD(torch.nn.Linear(10, 10).parameters(), lr=0.1)
scheduler = optim.lr_scheduler.CosineAnnealingLR(optimizer, T_max=50)
lr_history = []
for _ in range(epochs):
    lr_history.append(optimizer.param_groups[0]['lr'])
    scheduler.step()
axes[1, 0].plot(lr_history)
axes[1, 0].set_title('Cosine Annealing LR')

# Warmup + Cosine
def warmup_cosine(optimizer, warmup_epochs, total_epochs, min_lr=1e-6):
    def lr_lambda(epoch):
        if epoch < warmup_epochs:
            return epoch / warmup_epochs
        return min_lr + 0.5 * (1 - min_lr) * (1 + np.cos(np.pi * (epoch - warmup_epochs) / (total_epochs - warmup_epochs)))

    return optim.lr_scheduler.LambdaLR(optimizer, lr_lambda)

optimizer = optim.SGD(torch.nn.Linear(10, 10).parameters(), lr=0.1)
scheduler = warmup_cosine(optimizer, warmup_epochs=5, total_epochs=50)
lr_history = []
for _ in range(epochs):
    lr_history.append(optimizer.param_groups[0]['lr'])
    scheduler.step()
axes[1, 1].plot(lr_history)
axes[1, 1].set_title('Warmup + Cosine')

for ax in axes.flat:
    ax.set_xlabel('Epoch')
    ax.set_ylabel('Learning Rate')
    ax.grid(True, alpha=0.3)

plt.tight_layout()
plt.show()

5. 勾配問題の診断

5.1 勾配消失と勾配爆発

< h2 class="example">例
import torch
import torch.nn as nn

def analyze_gradients(model):
    """
モデル各層の勾配を分析
    """

    grad_stats = {}

    for name, param in model.named_parameters():
        if param.grad is not None:
            grad = param.grad
            grad_stats[name] = {
                'mean': grad.mean().item(),
                'std': grad.std().item(),
                'max': grad.abs().max().item(),
                'min': grad.abs().min().item(),
                'norm': grad.norm().item(),
            }

    return grad_stats


def detect_gradient_issues(model):
    """
勾配問題の検出
    """

    issues = []
    grad_norms = []

    for param in model.parameters():
        if param.grad is not None:
            grad_norms.append(param.grad.norm().item())

    avg_grad_norm = sum(grad_norms) / len(grad_norms) if grad_norms else 0

    if avg_grad_norm < 1e-7:
        issues.append("勾配消失:勾配が小さすぎて、モデルが学習できない可能性があります")
    elif avg_grad_norm > 100:
        issues.append("勾配爆発:勾配が大きすぎて、訓練が不安定です")

    return issues, avg_grad_norm


# 例:勾配の検出
model = nn.Sequential(
    nn.Linear(100, 50),
    nn.ReLU(),
    nn.Linear(50, 50),
    nn.ReLU(),
    nn.Linear(50, 10)
)

# 順伝播と逆伝播のシミュレーション
x = torch.randn(32, 100)
y = model(x)
loss = y.sum()
loss.backward()

issues, avg_norm = detect_gradient_issues(model)
print(f"平均勾配ノルム: {avg_norm:.6f}")
if issues:
    for issue in issues:
        print(f"警告: {issue}")
else:
    print("勾配状態は正常です")

5.2 勾配クリッピング

例

import torch
import torch.nn as nn
import torch.optim as optim
import torch.nn.utils as utils

# 勾配クリッピングの例
def train_with_gradient_clipping(model, dataloader, max_norm=1.0):
    """
勾配クリッピングを使用した訓練
max_norm: 最大勾配ノルム。この値を超える勾配はクリップされます
    """

    criterion = nn.CrossEntropyLoss()
    optimizer = optim.Adam(model.parameters(), lr=1e-3)

    model.train()
    for inputs, labels in dataloader:
        optimizer.zero_grad()

        outputs = model(inputs)
        loss = criterion(outputs, labels)

        loss.backward()

        # 勾配クリッピング:勾配爆発の防止
        utils.clip_grad_norm_(model.parameters(), max_norm=max_norm)

        optimizer.step()

    return model


# 要素ごとのクリッピング(より保守的)
def clip_grad_by_value(model, clip_value=1.0):
    """
値による勾配クリッピング
    """

    for param in model.parameters():
        if param.grad is not None:
            param.grad.data.clamp_(min=-clip_value, max=clip_value)

6. モデル性能分析

6.1 パラメータ数と FLOPs の計算

例

import torch
import torch.nn as nn
from thop import profile

def count_parameters(model):
    """モデルの学習可能なパラメータ数を計算"""
    total = sum(p.numel() for p in model.parameters())
    trainable = sum(p.numel() for p in model.parameters() if p.requires_grad)
    return total, trainable


def count_flops(model, input_size=(1, 3, 224, 224)):
    """FLOPsを計算(thopライブラリのインストールが必要)"""
    input_tensor = torch.randn(input_size)
    flops, params = profile(model, inputs=(input_tensor,), verbose=False)
    return flops, params


# 例:モデルの統計
model = nn.Sequential(
    nn.Conv2d(3, 64, kernel_size=3, padding=1),
    nn.ReLU(),
    nn.MaxPool2d(2),
    nn.Conv2d(64, 128, kernel_size=3, padding=1),
    nn.ReLU(),
    nn.MaxPool2d(2),
    nn.Conv2d(128, 256, kernel_size=3, padding=1),
    nn.ReLU(),
    nn.AdaptiveAvgPool2d(1),
    nn.Flatten(),
    nn.Linear(256, 10)
)

total, trainable = count_parameters(model)
print(f"総パラメータ数: {total:,}")
print(f"学習可能パラメータ数: {trainable:,}")
print(f"モデルサイズ: {total * 4 / 1024 / 1024:.2f} MB")

# FLOPsの計算
try:
    flops, _ = count_flops(model)
    print(f"FLOPs: {flops / 1e9:.2f} G")
except ImportError:
    print("thopライブラリをインストールしてください: pip install thop")

6.2 推論速度のテスト

< h2 class="example">例
import torch
import time

def measure_inference_speed(model, input_size, device='cuda', num_iterations=100):
    """
推論速度の測定
    """

    model.eval()
    model = model.to(device)

    # ウォームアップ
    dummy_input = torch.randn(input_size).to(device)
    with torch.no_grad():
        for _ in range(10):
            _ = model(dummy_input)

    # 計測
    start = time.time()
    with torch.no_grad():
        for _ in range(num_iterations):
            _ = model(dummy_input)

    if device == 'cuda':
        torch.cuda.synchronize()

    end = time.time()
    avg_time = (end - start) / num_iterations * 1000  # ms

    return avg_time


# 使用例
model = nn.Sequential(
    nn.Conv2d(3, 64, kernel_size=3, padding=1),
    nn.ReLU(),
    nn.Conv2d(64, 64, kernel_size=3, padding=1),
    nn.ReLU(),
    nn.AdaptiveAvgPool2d(1),
    nn.Flatten(),
    nn.Linear(64, 10)
)

# CPU推論速度
cpu_time = measure_inference_speed(model, (1, 3, 224, 224), device='cpu')
print(f"CPU推論時間: {cpu_time:.2f} ms/画像")

# GPU推論速度(CUDAがある場合)
if torch.cuda.is_available():
    gpu_time = measure_inference_speed(model, (1, 3, 224, 224), device='cuda')
    print(f"GPU推論時間: {gpu_time:.2f} ms/画像")

6.3 メモリ使用量の分析

例

import torch

def analyze_memory(model, input_size):
    """
モデルのメモリ使用量を分析
    """

    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
    model = model.to(device)

    # 入力の作成
    x = torch.randn(input_size).to(device)

    # キャッシュのクリア
    if torch.cuda.is_available():
        torch.cuda.empty_cache()
        torch.cuda.reset_peak_memory_stats()

    # 順伝播
    with torch.no_grad():
        output = model(x)

    # メモリ統計の取得
    if torch.cuda.is_available():
        allocated = torch.cuda.memory_allocated() / 1024**2  # MB
        reserved = torch.cuda.memory_reserved() / 1024**2
        max_allocated = torch.cuda.max_memory_allocated() / 1024**2

        print(f"現在の割り当て: {allocated:.2f} MB")
        print(f"キャッシュ使用量: {reserved:.2f} MB")
        print(f"ピーク使用量: {max_allocated:.2f} MB")
    else:
        print("CUDAサポートが必要です")

    return output


# 使用例
model = nn.Sequential(
    nn.Conv2d(3, 64, kernel_size=3, padding=1),
    nn.ReLU(),
    nn.Conv2d(64, 128, kernel_size=3, padding=1),
    nn.ReLU(),
    nn.Conv2d(128, 256, kernel_size=3, padding=1),
    nn.ReLU(),
)
analyze_memory(model, (8, 3, 224, 224))

7. よくある問題とデバッグのヒント

7.1 トレーニング問題の早見表

症状 考えられる原因 解決策
Lossが下がらない 学習率が小さすぎる/大きすぎる、勾配の問題 学習率の調整、勾配の確認
Lossの振動 学習率が大きすぎる、バッチサイズが小さい 学習率を下げる、バッチサイズを大きくする
NaNが発生 ゼロ除算、log(0)、勾配爆発 epsilonの追加、勾配クリッピング
過学習 モデルが複雑、データが不十分 データを増やす、正則化を追加
未学習(過小適合) モデルが単純すぎる、訓練不足 モデルを大きくする、より長く訓練する
メモリ不足 バッチサイズが大きい、モデルが大きい バッチを小さくする、勾配累積

7.2 デバッグテクニック集

例

import torch
import random
import numpy as np

def set_seed(seed=42):
    """乱数シードを設定して、結果を再現可能にする"""
    random.seed(seed)
    np.random.seed(seed)
    torch.manual_seed(seed)
    torch.cuda.manual_seed(seed)
    torch.cuda.manual_seed_all(seed)
    torch.backends.cudnn.deterministic = True
    torch.backends.cudnn.benchmark = False


def debug_forward(model, x):
    """順伝播をデバッグして、各層の出力を確認する"""
    print("=" * 50)
    print("順伝播デバッグ")
    print("=" * 50)

    for name, layer in model.named_children():
        x = layer(x)
        if hasattr(x, 'shape'):
            print(f"{name}: shape={x.shape}, ", end='')
            if hasattr(x, 'mean'):
                print(f"mean={x.mean().item():.4f}, std={x.std().item():.4f}")
            if torch.isnan(x).any():
                print(f" &#x26a0;&#xfe0f; NaNを検出しました!")
            if torch.isinf(x).any():
                print(f" &#x26a0;&#xfe0f; Infを検出しました!")
    print("=" * 50)


def debug_backward(model):
    """逆伝播をデバッグして、勾配を確認する"""
    print("=" * 50)
    print("逆伝播デバッグ")
    print("=" * 50)

    for name, param in model.named_parameters():
        if param.grad is not None:
            grad_norm = param.grad.norm().item()
            if torch.isnan(param.grad).any():
                print(f"{name}: &#x26a0;&#xfe0f; 勾配NaN!")
            elif torch.isinf(param.grad).any():
                print(f"{name}: &#x26a0;&#xfe0f; 勾配Inf!")
            elif grad_norm > 10:
                print(f"{name}: &#x26a0;&#xfe0f; 勾配爆発! norm={grad_norm:.2f}")
            elif grad_norm < 1e-7:
                print(f"{name}: &#x26a0;&#xfe0f; 勾配消失! norm={grad_norm:.2e}")
            else:
                print(f"{name}: 正常 norm={grad_norm:.4f}")
    print("=" * 50)


# 使用例
set_seed(42)

model = nn.Sequential(
    nn.Linear(10, 20),
    nn.ReLU(),
    nn.Linear(20, 20),
    nn.ReLU(),
    nn.Linear(20, 5)
)

x = torch.randn(2, 10)
y = model(x)

debug_forward(model, x)

loss = y.sum()
loss.backward()

debug_backward(model)

8. PyTorch Profiler の使用

PyTorch Profilerは公式提供のパフォーマンス分析ツールで、モデルの各部分の処理時間とメモリ使用量を分析できます。

8.1 Profiler の基本的な使用方法

例

import torch
import torch.nn as nn
from torch.profiler import profile, ProfilerActivity, schedule

# シンプルなモデル
model = nn.Sequential(
    nn.Conv2d(3, 64, 3, padding=1),
    nn.ReLU(),
    nn.Conv2d(64, 64, 3, padding=1),
    nn.ReLU(),
    nn.AdaptiveAvgPool2d(1),
    nn.Flatten(),
    nn.Linear(64, 10)
).cuda()

optimizer = torch.optim.Adam(model.parameters())
criterion = nn.CrossEntropyLoss()

# profilerを使用
with profile(
    activities=[ProfilerActivity.CPU, ProfilerActivity.CUDA],
    schedule=schedule(wait=1, warmup=1, active=3, repeat=1),
    on_trace_ready=torch.profiler.tensorboard_trace_handler('./logs'),
    record_shapes=True,
    profile_memory=True,
    with_stack=True
) as prof:
    for step in range(5):
        inputs = torch.randn(8, 3, 224, 224).cuda()
        labels = torch.randint(0, 10, (8,)).cuda()

        optimizer.zero_grad()
        outputs = model(inputs)
        loss = criterion(outputs, labels)
        loss.backward()
        optimizer.step()
        prof.step()

# 結果を出力
print(prof.key_averages().table(sort_by="cuda_time_total", row_limit=10))

8.2 Profiler 結果の可視化

例

# Chromeトレースファイルをエクスポート
# 生成された./logsディレクトリはChromeブラウザで開いて確認できます

# または各指標を直接出力
print("=" * 80)
print("CPU時間 Top 10:")
print(prof.key_averages().table(sort_by="cpu_time_total", row_limit=10))

print("\n" + "=" * 80)
print("CUDA時間 Top 10:")
print(prof.key_averages().table(sort_by="cuda_time_total", row_limit=10))

print("\n" + "=" * 80)
print("メモリ使用量 Top 10:")
print(prof.key_averages().table(sort_by="self_cuda_memory_usage", row_limit=10))
その他の拡張