第 3 章：理解反向传播 —— 神经网络中的误差传递¶

# 前向传播
x, y, z = 2, 3, 4

# 步骤1: a = x + y
a = x + y          # a = 5

# 步骤2: f = a * z
f = a * z          # f = 20

print(f"x={x}, y={y}, z={z}")
print(f"a = x + y = {a}")
print(f"f = a * z = {f}")

class AddNode:
    """加法节点"""
    def forward(self, x, y):
        self.x, self.y = x, y
        return x + y

    def backward(self, dout):
        """dout: 上游传来的梯度"""
        return dout, dout  # 原样传给 x 和 y

# 测试
add = AddNode()
result = add.forward(2, 3)
print(f"前向: 2 + 3 = {result}")

dx, dy = add.backward(5.0)  # 假设上游梯度是 5
print(f"反向: dx = {dx}, dy = {dy}")

class MulNode:
    """乘法节点"""
    def forward(self, a, z):
        self.a, self.z = a, z
        return a * z

    def backward(self, dout):
        da = dout * self.z  # 上游梯度 × z
        dz = dout * self.a  # 上游梯度 × a
        return da, dz

# 测试
mul = MulNode()
result = mul.forward(5, 4)
print(f"前向: 5 * 4 = {result}")

da, dz = mul.backward(1.0)  # 假设上游梯度是 1
print(f"反向: da = {da}, dz = {dz}")

class ComputationGraph:
    """完整的计算图：f(x, y, z) = (x + y) * z"""

    def __init__(self):
        self.add_node = AddNode()
        self.mul_node = MulNode()

    def forward(self, x, y, z):
        self.x, self.y, self.z = x, y, z
        a = self.add_node.forward(x, y)
        f = self.mul_node.forward(a, z)
        return f

    def backward(self):
        # 从输出端开始，初始梯度为 1（∂f/∂f = 1）
        df = 1.0

        # 反向通过乘法节点
        da, dz = self.mul_node.backward(df)

        # 反向通过加法节点
        dx, dy = self.add_node.backward(da)

        return dx, dy, dz

# 运行完整示例
graph = ComputationGraph()
f = graph.forward(2, 3, 4)
dx, dy, dz = graph.backward()

print("=" * 40)
print("计算图: f(x, y, z) = (x + y) * z")
print("=" * 40)
print(f"前向传播: f(2, 3, 4) = {f}")
print(f"\n反向传播（梯度）:")
print(f"  ∂f/∂x = {dx}    (应该是 z = 4)")
print(f"  ∂f/∂y = {dy}    (应该是 z = 4)")
print(f"  ∂f/∂z = {dz}    (应该是 x + y = 5)")
print(f"\n验证:")
print(f"  ∂f/∂x = ∂((x+y)*z)/∂x = z = 4 ✓" if dx == 4 else "  ✗")
print(f"  ∂f/∂y = ∂((x+y)*z)/∂y = z = 4 ✓" if dy == 4 else "  ✗")
print(f"  ∂f/∂z = ∂((x+y)*z)/∂z = x+y = 5 ✓" if dz == 5 else "  ✗")

class SigmoidNode:
    """Sigmoid 激活函数节点"""
    def forward(self, x):
        self.out = 1 / (1 + np.exp(-x))
        return self.out

    def backward(self, dout):
        return dout * self.out * (1 - self.out)

# 测试
sigmoid = SigmoidNode()
x_val = 0.5
out = sigmoid.forward(x_val)
grad = sigmoid.backward(1.0)

print(f"Sigmoid({x_val}) = {out:.4f}")
print(f"Sigmoid'({x_val}) = {grad:.4f}")
print(f"验证: out*(1-out) = {out*(1-out):.4f}")

class NeuralNetworkWithBackprop:
    """带完整反向传播的神经网络"""

    def __init__(self, input_size=2, hidden_size=3, output_size=1):
        self.W1 = np.random.randn(input_size, hidden_size) * 0.1
        self.b1 = np.zeros((1, hidden_size))
        self.W2 = np.random.randn(hidden_size, output_size) * 0.1
        self.b2 = np.zeros((1, output_size))

    def sigmoid(self, z):
        return 1 / (1 + np.exp(-np.clip(z, -500, 500)))

    def forward(self, X):
        """前向传播：记录所有中间值"""
        self.X = X

        # 第一层
        self.z1 = np.dot(X, self.W1) + self.b1
        self.a1 = self.sigmoid(self.z1)

        # 第二层（输出层，无激活函数）
        self.z2 = np.dot(self.a1, self.W2) + self.b2

        return self.z2

    def compute_loss(self, y_pred, y_true):
        """均方误差损失"""
        self.y_pred = y_pred
        self.y_true = y_true
        diff = y_pred - y_true
        return np.mean(diff ** 2)

    def backward(self):
        """反向传播：计算所有参数的梯度"""
        n_samples = self.X.shape[0]

        # 损失对输出的梯度（MSE 的导数）
        dz2 = 2 * (self.y_pred - self.y_true) / n_samples

        # 输出层参数的梯度
        self.dW2 = np.dot(self.a1.T, dz2)
        self.db2 = np.sum(dz2, axis=0, keepdims=True)

        # 梯度传到隐藏层
        da1 = np.dot(dz2, self.W2.T)
        dz1 = da1 * self.a1 * (1 - self.a1)  # sigmoid 的导数

        # 隐藏层参数的梯度
        self.dW1 = np.dot(self.X.T, dz1)
        self.db1 = np.sum(dz1, axis=0, keepdims=True)

    def update(self, learning_rate=0.01):
        """梯度下降更新"""
        self.W1 -= learning_rate * self.dW1
        self.b1 -= learning_rate * self.db1
        self.W2 -= learning_rate * self.dW2
        self.b2 -= learning_rate * self.db2

# 测试：学习 XOR 函数
np.random.seed(42)
nn = NeuralNetworkWithBackprop(input_size=2, hidden_size=4, output_size=1)

# XOR 数据
X = np.array([[0, 0], [0, 1], [1, 0], [1, 1]])
y = np.array([[0], [1], [1], [0]])

print("训练 XOR 函数...")
print(f"{'轮次':<6} {'损失':<12}")
print("-" * 20)

for epoch in range(2000):
    y_pred = nn.forward(X)
    loss = nn.compute_loss(y_pred, y)
    nn.backward()
    nn.update(learning_rate=0.5)

    if epoch % 500 == 0:
        print(f"{epoch:<6} {loss:<12.6f}")

print(f"\n最终预测:")
for i, (x1, x2) in enumerate(X):
    pred = nn.forward(np.array([[x1, x2]]))[0, 0]
    print(f"  XOR({x1}, {x2}) = {pred:.4f}  (真实值: {y[i,0]})")

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

class XORNet(nn.Module):
    """用 PyTorch 解决 XOR 问题"""
    def __init__(self):
        super(XORNet, self).__init__()
        self.fc1 = nn.Linear(2, 4)
        self.sigmoid = nn.Sigmoid()
        self.fc2 = nn.Linear(4, 1)

    def forward(self, x):
        x = self.fc1(x)
        x = self.sigmoid(x)
        x = self.fc2(x)
        x = torch.sigmoid(x)
        return x

X = torch.tensor([[0.0, 0.0], [0.0, 1.0], [1.0, 0.0], [1.0, 1.0]])
y = torch.tensor([[0.0], [1.0], [1.0], [0.0]])

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

print("训练 XOR 函数（PyTorch 自动反向传播）...")
print(f"{'轮次':<6} {'损失':<12}")
print("-" * 20)

for epoch in range(2000):
    y_pred = model(X)
    loss = criterion(y_pred, y)

    optimizer.zero_grad()
    loss.backward()
    optimizer.step()

    if epoch % 500 == 0:
        print(f"{epoch:<6} {loss.item():<12.6f}")

print(f"\n最终预测:")
with torch.no_grad():
    for i in range(4):
        pred = model(X[i:i+1]).item()
        print(f"  XOR({X[i,0].item():.0f}, {X[i,1].item():.0f}) = {pred:.4f}  (真实值: {y[i,0].item():.0f})")