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)
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)
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
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)
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}")
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)
# 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()
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("勾配状態は正常です")
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)
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")
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/画像")
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))
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" ⚠️ NaNを検出しました!")
if torch.isinf(x).any():
print(f" ⚠️ 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}: ⚠️ 勾配NaN!")
elif torch.isinf(param.grad).any():
print(f"{name}: ⚠️ 勾配Inf!")
elif grad_norm > 10:
print(f"{name}: ⚠️ 勾配爆発! norm={grad_norm:.2f}")
elif grad_norm < 1e-7:
print(f"{name}: ⚠️ 勾配消失! 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)
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" ⚠️ NaNを検出しました!")
if torch.isinf(x).any():
print(f" ⚠️ 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}: ⚠️ 勾配NaN!")
elif torch.isinf(param.grad).any():
print(f"{name}: ⚠️ 勾配Inf!")
elif grad_norm > 10:
print(f"{name}: ⚠️ 勾配爆発! norm={grad_norm:.2f}")
elif grad_norm < 1e-7:
print(f"{name}: ⚠️ 勾配消失! 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))
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))
# 生成された./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))