Day 111 — PyTorch入門① — Tensor・自動微分の仕組み

📚 背景知識（読んでから問題へ）

numpyとPyTorchの関係

これまで使ってきた numpy の配列（ndarray）と、PyTorchの配列（Tensor）は、見た目も使い方もほぼ同じです。違いは1点だけ ── PyTorchのTensorは「自分がどんな計算を経てこの値になったか」という計算の履歴（計算グラフ）を裏側で記録できるという点です。この記録機能を自動微分（autograd）と呼びます。

🗂️ ndarray ⇔ Tensor 対応表

まず「何が同じで、何が違うのか」をデータ構造のレベルで整理します。

🕸️ 計算グラフのイメージ: y = w*x + b → loss

タスク3で使う loss = (w*x + b - target)^2 の計算を、PyTorchが裏側でどう記録しているかを図にしたものです。矢印は「順伝播」の向き、点線は .backward() が勾配を流す「逆伝播」の向きを表します。

🎯 問題

💡 ヒント

import torch
import torch.nn as nn

# --- タスク3: 自動微分の確認 ---
x = torch.tensor(2.0)
w = torch.tensor(3.0, requires_grad=True)
b = torch.tensor(1.0, requires_grad=True)
target = torch.tensor(10.0)

y_pred = w * x + b
loss = (y_pred - target) ** 2
loss.backward()
print(w.grad, b.grad)

# --- タスク4: XORをnn.Moduleで学習 ---
X = torch.tensor([[0.,0.],[0.,1.],[1.,0.],[1.,1.]])
y = torch.tensor([[0.],[1.],[1.],[0.]])

class XORNet(nn.Module):
    def __init__(self):
        super().__init__()
        self.hidden = nn.Linear(2, 2)
        self.output = nn.Linear(2, 1)

    def forward(self, x):
        h = torch.sigmoid(self.hidden(x))
        out = torch.sigmoid(self.output(h))
        return out

model = XORNet()
criterion = nn.BCELoss()
optimizer = torch.optim.SGD(model.parameters(), lr=0.5)

for epoch in range(5000):
    optimizer.zero_grad()
    pred = model(X)
    loss = criterion(pred, y)
    loss.backward()
    optimizer.step()

✅ 模範解答

タスク1: なぜTensorという独自の型が必要か

タスク2: Tensorの基本操作

import torch
import numpy as np

# 1. Tensor作成とshape確認
t = torch.tensor([[1, 2, 3], [4, 5, 6]])
print(t.shape)          # torch.Size([2, 3])
# numpyなら: np.array([[1,2,3],[4,5,6]]).shape → (2, 3)

# 2. 転置とreshape
t_T = t.T
print(t_T.shape)        # torch.Size([3, 2])
t_flat = t.reshape(-1)  # 1次元に変形（numpyのreshape(-1)と同じ）
print(t_flat)            # tensor([1, 2, 3, 4, 5, 6])

# 3. numpy ⇔ Tensor 相互変換
arr = np.array([1.0, 2.0, 3.0])
t_from_np = torch.from_numpy(arr)   # ndarray → Tensor
print(t_from_np)

back_to_np = t_from_np.numpy()      # Tensor → ndarray
print(back_to_np, type(back_to_np))

タスク3: 自動微分と手計算の照合

import torch

x = torch.tensor(2.0)
w = torch.tensor(3.0, requires_grad=True)
b = torch.tensor(1.0, requires_grad=True)
target = torch.tensor(10.0)

y_pred = w * x + b        # 7.0
loss = (y_pred - target) ** 2  # (7-10)^2 = 9.0

loss.backward()
print(f"PyTorchが計算した dLoss/dw: {w.grad.item()}")  # -12.0
print(f"PyTorchが計算した dLoss/db: {b.grad.item()}")  # -6.0

.backward()が行っているのは、まさにこの連鎖律の展開を全自動でやっているだけだと確認できます。

タスク4: XORをPyTorchで学習させる

import torch
import torch.nn as nn

X = torch.tensor([[0., 0.], [0., 1.], [1., 0.], [1., 1.]])
y = torch.tensor([[0.], [1.], [1.], [0.]])

class XORNet(nn.Module):
    def __init__(self):
        super().__init__()
        self.hidden = nn.Linear(2, 2)   # 入力2 → 隠れ2（重み・バイアスはランダム初期化）
        self.output = nn.Linear(2, 1)   # 隠れ2 → 出力1

    def forward(self, x):
        h = torch.sigmoid(self.hidden(x))
        out = torch.sigmoid(self.output(h))
        return out

torch.manual_seed(42)
model = XORNet()
criterion = nn.BCELoss()                          # 二値分類用の損失関数
optimizer = torch.optim.SGD(model.parameters(), lr=0.5)

for epoch in range(5000):
    optimizer.zero_grad()
    pred = model(X)
    loss = criterion(pred, y)
    loss.backward()
    optimizer.step()

    if epoch % 1000 == 0:
        acc = ((pred > 0.5).float() == y).float().mean()
        print(f"epoch {epoch:4d}  loss={loss.item():.4f}  acc={acc.item():.2f}")

final_pred = model(X)
final_acc = ((final_pred > 0.5).float() == y).float().mean()
print(f"\n最終正解率: {final_acc.item():.2f}")

Day 110では「OR＝h1、NAND＝h2」と自分で決め打ちしましたが、今回は torch.manual_seed(42) によるランダムな初期値から出発し、勾配降下法だけで自動的に同じ役割を果たす重みへ収束していきます。

🕸️ 今日「学習」させたネットワークの構造

Day 110では人間が「h1=OR、h2=NAND」と設計しましたが、今回は nn.Linear がランダムな初期値からスタートし、optimizer.step() の繰り返しだけで同じ役割を果たす重みへ自動的に近づいていきます。

📊 学習曲線: lossが下がり、正解率が1.0に収束する様子

5000エポックの学習ループの中で、1000エポックごとに記録したlossの推移です（縦軸は対数スケール寄りに強調表示。値が小さいほどグラフの下側に位置します）。

🪜 Step-by-Step 解説

1Tensorはnumpyの「記憶力付きバージョン」と捉える

t = torch.tensor([[1, 2, 3], [4, 5, 6]])

2requires_grad=True で計算履歴の記録を開始する

w = torch.tensor(3.0, requires_grad=True)

3.backward() で連鎖律を自動的に逆向きにたどる

loss.backward()
print(w.grad)

4nn.Module でネットワークの「形」を定義する

class XORNet(nn.Module):
    def __init__(self):
        super().__init__()
        self.hidden = nn.Linear(2, 2)
        self.output = nn.Linear(2, 1)
    def forward(self, x):
        h = torch.sigmoid(self.hidden(x))
        return torch.sigmoid(self.output(h))

5学習ループの「型」を繰り返す

optimizer.zero_grad()
pred = model(X)
loss = criterion(pred, y)
loss.backward()
optimizer.step()

🧮 数学・統計の補足（文系向け）

🏆 Kaggleでの実践的な使い方

よく使われるコンペカテゴリ: ☐ 表形式データ（Tabular） / ☑ 自然言語処理（NLP） / ☑ 画像認識（CV） / ☑ 時系列（Time Series）

⚠️ よくある誤解・ミス

🚀 次のステップ

• 発展: torch.optim.SGD を torch.optim.Adam に変えて、同じXORタスクが何エポックで収束するか比較してみましょう。学習率 lr を大きく／小さくすると収束の速さがどう変わるかも確認してみてください
• 次回予告: Day 112 — PyTorch入門②（Dataset・DataLoader・本格的な学習ループ）。今日は4行だけのXORデータを直接扱いましたが、実際のKaggleコンペでは数万〜数百万行のデータをミニバッチに分けて学習する必要があります。Dataset と DataLoader を使い、表形式データをバッチ処理する本格的な学習パイプラインを組みます

Phase 5 の学習マップ（全20テーマ予定）

本日（Day 111）は「1-5 DL基礎」の2テーマ目。Day 110で理解した仕組みを、今日はPyTorchの型に落とし込んだ。次回はミニバッチ処理を伴う実務的な学習パイプラインへ進む。

📝 自己評価（解いた後に記入）