詳解 PyTorch: Pythonicな深層学習ライブラリの徹底ガイド 🚀

1. テンソル (Tensor)

テンソルはPyTorchにおける最も基本的なデータ構造であり、多次元配列です。これは数学や物理学におけるテンソルとは少し異なり、より具体的にはNumPyの `ndarray` に非常によく似ています。ベクトル（1次元テンソル）、行列（2次元テンソル）、そしてそれ以上の次元を持つデータを表現できます。

PyTorchテンソルの大きな特徴は、GPU上での計算をサポートしている点です。`.to(device)` メソッドを使うことで、テンソルをCPUとGPU間で簡単に移動させることができます。

テンソルの作成

import torch

# データから直接テンソルを作成
data = [[1, 2], [3, 4]]
x_data = torch.tensor(data)
print(f"Data Tensor:\n {x_data}\n")

# NumPy配列からテンソルを作成
import numpy as np
np_array = np.array(data)
x_np = torch.from_numpy(np_array)
print(f"NumPy Tensor:\n {x_np}\n")

# 他のテンソルに基づいて新しいテンソルを作成 (形状とデータ型を保持)
x_ones = torch.ones_like(x_data) # x_dataと同じ形状で要素が全て1のテンソル
print(f"Ones Tensor:\n {x_ones}\n")
x_rand = torch.rand_like(x_data, dtype=torch.float) # x_dataと同じ形状で乱数 (float型)
print(f"Random Tensor:\n {x_rand}\n")

# 指定した形状でテンソルを作成
shape = (2, 3,)
rand_tensor = torch.rand(shape)
ones_tensor = torch.ones(shape)
zeros_tensor = torch.zeros(shape)

print(f"Random Tensor (shape {shape}):\n {rand_tensor}\n")
print(f"Ones Tensor (shape {shape}):\n {ones_tensor}\n")
print(f"Zeros Tensor (shape {shape}):\n {zeros_tensor}\n")

テンソルの属性

テンソルは形状 (shape)、データ型 (dtype)、そしてデータが格納されているデバイス (device) の属性を持ちます。

tensor = torch.rand(3, 4)

print(f"Shape of tensor: {tensor.shape}")
print(f"Datatype of tensor: {tensor.dtype}")
print(f"Device tensor is stored on: {tensor.device}")

テンソル演算

NumPyと同様に、豊富な演算がサポートされています。インデックス操作、算術演算、線形代数、統計処理などが可能です。

# GPUが利用可能か確認し、デバイスを設定
if torch.cuda.is_available():
    device = torch.device("cuda")
else:
    device = torch.device("cpu")
print(f"Using {device} device")

tensor = torch.ones(4, 4, device=device) # デバイスを指定して作成

# NumPyライクなインデックス操作
print('First row: ', tensor[0])
print('First column: ', tensor[:, 0])
print('Last column:', tensor[..., -1])
tensor[:,1] = 0 # 2列目を全て0にする
print("Tensor after modification:\n", tensor)

# テンソルの結合 (Concatenation)
t1 = torch.cat([tensor, tensor, tensor], dim=1)
print("Concatenated Tensor:\n", t1)

# 算術演算
# これは要素ごとの積 (element-wise product)
print(f"tensor.mul(tensor): \n {tensor.mul(tensor)} \n")
# または: tensor * tensor

# これは行列積 (matrix multiplication)
print(f"tensor.matmul(tensor.T): \n {tensor.matmul(tensor.T)} \n")
# または: tensor @ tensor.T

# 単一要素テンソルからPythonの数値を取得
agg = tensor.sum()
agg_item = agg.item()
print(agg_item, type(agg_item))

# インプレース演算 (元のテンソルを変更する演算、接尾辞 `_` がつく)
print(f"Original Tensor:\n {tensor}\n")
tensor.add_(5) # 各要素に5を加算
print(f"Tensor after add_(5):\n {tensor}\n")

注意: インプレース演算はメモリを節約できますが、後述する自動微分の計算に必要な情報を破壊してしまう可能性があるため、注意が必要です。特に勾配計算が必要なテンソルに対するインプレース演算は避けるべきです。

2. 自動微分 (Autograd)

torch.autograd はPyTorchの自動微分エンジンであり、ニューラルネットワークの学習プロセスの中核をなす機能です。モデルのパラメータに関する損失関数の勾配（偏微分）を自動的に計算してくれます。これにより、開発者は複雑な勾配計算を手動で行う必要がなくなり、モデル構築に集中できます。

Autogradは、テンソルに対する全ての演算を追跡し、計算グラフ (Computation Graph) を動的に構築します。このグラフは有向非巡回グラフ (DAG) で、ノードがテンソル、エッジがテンソルを生み出した関数（演算）を表します。フォワードパス（順伝播）でこのグラフが構築され、バックワードパス（逆伝播）で .backward() メソッドが呼ばれると、グラフを逆向きに辿って連鎖律に基づき勾配が計算されます。

勾配計算の有効化

テンソルを作成する際に requires_grad=True を設定すると、そのテンソルに対する演算が追跡され、勾配計算の対象となります。モデルの学習可能なパラメータ（重みやバイアス）は通常、このフラグが True に設定されます。

import torch

# requires_grad=True を設定してテンソルを作成
x = torch.ones(2, 2, requires_grad=True)
print(f"x:\n {x}")

# xに対する演算を行う
y = x + 2
print(f"y:\n {y}") # yも自動的にrequires_grad=Trueとなり、grad_fnを持つ

# yに対する演算
z = y * y * 3
out = z.mean()

print(f"z:\n {z}")
print(f"out:\n {out}")

各テンソルは .grad_fn 属性を持ちます。これは、そのテンソルを生成した関数（演算）への参照です。ユーザーが直接作成したテンソル（グラフの葉、leaf node）の grad_fn は None です。

勾配の計算 (バックプロパゲーション)

.backward() メソッドをスカラー値（通常は損失関数の出力）を持つテンソルに対して呼び出すと、Autogradはグラフを辿って各葉ノード (requires_grad=True を持つテンソル) に対する勾配を計算し、それらを各テンソルの .grad 属性に蓄積します。

# out (スカラー値) からバックプロパゲーションを実行
out.backward()

# xの勾配 d(out)/dx を表示
print(f"Gradient of x (d(out)/dx):\n {x.grad}")

この例では、out = (1/4) * Σ 3 * (x_i + 2)^2 なので、d(out)/dx_i = (1/4) * 6 * (x_i + 2) です。x_i = 1 なので、d(out)/dx_i = (1/4) * 6 * 3 = 18/4 = 4.5 となり、x.grad は全ての要素が4.5のテンソルになります。

勾配追跡の停止

モデルの評価時や、勾配が不要な演算を行う場合など、勾配の追跡を一時的に停止したい場合があります。これには torch.no_grad() コンテキストマネージャを使用します。

print(f"x requires grad: {x.requires_grad}")
y = x * 2
print(f"y requires grad: {y.requires_grad}")

with torch.no_grad():
    z = x * 2
    print(f"z requires grad (inside no_grad): {z.requires_grad}")

# .detach() メソッドでも勾配追跡から切り離すことができる
w = x.detach()
print(f"w requires grad (detached): {w.requires_grad}")

ヒント: デフォルトでは、.backward() を呼び出すと計算グラフは破棄されます。複数の .backward() 呼び出しを行いたい場合（例えば、異なる損失に対する勾配を計算したい場合など）は、最初の .backward() 呼び出し時に retain_graph=True を指定する必要があります。ただし、これはメモリ使用量を増やす可能性があります。 また、torch.autograd.grad() は .backward() と似ていますが、勾配を .grad 属性に蓄積せず、直接勾配テンソルを返す点が異なります。

3. ニューラルネットワークモジュール (torch.nn)

torch.nn パッケージは、ニューラルネットワークを構築するための基本的な部品（レイヤー、活性化関数、損失関数など）を提供します。PyTorchでモデルを構築する際の中心となるのが nn.Module クラスです。

カスタムのニューラルネットワークは、通常 nn.Module を継承して定義します。この基底クラスは、モデルのパラメータ（学習可能な重みやバイアス）を追跡したり、モデル全体をCPU/GPU間で移動させたり、状態を保存・ロードしたりするための便利な機能を提供します。

カスタムモデルの定義

モデルクラスを定義する際には、主に2つのメソッドを実装します。

• __init__(self): モデル内で使用するレイヤーやその他のモジュールを初期化して定義します。ここで定義された nn.Module のサブモジュール（例: nn.Linear, nn.Conv2d）は自動的に登録され、パラメータが追跡されます。注意: サブモジュールを属性として代入する前に、必ず super().__init__() を呼び出す必要があります。
• forward(self, x): 入力データ x を受け取り、モデルの順伝播計算を実行して出力を返すロジックを定義します。このメソッド内で、__init__ で定義したレイヤーや、torch.nn.functional (通常 F としてインポートされる) の関数（例: 活性化関数 F.relu）を使用します。

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

class SimpleNet(nn.Module):
    def __init__(self):
        super(SimpleNet, self).__init__()
        # 畳み込み層1: 入力チャネル1, 出力チャネル6, カーネルサイズ5x5
        self.conv1 = nn.Conv2d(1, 6, 5)
        # 畳み込み層2: 入力チャネル6, 出力チャネル16, カーネルサイズ5x5
        self.conv2 = nn.Conv2d(6, 16, 5)
        # 全結合層1: 入力次元 16 * 5 * 5, 出力次元 120
        self.fc1 = nn.Linear(16 * 5 * 5, 120) # 画像サイズに依存する入力次元
        # 全結合層2: 入力次元 120, 出力次元 84
        self.fc2 = nn.Linear(120, 84)
        # 全結合層3: 入力次元 84, 出力次元 10 (クラス数)
        self.fc3 = nn.Linear(84, 10)

    def forward(self, x):
        # 入力 x は (バッチサイズ, チャネル数, 高さ, 幅) を想定
        # 畳み込み -> ReLU -> プーリング (2x2)
        x = F.max_pool2d(F.relu(self.conv1(x)), (2, 2))
        # 畳み込み -> ReLU -> プーリング (2x2)
        x = F.max_pool2d(F.relu(self.conv2(x)), 2) # カーネルサイズが正方形ならタプルでなく整数でもOK
        # Flatten: バッチ次元以外の次元を1次元に平坦化
        x = torch.flatten(x, 1) # start_dim=1 はバッチ次元を残すため
        # 全結合層 -> ReLU
        x = F.relu(self.fc1(x))
        # 全結合層 -> ReLU
        x = F.relu(self.fc2(x))
        # 全結合層 (出力層: 通常、活性化関数は損失関数に含まれることが多い)
        x = self.fc3(x)
        return x

# モデルのインスタンスを作成
net = SimpleNet()
print(net)

# モデルのパラメータを確認
for name, param in net.named_parameters():
    if param.requires_grad:
        print(f"Layer: {name}, Size: {param.size()}")

一般的なレイヤーと関数

torch.nn には様々なレイヤーが用意されています。

• 畳み込み層: nn.Conv1d, nn.Conv2d, nn.Conv3d
• プーリング層: nn.MaxPool2d, nn.AvgPool2d, nn.AdaptiveAvgPool2d
• 全結合層 (線形層): nn.Linear
• 活性化関数 (レイヤー形式): nn.ReLU, nn.Sigmoid, nn.Tanh, nn.Softmax (torch.nn.functional にも関数形式があります)
• 正規化層: nn.BatchNorm2d, nn.LayerNorm
• リカレント層: nn.RNN, nn.LSTM, nn.GRU
• ドロップアウト層: nn.Dropout
• 損失関数: nn.MSELoss, nn.CrossEntropyLoss, nn.BCELoss など

活性化関数など、内部状態（パラメータ）を持たない操作の多くは torch.nn.functional モジュールに関数としても提供されています。どちらを使うかは好みの問題やコードの構造によりますが、一般的にパラメータを持つものは nn.Module、持たないものは functional を使うことが多いです。

4. オプティマイザ (torch.optim)

torch.optim パッケージは、ニューラルネットワークのパラメータ（重みとバイアス）を更新するための様々な最適化アルゴリズム（オプティマイザ）を実装しています。モデルが予測を行い、損失関数が誤差を計算した後、オプティマイザがその誤差（勾配情報を使用）に基づいてパラメータを調整し、モデルの性能を改善します。

一般的な最適化アルゴリズムには、SGD (確率的勾配降下法)、Adam、RMSprop、Adagradなどがあります。PyTorchでは、これらのアルゴリズムが簡単に利用できます。

オプティマイザの作成と使用

オプティマイザを作成するには、最適化対象のパラメータ（通常は model.parameters() で取得）と、学習率 (learning rate, lr) などのハイパーパラメータを指定します。

import torch.optim as optim

# 上で定義した SimpleNet のインスタンス
net = SimpleNet()

# 最適化アルゴリズムを選択 (例: SGD)
# net.parameters() でモデルの全学習可能パラメータを取得
# lr は学習率 (Learning Rate)
optimizer = optim.SGD(net.parameters(), lr=0.01, momentum=0.9)

# 別の例: Adam オプティマイザ
# optimizer = optim.Adam(net.parameters(), lr=0.001)

学習ループにおけるオプティマイザの役割

典型的な学習ループでは、以下のステップでオプティマイザを使用します。

1. 勾配の初期化 (optimizer.zero_grad()): 新しいバッチで勾配を計算する前に、前のバッチで計算された勾配をクリアします。PyTorchでは勾配はデフォルトで加算 (accumulate) されるため、このステップは重要です。
2. 順伝播 (outputs = model(inputs)): 入力データをモデルに通して予測値を得ます。
3. 損失の計算 (loss = criterion(outputs, labels)): 予測値と正解ラベルを使って損失関数を計算します。
4. 逆伝播 (loss.backward()): 損失に基づいて、モデルの全パラメータに関する勾配を計算します (Autogradが担当)。
5. パラメータの更新 (optimizer.step()): 計算された勾配に基づいて、オプティマイザがモデルのパラメータを更新します。

# ダミーデータとラベルを作成
inputs = torch.randn(1, 1, 32, 32) # バッチサイズ1, チャネル1, 32x32画像
labels = torch.randint(0, 10, (1,)) # 0から9のランダムなラベル (バッチサイズ1)

# 損失関数を定義 (例: 交差エントロピー)
criterion = nn.CrossEntropyLoss()

# --- 学習ループの1ステップ ---
# 1. 勾配をゼロに初期化
optimizer.zero_grad()

# 2. 順伝播
outputs = net(inputs)

# 3. 損失の計算
loss = criterion(outputs, labels)
print(f"Calculated Loss: {loss.item()}")

# 4. 逆伝播 (勾配計算)
loss.backward()

# 5. パラメータの更新
optimizer.step()
# --- ここまでが1ステップ ---

# 更新後のパラメータを確認 (一部)
print("Weight of conv1 after one step:", net.conv1.weight.data[0][0][0])

重要: optimizer.step() を呼び出す前に必ず loss.backward() を呼び出して勾配を計算しておく必要があります。また、各イテレーションの開始時に optimizer.zero_grad() を呼び出すことを忘れないでください。

また、LBFGSなどの一部の最適化アルゴリズムは、複数回の関数評価（損失計算）を必要とする場合があります。その場合、損失計算と勾配クリアを含むクロージャ（関数）を optimizer.step() に渡す必要があります。

1. Dataset

torch.utils.data.Dataset は、データセットを表す抽象クラスです。カスタムデータセットを作成するには、このクラスを継承し、以下の2つのメソッドをオーバーライド（実装）する必要があります。

• __len__(self): データセットの総サンプル数を返すように実装します。Pythonの組み込み関数 len() で呼び出されます (例: len(dataset))。
• __getitem__(self, idx): 指定されたインデックス idx に対応する1つのデータサンプル（通常はデータとそのラベルのペア）を取得して返すように実装します。Pythonのインデックスアクセス (例: dataset[idx]) で呼び出されます。

PyTorchには主に2種類のデータセットがあります。

• マップスタイルデータセット (Map-style datasets): __getitem__() と __len__() を実装し、インデックス idx からサンプルへのマッピング（ランダムアクセス）を提供するデータセット。torch.utils.data.Dataset のサブクラスがこれにあたります。
• イテラブルスタイルデータセット (Iterable-style datasets): __iter__() を実装し、データサンプル上のイテレータを返すデータセット。torch.utils.data.IterableDataset のサブクラスがこれにあたります。ストリーミングデータなどに適しています。

ここでは、より一般的なマップスタイルデータセットの例を示します。

import torch
from torch.utils.data import Dataset
import os
import pandas as pd
# from torchvision.io import read_image # 画像を読み込む場合

# 例: 画像ファイルとそのラベルを持つカスタムデータセット
class CustomImageDataset(Dataset):
    # annotation_file: 画像ファイルパスとラベルが記載されたCSVファイルへのパス
    # img_dir: 画像ファイルが格納されているディレクトリへのパス
    # transform: 画像に適用する前処理 (オプション)
    # target_transform: ラベルに適用する前処理 (オプション)
    def __init__(self, annotations_file, img_dir, transform=None, target_transform=None):
        self.img_labels = pd.read_csv(annotations_file) # CSVファイルを読み込む
        self.img_dir = img_dir
        self.transform = transform
        self.target_transform = target_transform

    def __len__(self):
        return len(self.img_labels) # CSVファイルの行数 (サンプル数) を返す

    def __getitem__(self, idx):
        # idx番目の画像のファイルパスを構築
        img_path = os.path.join(self.img_dir, self.img_labels.iloc[idx, 0])
        # 画像を読み込む (ここではダミーとしてテンソルを作成)
        # image = read_image(img_path)
        image = torch.randn(3, 64, 64) # ダミー画像データ (3チャネル, 64x64)
        # idx番目のラベルを取得
        label = self.img_labels.iloc[idx, 1]
        # もし transform が指定されていれば、画像に適用
        if self.transform:
            image = self.transform(image)
        # もし target_transform が指定されていれば、ラベルに適用
        if self.target_transform:
            label = self.target_transform(label)
        return image, label

# 使用例 (ダミーのファイルとディレクトリを仮定)
# dataset = CustomImageDataset(annotations_file='labels.csv', img_dir='images/')
# first_image, first_label = dataset[0] # 最初のサンプルを取得
# print(f"Image shape: {first_image.shape}, Label: {first_label}")
# print(f"Dataset size: {len(dataset)}")

2. DataLoader

torch.utils.data.DataLoader は、Dataset をラップし、データセットに対するイテラブル（繰り返し可能なオブジェクト）を提供します。DataLoader は、以下のような複雑な処理を簡単なAPIで抽象化してくれます。

• バッチ処理 (Batching): データを指定されたサイズのミニバッチにまとめて供給します。
• シャッフル (Shuffling): 各エポックの開始時にデータをシャッフルし、モデルの過学習を抑制します。
• マルチプロセスデータロード (Multiprocessing): Pythonの multiprocessing を使用して、複数のワーカープロセスで並行してデータをロードし、データ準備のボトルネックを解消します。
• メモリピニング (Memory Pinning): pin_memory=True を設定すると、ロードされたテンソルをCUDAのピンドメモリ（Pinned Memory）に配置し、GPUへのデータ転送を高速化できます。

from torch.utils.data import DataLoader

# 上で定義した (あるいは組み込みの) Dataset オブジェクトを準備
# 例として、ランダムなテンソルを返すダミーデータセットを作成
class DummyDataset(Dataset):
    def __init__(self, num_samples=1000):
        self.num_samples = num_samples

    def __len__(self):
        return self.num_samples

    def __getitem__(self, idx):
        # ダミーデータとダミーラベルを返す
        data = torch.randn(3, 32, 32) # 3x32x32 のデータ
        label = torch.randint(0, 10, (1,)).item() # 0-9 のラベル
        return data, label

train_dataset = DummyDataset(num_samples=100)
test_dataset = DummyDataset(num_samples=50)

# DataLoaderを作成
batch_size = 64
train_dataloader = DataLoader(train_dataset, batch_size=batch_size, shuffle=True, num_workers=4, pin_memory=torch.cuda.is_available())
test_dataloader = DataLoader(test_dataset, batch_size=batch_size, shuffle=False, num_workers=4, pin_memory=torch.cuda.is_available())

# DataLoaderの使用 (学習ループ内での典型的な使い方)
num_epochs = 5
for epoch in range(num_epochs):
    print(f"Epoch {epoch+1}\n-------------------------------")
    # 学習データでのループ
    for batch, (X, y) in enumerate(train_dataloader):
        # Xとyはそれぞれバッチサイズ分のデータとラベルを含むテンソル
        # X shape: [batch_size, 3, 32, 32], y shape: [batch_size]

        # GPUが利用可能ならデータをGPUに送る (pin_memory=Trueなら転送が速い)
        if torch.cuda.is_available():
             X, y = X.cuda(), y.cuda()

        # ここでモデルの学習処理を行う (順伝播、損失計算、逆伝播、パラメータ更新)
        # model.train()
        # outputs = model(X)
        # loss = criterion(outputs, y)
        # optimizer.zero_grad()
        # loss.backward()
        # optimizer.step()

        if batch % 10 == 0: # 例: 10バッチごとに進捗を表示
             # loss = loss.item() # 現在のバッチの損失を取得
             current = (batch + 1) * len(X)
             total = len(train_dataloader.dataset)
             print(f"  Batch {batch+1}: [{current:>5d}/{total:>5d}]") # 仮の進捗表示

    # エポック終了後、テストデータで評価などを行う
    # model.eval()
    # with torch.no_grad():
    #     for X, y in test_dataloader:
    #         ...

print("Training finished!")

num_workers を1以上に設定すると、データローディングがバックグラウンドの別プロセスで行われるため、メインプロセス（GPUでの計算など）をブロックせずに済み、特にデータの前処理が重い場合に学習全体の速度向上に繋がります。num_workers の適切な値はシステム構成（CPUコア数など）に依存します。

1. 状態辞書 (state_dict) の保存とロード

state_dict は、モデルの各レイヤーとそのパラメータ（weight と bias）をマッピングするPython辞書です。

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

# 上で定義した SimpleNet モデルを使用
model = SimpleNet()
optimizer = optim.SGD(model.parameters(), lr=0.001, momentum=0.9)

# モデルの状態辞書を表示 (例)
print("Model's state_dict:")
for param_tensor in model.state_dict():
    print(param_tensor, "\t", model.state_dict()[param_tensor].size())

# オプティマイザの状態辞書も保存できる (学習率などを含む)
print("\nOptimizer's state_dict:")
for var_name in optimizer.state_dict():
    # state_dict は少し複雑な構造を持つことがある
    if isinstance(optimizer.state_dict()[var_name], dict):
         print(var_name, "\t", {k: v.size() if isinstance(v, torch.Tensor) else v for k,v in optimizer.state_dict()[var_name].items()})
    else:
         print(var_name, "\t", optimizer.state_dict()[var_name])


# --- 保存 ---
# モデルの state_dict のみを保存する場合 (推奨)
PATH = "simple_net_statedict.pth"
torch.save(model.state_dict(), PATH)

# 学習のチェックポイントとして保存する場合 (モデルとオプティマイザ、エポック数など)
EPOCH = 5
LOSS = 0.4
CHECKPOINT_PATH = "model_checkpoint.pth"
torch.save({
            'epoch': EPOCH,
            'model_state_dict': model.state_dict(),
            'optimizer_state_dict': optimizer.state_dict(),
            'loss': LOSS,
            }, CHECKPOINT_PATH)


# --- ロード ---

# state_dict をロードする場合
# 1. まずモデルのインスタンスを作成
load_model = SimpleNet()
# 2. 保存した state_dict をロード
load_model.load_state_dict(torch.load(PATH))
# 3. 推論を行う場合は、必ず model.eval() を呼び出す
load_model.eval()
# あとは load_model を推論に使用できる


# チェックポイントをロードする場合
load_checkpoint_model = SimpleNet()
load_optimizer = optim.SGD(load_checkpoint_model.parameters(), lr=0.001, momentum=0.9) # オプティマイザも再作成

checkpoint = torch.load(CHECKPOINT_PATH)
load_checkpoint_model.load_state_dict(checkpoint['model_state_dict'])
load_optimizer.load_state_dict(checkpoint['optimizer_state_dict'])
epoch = checkpoint['epoch']
loss = checkpoint['loss']

# 学習を再開する場合は model.train() を呼び出す
# load_checkpoint_model.train()
# 推論なら model.eval()
load_checkpoint_model.eval()

print(f"\nCheckpoint loaded: Epoch {epoch}, Loss {loss}")

model.eval() は、モデルを評価モードに設定します。これにより、DropoutやBatchNormなどのレイヤーが学習時とは異なる振る舞い（Dropoutが無効化され、BatchNormが学習済み統計量を使用）をするようになります。推論時には必ず呼び出すべきです。学習を再開する場合は model.train() を呼び出して学習モードに戻します。

2. モデル全体の保存とロード

モデル構造全体を保存するには、torch.save にモデルオブジェクト自体を渡します。

# --- 保存 ---
# モデル全体を保存
FULL_MODEL_PATH = "simple_net_full.pth"
torch.save(model, FULL_MODEL_PATH)


# --- ロード ---
# モデル全体をロード
# この場合、モデルクラス (SimpleNet) の定義が利用可能である必要がある
loaded_full_model = torch.load(FULL_MODEL_PATH)
loaded_full_model.eval() # 推論モードに設定

# これで loaded_full_model を使用できる

この方法はシンプルですが、ロード時に元のクラス定義が必要であり、コードの変更に弱いという欠点があります。そのため、一般的には state_dict を使う方法が推奨されます。