【仕組み解説】逆伝播と更新のサイクルを実装：「心臓部」の動きを理解（NN #10）

class Affine:
    def __init__(self, W, b):
        self.W = W
        self.b = b
        self.x = None
        self.dW = None
        self.db = None

    def forward(self, x):
        self.x = x
        return torch.matmul(x, self.W) + self.b

    def backward(self, dout):
        dx = torch.matmul(dout, self.W.t())
        self.dW = torch.matmul(self.x.t(), dout)
        self.db = torch.sum(dout, dim=0)
        return dx

class Relu:
    def __init__(self):
        self.mask = None

    def forward(self, x):
        self.mask = (x <= 0)
        out = x.clone()
        out[self.mask] = 0
        return out

    def backward(self, dout):
        dout[self.mask] = 0
        return dout

# 【NEW】損失関数：平均2乗誤差 (Mean Squared Error)
class MSE:
    def __init__(self):
        self.y = None
        self.t = None
        
    def forward(self, y, t):
        self.y = y
        self.t = t
        # Loss = 0.5 * (y - t)^2 の合計
        loss = 0.5 * torch.sum((y - t) ** 2)
        return loss

    def backward(self, dout=1):
        # Lossの微分　= (y - t)
        # (平均二乗で定義した0.5 * (y - t)^2の微分)
        # これが最初の「誤差」として逆伝播のスタート地点になります
        dx = self.y - self.t
        return dx

# 0. データの準備
torch.manual_seed(42) # 結果固定

# 入力(X): 2件のデータ, 3つの特徴量
X = torch.randn(2, 3)
# 正解(T): 2件のデータ, 1つの正解値 (回帰問題を想定)
T = torch.randn(2, 1) 

# 重みの初期化
W1 = torch.randn(3, 4) # 1層目の重み
b1 = torch.zeros(4)
W2 = torch.randn(4, 1) # 2層目の重み (出力用)
b2 = torch.zeros(1)

# レイヤーの積み上げ
layers = [
    Affine(W1, b1),
    Relu(),
    Affine(W2, b2) # 最後にもう一度Affineを通して1つの値にする
]
loss_layer = MSE()

learning_rate = 0.1 # 学習率 (更新の歩幅)

print("--- 学習サイクル開始 ---")

# === STEP 1: 順伝播 (知る) ===
print("\n【Step 1: 順伝播 (Forward)】")
out = X
for layer in layers:
    out = layer.forward(out)
    print(f"Layer {layer.__class__.__name__} passed. Shape: {out.shape}")

y_pred = out # AIの予測値

# === ロス計算 ===
print("\n【Step 2: ロス計算 (Loss)】")
loss = loss_layer.forward(y_pred, T)
print(f"現在の予測: \n{y_pred.T} (転置表示)")
print(f"正解データ: \n{T.T} (転置表示)")
print(f"Lossの値 : {loss.item():.4f}")
print("→ まだ全然合っていませんね。")

# === STEP 2: 考える (Backward) ===
print("\n【Step 3: 考える (Backward)】")
# 一番後ろのLoss層からスタート
# dout = t-y (平均二乗で定義した0.5(t-y)^0.5の微分)
dout = loss_layer.backward() 

# レイヤーを逆順にして誤差を伝えていく
for layer in reversed(layers):
    dout = layer.backward(dout)
    
print("逆伝播完了。各層が「修正方向(勾配)」を計算しました。")
# 試しに1層目の重み(W1)の勾配を見てみる
print(f"W1の勾配(dW)の例:\n{layers[0].dW}")
print("→ この値の分だけ、逆に動かせば誤差が減るはずです。")

# === STEP 3: 更新 (Update) ===
print("\n【Step 4: 更新 (Update)】")

# パラメータを持っている層(Affine)だけ更新
# W = W - lr * dW
layers[0].W -= learning_rate * layers[0].dW
layers[0].b -= learning_rate * layers[0].db
layers[2].W -= learning_rate * layers[2].dW
layers[2].b -= learning_rate * layers[2].db

print("パラメータを更新しました！")

# --- 確認：本当によくなった？ ---
print("\n【確認テスト】")
out_new = X
for layer in layers:
    out_new = layer.forward(out_new)
loss_new = loss_layer.forward(out_new, T)

print(f"更新前のLoss: {loss.item():.4f}")
print(f"更新後のLoss: {loss_new.item():.4f}")

if loss_new < loss:
    print("成功 Lossが減りました！")
else:
    print("失敗 Lossが増えてしまいました（学習率が大きすぎたかも？）")

【Step 2: ロス計算 (Loss)】
現在の予測: 
tensor([[ 0.0000, -0.4941, -0.3093, -0.4258]]) (転置表示)
正解データ: 
tensor([[0., 1., 1., 0.]]) (転置表示)
Lossの値 : 2.0640
→ まだ全然合っていませんね。

【Step 3: 考える (Backward)】
逆伝播完了。各層が「修正方向(勾配)」を計算しました。
W1の勾配(dW)の例:
tensor([[0.0000, 1.1860, 0.1110, 0.2327],
        [0.0000, 0.0000, 0.5005, 1.0492]])
→ この値の分だけ、逆に動かせば誤差が減るはずです。

【Step 4: 更新 (Update)】
パラメータを更新しました！

【確認テスト】
更新前のLoss: 2.0640
更新後のLoss: 0.7897
🎉 成功です！ Lossが減りました！

import numpy as np
# 入力(X): 4件のデータ, 2つの特徴量
X_xor = [[0.0,0.0],[0.0,1.0],[1.0,0.0],[1.0,1.0]]
T_xor = [[0.0], [1.0], [1.0], [0.0]]

X_xor_array = np.array(X_xor)
T_xor_array = np.array(T_xor)

X = torch.from_numpy(X_xor_array).float()
T = torch.from_numpy(T_xor_array).float()

print(f"X shape: {X.shape}, dtype: {X.dtype}") # dtype float32 
print(f"T shape: {T.shape}, dtype: {T.dtype}")

print(X.shape)
print(T.shape)