pytorch

PyTorch - ディープラーニングとテンソル

PyTorch は Python ベースの科学計算パッケージです。Graphics Processing Units（GPU）の性能を活用し、動的計算グラフシステムによって最大限の柔軟性と速度を実現します。

使用する場面

• ディープニューラルネットワーク（CNN、RNN、Transformer）の構築とトレーニング。
• 動的グラフが必要な新しい AI アーキテクチャの研究。
• NVIDIA（CUDA）または Mac（MPS）ハードウェアでのテンソル演算の高速化。
• 物理情報を組み込んだニューラルネットワーク（PINN）の解決。
• 生成モデル（GAN、Diffusion）の実装。
• Autograd（自動微分）を用いた大規模な最適化。
• 本番環境向けの AI デプロイ（TorchScript/ONNX 経由）。

リファレンスドキュメント

公式ドキュメント：https://pytorch.org/docs/
チュートリアル：https://pytorch.org/tutorials/
検索パターン：torch.nn、torch.optim、torch.utils.data、Autograd、Tensor.to(device)

基本原則

テンソル

NumPy の ndarray に似た中心的なデータ構造ですが、GPU 上に配置でき、自動微分をサポートするという 2 つの重要な機能があります。

動的計算グラフ（Autograd）

PyTorch はコードの実行中にグラフを「その場で」構築します。これにより、モデル内で標準的な Python の制御フロー（if/for）を使用できます。

モジュールとパラメーター

nn.Module はすべてのニューラルネットワークコンポーネントの基底クラスです。最適化のために、nn.Parameter オブジェクト（重み／バイアス）を自動的に追跡します。

クイックリファレンス

インストール

# CPU
pip install torch torchvision
# GPU (Check pytorch.org for specific CUDA versions)
pip install torch --index-url https://download.pytorch.org/whl/cu121

標準インポート

import torch
import torch.nn as nn
import torch.optim as optim
import torch.nn.functional as F
from torch.utils.data import DataLoader, Dataset

基本パターン - シンプルな線形回帰（「PyTorch の方法」）

import torch

# 1. Data (Tensors)
X = torch.tensor([[1.0], [2.0], [3.0]], requires_grad=True)
y = torch.tensor([[2.0], [4.0], [6.0]])

# 2. Simple Model
model = torch.nn.Linear(1, 1) # y = w*x + b

# 3. Loss and Optimizer
criterion = torch.nn.MSELoss()
optimizer = torch.optim.SGD(model.parameters(), lr=0.01)

# 4. Training Loop
for epoch in range(100):
    prediction = model(X)
    loss = criterion(prediction, y)
    
    optimizer.zero_grad() # Clear previous gradients
    loss.backward()       # Compute gradients (Autograd)
    optimizer.step()      # Update weights

重要なルール

✅ すること

• 常に zero_grad() を呼び出す - PyTorch はデフォルトで勾配を蓄積します。これを忘れると、モデルは収束しません。
• .to(device) を使用する - モデルとデータの両方を、同じデバイス（CPU または CUDA）に明示的に移動します。
• DataLoader を使用する - ループ内で手動でデータを渡さないでください。DataLoader がバッチ処理、シャッフル、マルチプロセス読み込みを処理します。
• model.train() / model.eval() を設定する - これは、推論時に動作が異なる Dropout や BatchNorm などのレイヤーで非常に重要です。
• 推論には torch.no_grad() を使用する - グラフを構築しないため、メモリと計算量を大幅に節約できます。
• データ型を指定する - float32（標準）、float64（科学計算向けの精度）、float16（速度）の違いに注意してください。

❌ しないこと

• CPU と GPU のテンソルを混在させる - RuntimeError: Expected all tensors to be on the same device は最もよくあるエラーです。
• 演算に標準的な Python のループを使う - パフォーマンス向上のため、ベクトル化されたテンソル演算を使用します。
• .item() を忘れる - ログ出力のためにテンソルからスカラー値を取得するときは、loss.item() を使用して計算グラフから切り離します。
• GPU で float64 を使いすぎる - 多くの一般向け GPU では倍精度のパフォーマンスが低いため、可能であれば float32 を使用します。

アンチパターン（絶対に避けること）

import torch

# ❌ BAD: Mixing Python lists/arrays with Tensors in a loop
# for x in data:
#     res = model(torch.tensor(x)) # Extremely slow re-allocation!

# ✅ GOOD: Batching
# data_tensor = torch.stack([torch.tensor(x) for x in data])
# res = model(data_tensor)

# ❌ BAD: Calculating loss without zeroing gradients
loss.backward()
optimizer.step()
# Next iteration... gradients will be double what they should be!

# ✅ GOOD:
optimizer.zero_grad()
loss.backward()
optimizer.step()

# ❌ BAD: Standard NumPy for inference
# with torch.no_grad():
#    pred = model(X).numpy() # Can be slow on GPU if not handled

# ✅ GOOD: Explicit move to CPU
# pred = model(X).detach().cpu().numpy()

テンソルとデバイス管理

CPU と GPU の間での移動

device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
print(f"Using device: {device}")

# Create tensor on device
x = torch.randn(3, 3, device=device)

# Move model to device
model = MyModel().to(device)

# Move data to device during loop
for inputs, labels in dataloader:
    inputs, labels = inputs.to(device), labels.to(device)
    # ...

モデルの構築（nn.Module）

柔軟なアーキテクチャ

class ScientificNet(nn.Module):
    def __init__(self, input_dim, hidden_dim):
        super().__init__()
        self.layer1 = nn.Linear(input_dim, hidden_dim)
        self.layer2 = nn.Linear(hidden_dim, 1)
        self.dropout = nn.Dropout(0.2)
        
    def forward(self, x):
        x = F.relu(self.layer1(x))
        x = self.dropout(x)
        x = torch.sigmoid(self.layer2(x))
        return x

model = ScientificNet(10, 50)

カスタムデータセット（torch.utils.data）

科学計算用ファイルの処理（例：HDF5 または CSV）

class MyScientificDataset(Dataset):
    def __init__(self, file_path):
        self.data = pd.read_csv(file_path)
        
    def __len__(self):
        return len(self.data)
        
    def __getitem__(self, idx):
        # Convert row to tensor
        sample = torch.tensor(self.data.iloc[idx, :-1].values, dtype=torch.float32)
        label = torch.tensor(self.data.iloc[idx, -1], dtype=torch.float32)
        return sample, label

dataset = MyScientificDataset("experiment_results.csv")
loader = DataLoader(dataset, batch_size=32, shuffle=True, num_workers=4)

高度な Autograd

物理計算のための勾配（ヤコビアン／ヘッセ行列）

x = torch.linspace(-5, 5, 100, requires_grad=True)
y = x**3

# First derivative dy/dx
# create_graph=True allows for higher-order derivatives
dy_dx = torch.autograd.grad(y.sum(), x, create_graph=True)[0]

# Second derivative (Hessian) d2y/dx2
d2y_dx2 = torch.autograd.grad(dy_dx.sum(), x)[0]

実践的なワークフロー

1. 物理情報を組み込んだニューラルネットワーク（PINN）の例

def pde_loss(model, x):
    """Simple ODE: u'(x) = u(x)."""
    x.requires_grad = True
    u = model(x)
    u_x = torch.autograd.grad(u.sum(), x, create_graph=True)[0]
    return F.mse_loss(u_x, u)

# Training loop combines data_loss + pde_loss

2. 科学計算向けトレーニングでの早期停止

best_loss = float('inf')
patience = 10
counter = 0

for epoch in range(1000):
    train_loss = train_one_epoch()
    val_loss = validate()
    
    if val_loss < best_loss:
        best_loss = val_loss
        torch.save(model.state_dict(), 'best_model.pth')
        counter = 0
    else:
        counter += 1
        if counter >= patience:
            print("Early stopping triggered")
            break

3. 化学分野での特徴抽出

def extract_embeddings(model, loader):
    model.eval()
    embeddings = []
    with torch.no_grad():
        for batch in loader:
            # Assume model has a .get_features() method
            features = model.get_features(batch.to(device))
            embeddings.append(features.cpu())
    return torch.cat(embeddings)

パフォーマンスの最適化

torch.compile の使用（PyTorch 2.0+）

最新のモデルで、1 行のコードによって大幅に高速化できます。

model = MyModel()
compiled_model = torch.compile(model)

混合精度（torch.cuda.amp）

最新の GPU（Tensor Cores）でメモリを節約し、トレーニングを高速化します。

scaler = torch.cuda.amp.GradScaler()

for inputs, labels in loader:
    with torch.cuda.amp.autocast():
        output = model(inputs)
        loss = criterion(output, labels)
    
    scaler.scale(loss).backward()
    scaler.step(optimizer)
    scaler.update()

よくある問題と解決策

勾配の消失／爆発

# ❌ Problem: Loss becomes 'nan' or weights don't update
# ✅ Solution: Use Gradient Clipping
torch.nn.utils.clip_grad_norm_(model.parameters(), max_norm=1.0)

ReLU の不活性化

ニューロンの出力が常に <= 0 の場合、学習が止まります。

# ✅ Solution: Use LeakyReLU or ELU
self.act = nn.LeakyReLU(0.01)

メモリリーク（テンソルがグラフ内に残る）

損失を直接ログに記録すると、グラフ全体がメモリに保持されます。

# ❌ BAD: total_loss += loss
# ✅ GOOD: total_loss += loss.item()

PyTorch は AI 革命を支えるエンジンです。科学者にとって、従来のデータ分析から微分可能なモデルの世界へとつなぐ架け橋となり、これまで見えなかったパターンを発見できるようにします。