python实现反向传播算法

反向传播算法是神经网络中常用的一种训练方法，其本质是利用链式法则求导，来更新网络参数使得损失函数最小化。下面是用 Python 实现反向传播算法的基本步骤：

1. 前向传播计算损失函数，得到网络输出值。

2. 计算每个输出节点对输入的偏导数。

3. 计算每个中间节点对输入的偏导数。

4. 计算每个权重对输入的偏导数。

5. 利用梯度下降法更新每个权重。

下面是一个简单的神经网络反向传播算法的 Python 代码实现：

import numpy as np

# 1. 定义神经网络
class NeuralNetwork:
    def __init__(self, input_size, hidden_size, output_size):
        self.W1 = np.random.randn(input_size, hidden_size) / np.sqrt(input_size)
        self.b1 = np.zeros((1, hidden_size))
        self.W2 = np.random.randn(hidden_size, output_size) / np.sqrt(hidden_size)
        self.b2 = np.zeros((1, output_size))

    # 2. 前向传播计算损失函数
    def forward(self, X):
        self.z1 = np.dot(X, self.W1) + self.b1
        self.a1 = np.tanh(self.z1)
        self.z2 = np.dot(self.a1, self.W2) + self.b2
        self.y_hat = np.exp(self.z2) / np.sum(np.exp(self.z2), axis=1, keepdims=True)

    # 3. 计算每个输出节点对输入的偏导数
    def backward_output(self, X, y):
        self.delta3 = self.y_hat
        self.delta3[range(X.shape[0]), y] -= 1

    # 4. 计算每个中间节点对输入的偏导数
    def backward_hidden(self):
        self.delta2 = np.dot(self.delta3, self.W2.T) * (1 - np.power(self.a1, 2))

    # 5. 计算每个权重对输入的偏导数
    def gradient(self, X):
        self.dW2 = np.dot(self.a1.T, self.delta3)
        self.db2 = np.sum(self.delta3, axis=0, keepdims=True)
        self.dW1 = np.dot(X.T, self.delta2)
        self.db1 = np.sum(self.delta2, axis=0)

    # 6. 利用梯度下降法更新每个权重
    def update(self, learning_rate):
        self.W1 -= learning_rate * self.dW1
        self.b1 -= learning_rate * self.db1
        self.W2 -= learning_rate * self.dW2
        self.b2 -= learning_rate * self.db2

# 测试
X = np.array([[0, 0], [0, 1], [1, 0], [1, 1]])
y = np.array([0, 1, 1, 0])
nn = NeuralNetwork(2, 3, 2)
for i in range(10000):
    nn.forward(X)
    nn.backward_output(X, y)
    nn.backward_hidden()
    nn.gradient(X)
    nn.update(0.01)
print(nn.y_hat)

上面的代码实现了一个简单的两层神经网络，并且用反向传播算法训练了一个异或门。