Backpropagation

反向传播算法（Backpropagation）是深度学习中用于训练多层神经网络的算法。它基于梯度下降法，通过计算损失函数关于网络参数的梯度，并更新参数以最小化损失。

反向传播算法的步骤：

1. 初始化网络参数：通常使用小的随机数初始化权重和偏置。
2. 前向传播：输入数据通过网络，逐层计算直到输出层，得到预测结果。
3. 计算损失：使用损失函数（如均方误差、交叉熵等）计算预测结果与真实标签之间的差异。
4. 反向传播：从输出层开始，逆向通过网络，计算每个参数的梯度。
5. 参数更新：使用梯度下降法或其他优化算法更新网络参数。
6. 迭代优化：重复步骤2-5，直到达到预定的迭代次数或损失函数值收敛。

代码实现

以下是一个简单的Python示例，实现一个具有单个隐藏层的多层感知器（MLP）的反向传播算法：

import numpy as np

# 激活函数及其导数
def sigmoid(x):
    return 1 / (1 + np.exp(-x))

def sigmoid_derivative(x):
    return x * (1 - x)

# 损失函数（均方误差）
def mse_loss(y_true, y_pred):
    return ((y_true - y_pred) ** 2).mean()

# 反向传播算法
def backpropagation(X, y, weights, learning_rate, epochs):
    input_size = X.shape[1]
    hidden_size = 4  # 假设隐藏层有4个神经元
    output_size = 1  # 假设输出层有1个神经元

    # 初始化权重和偏置
    weights_input_to_hidden = np.random.randn(input_size, hidden_size)
    weights_hidden_to_output = np.random.randn(hidden_size, output_size)
    biases_hidden = np.zeros((1, hidden_size))
    biases_output = np.zeros((1, output_size))

    for epoch in range(epochs):
        # 前向传播
        hidden_layer_input = np.dot(X, weights_input_to_hidden) + biases_hidden
        hidden_layer_output = sigmoid(hidden_layer_input)

        output_layer_input = np.dot(hidden_layer_output, weights_hidden_to_output) + biases_output
        y_pred = sigmoid(output_layer_input)

        # 计算损失
        loss = mse_loss(y, y_pred)

        # 反向传播
        d_output = (y_pred - y)
        d_weights_hidden_to_output = np.dot(hidden_layer_output.T, d_output * sigmoid_derivative(output_layer_input))
        d_biases_output = np.sum(d_output * sigmoid_derivative(output_layer_input), axis=0, keepdims=True)

        d_hidden_output = np.dot(d_output * sigmoid_derivative(output_layer_input), weights_hidden_to_output.T)
        d_weights_input_to_hidden = np.dot(X.T, d_hidden_output * sigmoid_derivative(hidden_layer_input))
        d_biases_hidden = np.sum(d_hidden_output * sigmoid_derivative(hidden_layer_input), axis=0, keepdims=True)

        # 参数更新
        weights_hidden_to_output -= learning_rate * d_weights_hidden_to_output
        biases_output -= learning_rate * d_biases_output
        weights_input_to_hidden -= learning_rate * d_weights_input_to_hidden
        biases_hidden -= learning_rate * d_biases_hidden

        if epoch % 100 == 0:
            print(f"Epoch {epoch}, Loss: {loss}")

    return weights_input_to_hidden, weights_hidden_to_output, biases_hidden, biases_output

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

# 训练模型
learning_rate = 0.1
epochs = 1000
weights_input_to_hidden, weights_hidden_to_output, biases_hidden, biases_output = backpropagation(X, y, None, learning_rate, epochs)