神经网络基础-神经网络补充概念-26-前向和反向传播_神经网络中的前向传播和反向传播是什么

简单比较

前向传播（Forward Propagation）：

前向传播是神经网络中的正向计算过程，用于从输入数据开始，逐层计算每个神经元的输出值，直到得到最终的预测值。在前向传播过程中，我们按以下步骤进行：

输入数据：将输入数据传递给输入层。

加权求和：对每个神经元的输入进行加权求和，即将输入与权重相乘并加上偏差。

激活函数：将加权求和的结果输入激活函数（如Sigmoid、ReLU等），得到神经元的输出。

传递至下一层：将当前层的输出作为下一层的输入，重复步骤 2 和 3，直到达到输出层，得到最终的预测值。

反向传播（Backward Propagation）：

反向传播是神经网络中的梯度计算和权重更新过程，用于根据损失函数计算每个参数的梯度，然后根据梯度信息更新网络的权重和偏差。在反向传播过程中，我们按以下步骤进行：

计算损失：使用损失函数计算预测值与真实标签之间的差距。

计算梯度：通过链式法则，从输出层开始，逐层计算每个参数的梯度，传递梯度至前一层。对于每一层，计算权重和偏差的梯度，以及当前层输入的梯度。

参数更新：使用计算得到的梯度信息，根据优化算法（如梯度下降法、Adam等）更新每个参数的值，以减小损失函数。

重复迭代：重复进行前向传播和反向传播，多次迭代，直到损失函数足够小或达到预定的迭代次数。

前向传播和反向传播是神经网络训练的基石，通过不断地在这两个过程中更新参数，神经网络逐渐优化其性能，从而能够更好地进行预测和模式识别任务。

代码实现

import numpy as np

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

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

# 初始化参数
def initialize_parameters(input_size, hidden_size, output_size):
    parameters = {
        'W1': np.random.randn(hidden_size, input_size),
        'b1': np.zeros((hidden_size, 1)),
        'W2': np.random.randn(output_size, hidden_size),
        'b2': np.zeros((output_size, 1))
    }
    return parameters

# 前向传播
def forward_propagation(X, parameters):
    W1, b1, W2, b2 = parameters['W1'], parameters['b1'], parameters['W2'], parameters['b2']
    Z1 = np.dot(W1, X) + b1
    A1 = sigmoid(Z1)
    Z2 = np.dot(W2, A1) + b2
    A2 = sigmoid(Z2)
    cache = {'Z1': Z1, 'A1': A1, 'Z2': Z2, 'A2': A2}
    return A2, cache

# 计算损失
def compute_loss(A2, Y):
    m = Y.shape[1]
    loss = -np.sum(Y * np.log(A2) + (1 - Y) * np.log(1 - A2)) / m
    return loss

# 反向传播
def backward_propagation(X, Y, cache, parameters):
    m = X.shape[1]
    A1, A2 = cache['A1'], cache['A2']
    W2 = parameters['W2']

    dZ2 = A2 - Y
    dW2 = np.dot(dZ2, A1.T) / m
    db2 = np.sum(dZ2, axis=1, keepdims=True) / m

    dZ1 = np.dot(W2.T, dZ2) * sigmoid_derivative(A1)
    dW1 = np.dot(dZ1, X.T) / m
    db1 = np.sum(dZ1, axis=1, keepdims=True) / m

    grads = {'dW1': dW1, 'db1': db1, 'dW2': dW2, 'db2': db2}
    return grads

# 更新参数
def update_parameters(parameters, grads, learning_rate):
    parameters['W1'] -= learning_rate * grads['dW1']
    parameters['b1'] -= learning_rate * grads['db1']
    parameters['W2'] -= learning_rate * grads['dW2']
    parameters['b2'] -= learning_rate * grads['db2']
    return parameters

# 主函数
def deep_neural_network(X, Y, hidden_size, learning_rate, num_iterations):
    np.random.seed(42)
    input_size = X.shape[0]
    output_size = Y.shape[0]
    parameters = initialize_parameters(input_size, hidden_size, output_size)

    for i in range(num_iterations):
        A2, cache = forward_propagation(X, parameters)
        loss = compute_loss(A2, Y)
        grads = backward_propagation(X, Y, cache, parameters)
        parameters = update_parameters(parameters, grads, learning_rate)

        if i % 100 == 0:
            print(f'Iteration {i}, Loss: {loss:.4f}')

    return parameters

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

# 定义超参数
hidden_size = 4
learning_rate = 0.1
num_iterations = 10000

# 训练深层神经网络
parameters = deep_neural_network(X, Y, hidden_size, learning_rate, num_iterations)

# 预测
predictions, _ = forward_propagation(X, parameters)
print('Predictions:', predictions)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94