学習ループ
PyTorchの学習ループは、モデルを訓練する際の中心的な構造で、各エポックでデータを順番に処理し、勾配を計算・更新する。
- **エポック数**：`num_epochs=100`で、モデルが全学習データを100回見ることを示す。
- **バッチ処理**：`batch_size=64`で、1回の


# データローダー

データローダーは、PyTorchで学習データを効率的に扱うためのモジュールです。`torch.utils.data.DataLoader`を使用し、データセット(`dataset`)をバッチサイズ(`batch_size`)で分割、シャッフル(`shuffle=True`)し、マルチプロセス(`num_workers`)で処理することで高速化を実現します。

**活用例:**
* **画像認識 (PC画像認識AI):** 自作PCで画像認識AIを構築する場合、大量の画像データをDataLoaderに読み込み、GPUへ


PyTorchは、Facebookが開発したオープンソースの機械学習フレームワークで、特に深層学習に適した構造を持つ。Pythonベースで、動的計算グラフ（Dynamic Computation Graph）を特徴とし、Tensorの操作が直感的で、GPUアクセラレーションに対応している。特に、自作PCの性能を最大限に活かすために最適化されており、NVIDIA GeForce RTX 30系（例：RTX


```python
import torchvision.models as models
# 例：ResNet‑50 を使った画像分類
model = models.resnet50(pretrained=True)

from transformers import AutoModel, AutoTokenizer

tokenizer = AutoTokenizer.


```python
import torch.nn.functional as F

class DQN(nn.Module):
    def __init__(self, input_size, hidden_size, output_size):
        super(DQN, self).__init__()
        self.fc1 = nn.Linear(input_size, hidden_size)
        self.fc2 = nn.Linear(hidden_size, hidden_size)
        self.fc3 = nn.Linear(hidden_size, output_size)

    def forward(self, x):
        x = F.relu(self.fc1(x))
        x = F.relu(self.fc2(x))
        x =

# 学習ループ（DQN）

**学習ループ（DQN）**
```python
def optimize_model():
    if len(memory) < BATCH_SIZE: return          # バッファが足りなければ終了
    transitions = memory.sample(BATCH_SIZE


PyTorchのGPU・分散学習セクション

PyTorchは、NVIDIA製GPUを活用した高速な数値計算を強力にサポートします。特に画像認識や自然言語処理といった深層学習モデルでは、GPUの並列処理能力が不可欠です。

**活用例と製品:**

*   **画像認識 (ResNet, YOLO):** 高解像度画像の学習・推論にGPUが必須。NVIDIA GeForce RTX 3060 (約4万円) 以上推奨。RTX 30


```python
PyTorchは、NVIDIAのCUDA互換GPU（例：RTX 3080（10GB/24GB）、RTX 4090（24GB））を活用して機械学習モデルの学習・推論を高速化するフレームワーク。GPUメモリ使用量はモデル次第で2GB〜64GB以上。`torch.cuda.is_available()`で確認し、`model.to('cuda')`でデバイス割

# デバイス設定

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

**PC自作でのGPU選択例**
| GPU | CUDA コア | メモリ | 価格帯 | 推奨用途 |
|-----|-----------|--------|

# データもGPUに移動

PC自作でPyTorchを使う際、GPUを活用するにはデータとモデルをデバイス（通常はGPU）へ移動する必要があります。`data.to(device)`, `target.to(device)`と記述することで、DataLoaderから取得したデータ（画像、テキスト等）とそれに対応するターゲット変数（正解ラベル等）をGPUメモリに転送します。

**使用例：画像分類**
例えば、画像10枚のバッチデータをGPUに移動する場合:

```python
import torch
# ... (モデル定義

# 複数GPU利用

PyTorchは、複数GPU利用をサポートするための`DataParallel`クラスを提供。複数GPUでモデルを並列実行することで、学習速度を向上させられる。例えば、NVIDIA RTX 4090（24GB GDDR6X）を2枚搭載した自作PCでは、`torch.cuda.device_count()`が2を返し、`nn.DataParallel(model)`でモデルを分散実行可能。各GPUは1つのバッチを分割して処


PyTorchは、GPUで高速に学習・推論ができる深層学習フレームワークです。自作PCでの活用を考えると

# マルチプロセス実行

PyTorchのマルチプロセス実行は、GPUを活用した学習を高速化する強力な手段です。`mp.spawn()`関数を用いることで、複数のプロセスでモデルの学習を並行して行うことができます。

**具体的な使用例:**
例えば、画像認識モデルの学習で、GPUメモリが足りず単一プロセスでは学習が完結しない場合。PyTorchのマルチプロセス実行なら、GPUメモリを分割して複数のプロセスで学習を進め、全体を高速化できます。具体的には、画像データのバッチ処理やモデル


PyTorchは、メモリ効率の高いディープラーニングフレームワークで、特にGPUアクセラレーションを活かした機械学習開発に適しています。Intel Core i7-12700K（12コア/20スレッド）やNVIDIA RTX 3080（10GB VRAM）搭載の自作PCで、PyTorchを用いた画像認識モデル（ResNet50）の学習が


| ライブラリ | 用途 |
|------------|------|
| **torchvision** | コンピュータビジョン（画像分類・検出）<br />例：ResNet50で


PyTorchの`torchvision`は、画像認識・処理タスクを効率化するライブラリです。PC自作でGPUを活用し、Deep Learning環境構築時に必須となります。

**活用例：**

*   **画像分類:** 自作PCで構築した環境で、TensorFlowやKerasよりも直感的に画像分類モデルを実装できます。例：ペットの画像を収集し、種類（猫、犬、鳥）を分類するモデル作成。学習済みモデル（ResNet, VGGなど)

# データ変換

```markdown
**データ変換**

PyTorchの`torchvision.transforms`は、画像データをモデル入力に適する形式へ変換するためのモジュール。以下は典型的な変換例：

- `Resize(256)`：入力画像を256×256ピクセルにリサイズ。※実際の推論では224×224にクロップされる。
- `CenterCrop(224)`：中央224×224

# データセット読み込み

dataset = datasets.ImageFolder('path/to/data', transform=transform)
dataloader = DataLoader(dataset, batch_size=32, shuffle=True


PyTorchでは、学習済みモデルを保存・読み込みすることで、学習済みの成果を永続化し、再利用できます。

**保存方法:**
*   `torch.save(model, 'path/to/save.pth')`: モデル全体を`.pth`ファイルとして保存。GPU環境で学習させたモデルも、CPUモードで読み込めます。
*   `torch.save(model.state_dict(), 'path/to/state_dict.pth')`:  状態辞書（state_


```python
PyTorchは、深層学習フレームワークとして、特にモデルの状態辞書（`state_dict`）方式での保存・読み込みが推奨される。これは、モデルの重みや勾配情報などを辞書形式で管理し、メモリ効率と再現性を高める。例えば、`torch.save(model.state_dict(), 'model.pth')`のようにして保存し、`model.load_state_dict(torch.load('model.pth'))`で復元できる。これ

# 保存

torch.save(model.state_dict(), 'model_weights.pth')
・**状態辞書方式（推奨）**：モデルの重みだけを保存し、軽量化。
・例：RTX

# 読み込み

```markdown
PyTorchモデルの読み込みは、学習済みのモデルを実際に活用する上で不可欠です。

**仕組みとコード例:**

`model = Net()` でモデルの定義を行い、`torch.load('model_weights.pth')` でファイルから状態辞書（state dictionary）を読み込みます。この状態辞書は、層の重みやバイアスといった学習済みパラメータを格納しています。`model.load_state_dict()` でモデルに適用することで、学習済み状態を復

# GPU/CPU 間の移動

GPU/CPU 間の移動
PyTorchでは、`model.to('cuda')`や`model.to('cpu')`でモデルを移動。例：NVIDIA RTX 3080（10GB VRAM）で学習後、`model.cuda()`でGPUメモリにロード。メモリ不足時は`model.cpu()`で戻す。Tensorの移動も同様に`tensor.to('cuda')`。16GB RAM搭載のi7

# CPU で保存したモデルをGPU で読み込み

```python
# GPUで推論するためにCPU保存済みモデルを読み込む
model.load_state_dict(torch.load('model_weights.pth', map_location='cuda:0'))

PyTorchのチェックポイントとは、学習途中のモデルの状態（パラメータ、オプティマイザの状態など）を保存する仕組みです。学習中にクラッシュが発生した場合や、後で学習状態を引き継ぎたい場合に非常に有効です。

**活用シーンと自作PCでの選び方:**

*   **学習の継続:** 大規模な画像認識モデル (例: ResNet, EfficientNet - NVIDIA GeForce RTX 3080以上推奨) を学習中にPCが停止した場合でも、チェックポイントから

# 学習状態も含めて保存

```markdown
学習状態も含めて保存

PyTorchのチェックポイントは、モデルの学習状態を保存するための機能で、再開や推論に必要な情報を一括で保持します。典型的な実装は以下の通りです：

```python
checkpoint = {
    'epoch': epoch,
    'model_state_dict': model.state_dict(),
    'optimizer_state_dict': optimizer.state_dict(),
    'loss': loss,
}
torch.save(checkpoint, 'checkpoint.pth')

# 読み込み

# checkpointを保存したときに一緒に残っているのは、モデルの重みだけでなく
# オプティマイザの状態（Adamならm・v）や学習済みエポック数、損失値です。
#


PyTorchの本番環境展開は、研究開発から脱却し、実際にPCで動作させるために不可欠です。

**実践的な活用と選び方:**

*   **用途に応じた選択**: 画像認識、自然言語処理など具体的なタスクに応じて、最適なハードウェア構成を選びます。GPUを活用するには、NVIDIA製のグラフィックボードが必須です。（例：GeForce RTX 4090, 価格帯30万円以上）CPUは、データの前処理や後処理で活躍します。（例：


```python
TorchScriptは、PyTorchモデルを効率的に本番環境に展開するためのコンパイル機能。PythonコードをC++に変換し、高速実行を可能にする。主に以下の2方式で利用可能：


### 1. デコレータ方式（`@torch.jit.script`）
```python
import torch

@torch.jit.script
def simple_func(x):
    return x * 2 + 1

# JITコンパイル後、Python

# トレース方式

model.eval()
example_input = torch.rand(1, 3, 224, 224)
traced_model = torch.jit.trace(model, example_input)
traced_model.save('traced_model.pt')

- **トレース方式**は、実行時にモデルの計算グラフを「追跡」し、固定化した

# スクリプト方式

PyTorchのスクリプト方式は、動的グラフではなく静的グラフにモデルを変換することで、パフォーマンス向上と異なる環境への展開を容易にします。`scripted_model = torch.jit.script(model)`でモデルをスクリプト化し、`scripted_model.save('scripted_model.pt')`で保存。

**使用シーン例:**

*   **高性能推論サーバー構築:** 自作PCをAI推論サーバーとして活用する場合、スクリプト方式でモデルを保存

# 読み込み

**PyTorch JIT（Just-In-Time）コンパイル**は、モデルを高速化するための最適化機能で、`torch.jit.load()`で保存された`.pt`ファイルを読み込みます。
- **仕組み**：トレースされたモデルは、入力形状（例：`torch.Size([1, 3, 224, 224])`）を保持し、


```python
import torch.onnx

# PyTorch モデルを ONNX に変換する例
model = MyModel()
dummy_input = torch.randn(1, 3, 224, 224)
torch.onnx.export(model, dummy_input, "model.onnx")

import onnxruntime as ort
session = ort.InferenceSession('model.onnx')

JITコンパイルは、PyTorchの実行時最適化手法で、Pythonコードを高速なC++コンパイルコードに変換する。実行時にモデルの計算グラフを最適化し、メモリ使用量を削減。例として、NVIDIA RTX 4090（24GB GDDR6X）での推論速度が15%向上。`torch.jit.script`でモデルをコンパイル可能。Intel Core i7

# @torch.jit.script デコレータ

@torch.jit.script
```python
@torch.jit.script
def fused_gelu(x):
    return x * 0.5 * (1.0 + torch.erf(x / 1.41421))

PyTorchで勾配を確認するには、`torch.autograd.gradcheck` を使い、数値微分と自動微分の結果が一致するか検証します。

# 勾配爆発・消失チェック

勾配確認セクションの続きとして、PyTorchにおける勾配爆発・消失チェックは、学習の安定性を確認する上で不可欠です。

**勾配爆発・消失チェックとは？**

深層学習モデル、特にRNNやTransformerなどの再帰型ネットワークにおいて発生しやすい問題です。勾配が極端に大きくなると（爆発）、学習が不安定になり、逆に小さくなりすぎると（消失）学習が進まなくなります。

**具体的な使用例と実装例**

```python
for

# 勾配クリッピング

勾配クリッピングは、PyTorchにおける勾配爆発を防ぐための技術で、`torch.nn.utils.clip_grad_norm_()`関数を使用して実装される。この関数は、モデルパラメータの勾配ノルムを指定された最大値（例：`max_norm=1.0`）でクリップする。例えば、`clip_grad_norm_(model.parameters(), max_norm=1.0)`は、勾配ノルムが1.0を超える


# 結果出力

PyTorchプロファイラーの結果出力には、`print(prof.key_averages().table(sort_by="cuda_time_total"))` が代表的です。このコードは、GPU (CUDA) 時間の総量に基づきソートされたテーブルを出力し、ボトルネック特定に役立ちます。

**具体的な活用と出力例:**

*   **画像認識モデルの学習時:** モデルの各層（例：畳み込み層、全結合層）におけるCUDA時間を確認し、計算負荷の高い


- **[TensorFlow](/glossary/tensorflow)**: Google開発の機械学習フレームワーク。v2.15以降はTensorFlow LiteでIoTデバイス向けにも対応。PyTorchと比較し、TensorBoardによる可視化が強みで、生産性重視の開発に適する。
- **[Neural Network](/glossary/neural-network)**: 人間の脳構造を模�