BP反向传播神经网络的公式推导

假设我们有以下三层神经网络:

输入层:2个神经元
隐藏层:3个神经元
输出层:2个神经元

假设使用sigmoid函数作为激活函数,定义如下:

σ ( x ) = 1 1 + e − x \sigma(x) = \frac{1}{1+e^{-x}} σ(x)=1+ex1

现在,我们来推导反向传播算法的每一步公式。

Step 1: 前向传播

对于一个样本 x \mathbf{x} x,前向传播计算如下:

z 1 = w 1 ⊤ x + b 1 z_1 = \mathbf{w}_1^{\top}\mathbf{x} + \mathbf{b}_1 z1=w1x+b1

h 1 = σ ( z 1 ) h_1 = \sigma(z_1) h1=σ(z1)

z 2 = w 2 ⊤ h 1 + b 2 z_2 = \mathbf{w}_2^{\top}\mathbf{h}_1 + \mathbf{b}_2 z2=w2h1+b2

h 2 = σ ( z 2 ) h_2 = \sigma(z_2) h2=σ(z2)

其中, w 1 \mathbf{w}_1 w1 w 2 \mathbf{w}_2 w2 是权重矩阵, b 1 \mathbf{b}_1 b1 b 2 \mathbf{b}_2 b2 是偏置向量, σ ( ⋅ ) \sigma(\cdot) σ() 是sigmoid函数。

Step 2: 计算误差

我们假设要最小化平方损失函数:

L = 1 2 ∑ i = 1 m ( y ^ i − y i ) 2 L = \frac{1}{2}\sum_{i=1}^{m}(\hat{y}_i - y_i)^2 L=21i=1m(y^iyi)2

其中, m m m是样本数量, y ^ i \hat{y}_i y^i y i y_i yi分别是第 i i i个样本的预测值和真实值。对于本例, m = 1 m=1 m=1

因此,我们可以计算输出层的误差项 δ 2 \delta_2 δ2

δ 2 = ( y ^ − y ) ⋅ σ ′ ( z 2 ) = ( y ^ − y ) ⋅ h 2 ⋅ ( 1 − h 2 ) \delta_2 = (\hat{y} - y) \cdot \sigma'(z_2) = (\hat{y} - y) \cdot h_2 \cdot (1 - h_2) δ2=(y^y)σ(z2)=(y^y)h2(1h2)

其中, y ^ \hat{y} y^是预测值, y y y是真实值, σ ′ ( ⋅ ) \sigma'(\cdot) σ()表示sigmoid函数的导数。

Step 3: 反向传播

接下来,我们需要通过反向传播算法计算每一层的误差项 δ \delta δ

对于隐藏层,我们可以使用以下公式计算:

δ 1 = W 2 δ 2 ⋅ σ ′ ( z 1 ) = W 2 δ 2 ⋅ h 1 ⋅ ( 1 − h 1 ) \delta_1 = \mathbf{W}_2 \delta_2 \cdot \sigma'(z_1) = \mathbf{W}_2 \delta_2 \cdot h_1 \cdot (1 - h_1) δ1=W2δ2σ(z1)=W2δ2h1(1h1)

其中, W 2 \mathbf{W}_2 W2是权重矩阵除去偏置项后的部分。

Step 4: 计算梯度

最后,我们可以使用误差项 δ \delta δ计算梯度并更新参数。具体地,我们可以使用以下公式计算权重和偏置的梯度:

∂ L ∂ w 2 = h 1 δ 2 \frac{\partial L}{\partial \mathbf{w}_2} = \mathbf{h}_1 \delta_2 w2L=h1δ2

∂ L ∂ b 2 = δ 2 \frac{\partial L}{\partial \mathbf{b}_2} = \delta_2 b2L=δ2

∂ L ∂ w 1 = x δ 1 \frac{\partial L}{\partial \mathbf{w}_1} = \mathbf{x} \delta_1 w1L=xδ1

∂ L ∂ b 1 = δ 1 \frac{\partial L}{\partial \mathbf{b}_1} = \delta_1 b1L=δ1

其中, h 1 \mathbf{h}_1 h1 x \mathbf{x} x分别是隐藏层输出和输入层输入, δ 1 \delta_1 δ1 δ 2 \delta_2 δ2是误差项。

最后,我们可以使用梯度下降法或其他优化算法来更新权重和偏置。

  • 0
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
反向传播算法(Backpropagation)是一种用于训练神经网络的常见优化算法。它通过计算损失函数相对于每个参数的梯度,并使用梯度下降来更新参数。下面我将给出反向传播算法的公式推导及示例代码。 1. 反向传播算法公式推导: 首先,定义神经网络的损失函数为L,该函数是由网络输出和真实标签之间的差异计算得出。假设神经网络有多个隐藏层,每个隐藏层的参数为W和b。 1.1 前向传播: 首先,我们通过前向传播计算每一层的输出值。假设输入为x,第l层的输出为a[l],则有: a = x z[l] = W[l] * a[l-1] + b[l] a[l] = g(z[l]) 其中,g()是激活函数。 1.2 反向传播: 接下来,我们需要计算损失函数相对于每个参数的梯度,然后使用梯度下降更新参数。假设我们有L层神经网络,则有以下公式: 输出层的梯度: dz[L] = dL / da[L] * g'(z[L]) 隐藏层的梯度: dz[l] = (W[l+1]的转置 * dz[l+1]) * g'(z[l]) 参数梯度: dW[l] = dz[l] * a[l-1的转置] db[l] = dz[l] 更新参数: W[l] = W[l] - learning_rate * dW[l] b[l] = b[l] - learning_rate * db[l] 其中,dL / da[L]是损失函数对输出层输出的导数,g'()是激活函数的导数。 2. 反向传播算法示例代码: 下面是一个使用反向传播算法进行训练的示例代码: ```python # 假设网络有三个隐藏层 hidden_layers = [10, 20, 30] output_size = 2 # 初始化参数 parameters = {} layers_dims = [input_size] + hidden_layers + [output_size] L = len(layers_dims) - 1 for l in range(1, L + 1): parameters['W' + str(l)] = np.random.randn(layers_dims[l], layers_dims[l-1]) * 0.01 parameters['b' + str(l)] = np.zeros((layers_dims[l], 1)) # 前向传播 def forward_propagation(X, parameters): caches = [] A = X for l in range(1, L): Z = np.dot(parameters['W' + str(l)], A) + parameters['b' + str(l)] A = sigmoid(Z) cache = (Z, A) caches.append(cache) Z = np.dot(parameters['W' + str(L)], A) + parameters['b' + str(L)] AL = softmax(Z) cache = (Z, AL) caches.append(cache) return AL, caches # 反向传播 def backward_propagation(AL, Y, caches): grads = {} dZ = AL - Y m = AL.shape[1] grads['dW' + str(L)] = 1/m * np.dot(dZ, caches[-1][1].T) grads['db' + str(L)] = 1/m * np.sum(dZ, axis=1, keepdims=True) for l in reversed(range(1, L)): dA_prev = np.dot(parameters['W' + str(l+1)].T, dZ) dZ = dA_prev * sigmoid_derivative(caches[l-1][0]) grads['dW' + str(l)] = 1/m * np.dot(dZ, caches[l-1][1].T) grads['db' + str(l)] = 1/m * np.sum(dZ, axis=1, keepdims=True) return grads # 参数更新 def update_parameters(parameters, grads, learning_rate): for l in range(1, L+1): parameters['W' + str(l)] -= learning_rate * grads['dW' + str(l)] parameters['b' + str(l)] -= learning_rate * grads['db' + str(l)] return parameters # 训练模型 def train_model(X, Y, learning_rate, num_iterations): for i in range(num_iterations): AL, caches = forward_propagation(X, parameters) cost = compute_cost(AL, Y) grads = backward_propagation(AL, Y, caches) parameters = update_parameters(parameters, grads, learning_rate) if i % 100 == 0: print("Cost after iteration {}: {}".format(i, cost)) return parameters # 使用示例 parameters = train_model(X_train, Y_train, learning_rate=0.01, num_iterations=1000) ``` 这是一个简单的反向传播算法示例代码,其中的sigmoid()、softmax()、sigmoid_derivative()和compute_cost()函数需要根据具体情况自行实现。

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

zcongfly

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付:¥1
获取中
扫码支付

您的余额不足,请更换扫码支付或充值

打赏作者

实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值