神经网络与深度学习 第二章 反向传播算法(两个假设、四个基本方程及其证明、代码及注释)

2.1 热身：神经网络中使用矩阵快速计算输出的方法

2.2 关于代价函数的两个假设

2.3 Hadamard乘积 s⊙t

2.4 反向传播的四个基本方程

2.5 四个基本方程的证明

2.6 反向传播算法

2.7 代码

2.8 在哪种层面上，反向传播是快速的算法？

2.9 反向传播：全局观















2.7 代码：

def update_mini_batch(self, mini_batch, eta):
"""
基于反向传播的简单梯度下降算法更新网络的权重和偏置
:param mini_batch: 最小训练集
:param eta: 学习速率
:return:
"""
nabla_b = [np.zeros(b.shape) for b in self.biases]
"""

"""

"""
运行
for b in self.biases:
print("b.shape=",b.shape)
输出(30，1) (10，1)
np.zeros((a b))为生成a行b列的数组且每一个元素为0
所以依次生成一个30行1列的数组和一个10行1列的数组，存放到nabla_b中
nabla_b[0]为30行1列的数组，每一个元素为0
nabla_b[1]为10行1列的数组，每一个元素为0
"""

nabla_w = [np.zeros(w.shape) for w in self.weights]

"""
同理
nabla_w[0]为30行784列的数组，每一个元素为0
nabla_w[1]为10行30列的数组，每一个元素为0
"""
for x, y in mini_batch:
#对于最小训练集中的每一个训练数据x及其正确分类y
delta_nabla_b, delta_nabla_w = self.backprop(x, y)
"""
这行调用了一个称为反向传播的算法，一种快速计算代价函数的梯度的方法。
delta_nabla_b[0]与biases[0]和nabla_b[0]一样为30*1数组（向量）
delta_nabla_b[1]与biases[1]和nabla_b[1]一样为10*1数组（向量）
delta_nabla_w[0]与weights[0]和nabla_w[0]一样为30*784数组（向量）
delta_nabla_w[1]与weights[1]和nabla_w[1]一样为10*30数组（向量）
"""
nabla_b = [nb+dnb for nb, dnb in zip(nabla_b, delta_nabla_b)]
#nabla_b中的每一个即为∂C/∂b
nabla_w = [nw+dnw for nw, dnw in zip(nabla_w, delta_nabla_w)]
# nabla_b中的每一个即为∂C/∂w
self.weights = [w-(eta/len(mini_batch))*nw
for w, nw in zip(self.weights, nabla_w)]
#更新权重向量组
self.biases = [b-(eta/len(mini_batch))*nb
for b, nb in zip(self.biases, nabla_b)]
#更新偏置向量组

def backprop(self, x, y):
# 反向传播的算法，一种快速计算代价函数的梯度的方法。
nabla_b = [np.zeros(b.shape) for b in self.biases]
nabla_w = [np.zeros(w.shape) for w in self.weights]
# feedforward
activation = x
#激活值
activations = [x] # list to store all the activations, layer by layer
#各层激活值集合
zs = [] # list to store all the z vectors, layer by layer
#z值集合
for b, w in zip(self.biases, self.weights):
#对于每一层的偏置和权重
z = np.dot(w, activation)+b
#计算z=w*a+b
zs.append(z)
#将z加入z值集合
activation = sigmoid(z)
#计算激活值σ（z）
activations.append(activation)
#将激活值加入激活值集合
#至此计算最后的输出
# backward pass
delta = self.cost_derivative(activations[-1], y) * \
sigmoid_prime(zs[-1])
#计算δjL=∂C/∂ajL * σ'(ZjL)
nabla_b[-1] = delta
#∂C/∂bjl = δjL
nabla_w[-1] = np.dot(delta, activations[-2].transpose())
#∂C/∂wjkl = ak(l-1) * δjL
#transpose函数为转置
# Note that the variable l in the loop below is used a little
# differently to the notation in Chapter 2 of the book. Here,
# l = 1 means the last layer of neurons, l = 2 is the
# second-last layer, and so on. It's a renumbering of the
# scheme in the book, used here to take advantage of the fact
# that Python can use negative indices in lists.
for l in range(2, self.num_layers):
z = zs[-l]
sp = sigmoid_prime(z)
#sp=σ'(ZjL)
delta = np.dot(self.weights[-l+1].transpose(), delta) * sp
#δL=((w(l+1)T δL+1) ) ⊙ σ'(ZjL)
nabla_b[-l] = delta
# ∂C/∂bjl = δjL
nabla_w[-l] = np.dot(delta, activations[-l-1].transpose())
# ∂C/∂wjkl = ak(l-1) * δjL
return (nabla_b, nabla_w)

def cost_derivative(self, output_activations, y):
"""二次代价函数为:
C=1/2 * ∑(Yj-Aj)^2
∂C/∂Aj = Aj-Yj
也就是说二次代价函数对输出激活值的偏导数=输出激活值-正确分类值
"""
return (output_activations-y)