反向传播算法(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()函数需要根据具体情况自行实现。