Python 从零实现简单神经网络算法：原理与代码详解

三、Python 实现代码（详细注释）

环境：Python 3.x 依赖库：numpy

import numpy as np

# 固定随机种子，保证每次运行结果一致
np.random.seed(42)

# ========== 1. 数据集定义 ==========
# XOR 问题的输入与输出
X = np.array([[0, 0], [0, 1], [1, 0], [1, 1]])
y = np.array([[0], [1], [1], [0]])
# 目标输出（异或结果）

# ========== 2. 定义激活函数 ==========
def sigmoid(x):
    """Sigmoid 激活函数：将值压缩到 (0,1)"""
    return 1 / (1 + np.exp(-x))

def sigmoid_derivative(x):
    """Sigmoid 导数，用于反向传播"""
    return x * (1 - x)

# ========== 3. 网络结构参数 ==========
input_size = 2 # 输入层节点数
hidden_size = 3 # 隐藏层节点数
output_size = 1 # 输出层节点数
lr = 0.1 # 学习率
epochs = 10000 # 训练迭代次数

# ========== 4. 权重和偏置初始化 ==========
W1 = np.random.uniform(-1, 1, (input_size, hidden_size))
b1 = np.zeros((1, hidden_size))
W2 = np.random.uniform(-1, 1, (hidden_size, output_size))
b2 = np.zeros((1, output_size))

# ========== 5. 开始训练 ==========
for epoch in range(epochs):
    # ---- 前向传播 ----
    hidden_input = np.dot(X, W1) + b1
    hidden_output = sigmoid(hidden_input)
    final_input = np.dot(hidden_output, W2) + b2
    final_output = sigmoid(final_input)

    # ---- 计算误差 ----
    error = y - final_output

    # ---- 反向传播 ----
    d_output = error * sigmoid_derivative(final_output)
    d_hidden = np.dot(d_output, W2.T) * sigmoid_derivative(hidden_output)

    # ---- 更新权重与偏置 ----
    W2 += np.dot(hidden_output.T, d_output) * lr
    b2 += np.sum(d_output, axis=0, keepdims=True) * lr
    W1 += np.dot(X.T, d_hidden) * lr
    b1 += np.sum(d_hidden, axis=0, keepdims=True) * lr

    # 每 1000 次打印一次误差
    if epoch % 1000 == 0:
        loss = np.mean(np.abs(error))
        print(f"Epoch {epoch}, Loss: {loss:.4f}")

# ========== 6. 输出结果 ==========
print("\n训练完成后的预测输出：")
print(final_output)

四、结果分析

输出结果示例：

Epoch 0, Loss: 0.51
Epoch 1000, Loss: 0.24
Epoch 2000, Loss: 0.12
Epoch 3000, Loss: 0.07
...
Epoch 9000, Loss: 0.03
训练完成后的预测输出：
[[0.03]
 [0.97]
 [0.96]
 [0.04]]

预测效果如下表：

模型已经非常成功地学习到了异或逻辑！

五、可视化：误差下降曲线

import matplotlib.pyplot as plt

losses = []
for epoch in range(epochs):
    hidden_input = np.dot(X, W1) + b1
    hidden_output = sigmoid(hidden_input)
    final_input = np.dot(hidden_output, W2) + b2
    final_output = sigmoid(final_input)
    error = y - final_output
    losses.append(np.mean(np.abs(error)))
    
    d_output = error * sigmoid_derivative(final_output)
    d_hidden = np.dot(d_output, W2.T) * sigmoid_derivative(hidden_output)
    W2 += np.dot(hidden_output.T, d_output) * lr
    b2 += np.sum(d_output, axis=0, keepdims=True) * lr
    W1 += np.dot(X.T, d_hidden) * lr
    b1 += np.sum(d_hidden, axis=0, keepdims=True) * lr

plt.plot(losses)
plt.title("Loss 下降曲线")
plt.xlabel("Epochs")
plt.ylabel("Loss")
plt.show()

输出图像显示误差从 0.5 逐步降到接近 0，说明模型在不断学习。

六、深入理解反向传播的数学逻辑

反向传播（Backpropagation）的关键是链式法则（Chain Rule）。

举例：

∂L/∂W2 = ∂L/∂A2 · ∂A2/∂Z2 · ∂Z2/∂W2

这其实就是在计算：

• 输出层误差如何影响权重；
• 隐藏层误差如何传播回去；
• 最终更新每一层的参数。

通过不断循环这个过程，网络就会'自我纠正'，让预测结果越来越接近真实值。

七、总结与扩展方向

本文我们手写了一个完整的神经网络，从：

• 原理推导
• 代码实现
• 训练过程
• 可视化结果

都进行了详细讲解。

下一步建议：

1. 使用 ReLU 替代 Sigmoid，提高收敛速度；
2. 尝试多层网络，学习非线性更复杂的问题；
3. 尝试分类任务（如 Iris 鸢尾花数据集）；
4. 对比纯 Python 与 TensorFlow 的实现性能差异。