def SGD(self, training_data, epochs, mini_batch_size, eta,
        test_data=None):
    """Train the neural network using mini-batch stochastic
    gradient descent.  The ``training_data`` is a list of tuples
    ``(x, y)`` representing the training inputs and the desired
    outputs.  The other non-optional parameters are
    self-explanatory.  If ``test_data`` is provided then the
    network will be evaluated against the test data after each
    epoch, and partial progress printed out.  This is useful for
    tracking progress, but slows things down substantially."""
    if test_data: n_test = len(test_data)
    n = len(training_data)
    for j in xrange(epochs):
        random.shuffle(training_data)
        mini_batches = [
            training_data[k:k + mini_batch_size]
            for k in xrange(0, n, mini_batch_size)]
        for mini_batch in mini_batches:
            self.update_mini_batch(mini_batch, eta)
        if test_data:
            print "Epoch {0}: {1} / {2}".format(
                j, self.evaluate(test_data), n_test)
        else:
            print "Epoch {0} complete".format(j)

代码自带详细注释，而且很容易看懂。
文章来源：https://www.codelast.com/
for j in xrange(epochs) 这句代码使得训练会进行epoch轮。
xrang()是Python自带函数，随便试验一下就知道它的作用了，例如：

for j in xrange(4):
    print(j)

这段代码输出的结果是：

0

1

2

3

所以，如果我们把epoch定义成4，那么循环就会进行4次，也就是说训练会进行4轮。
文章来源：https://www.codelast.com/
显然，for j in xrange(epochs) 下面的循环体里的代码，就是每一轮训练要执行的代码。
首先，random.shuffle(training_data)这一句的作用是什么呢？答：随机打乱training_data这个list。
为了说明它，我们打开ipython，来做一个相当简单的试验：

import numpy as np
import random
a = [(1, 2), (3, 4), (5, 6), (7, 8), (0, 9)]
random.shuffle(a)
print(a)
random.shuffle(a)
print(a)
random.shuffle(a)
print(a)

在上面的代码中，打印了3次 a 的内容，在我的PC上，3次print的输出分别如下：

[(7, 8), (0, 9), (1, 2), (3, 4), (5, 6)]
[(3, 4), (5, 6), (0, 9), (7, 8), (1, 2)]
[(1, 2), (0, 9), (5, 6), (3, 4), (7, 8)]

可见，random.shuffle()把list里的元素进行了随机打乱。由于是随机的，所以，你的测试结果可能和我的不一样。
随机打乱数据是为了防止某些pattern相似的输入数据集中在一个batch中，导致对训练结果产生负面影响。SGD不就是“随机梯度下降”嘛。
文章来源：https://www.codelast.com/
在打乱数据之后，程序就把所有输入数据拆分成了若干个批量（mini batch），每一个batch的大小是由mini_batch_size定义的：

mini_batches = [
    training_data[k:k+mini_batch_size]
    for k in xrange(0, n, mini_batch_size)]

这里的xrange用法和上面的xrange稍有不同，我们还是用一个实例来表明它的作用：

for k in xrange(0, 10, 3):
    print(k)

这段代码把mini_batch_size设置成了3，它的输出结果是：

0

3

6

9

self.update_mini_batch(mini_batch, eta)

if test_data:
    print "Epoch {0}: {1} / {2}".format(j, self.evaluate(test_data), n_test)
else:
    print "Epoch {0} complete".format(j)

知道了这一点，再来看看这句话里所说的误差是什么？在机器学习中，我们的目的是最小化代价函数（cost function），而根据高等数学的导数知识：

一个函数在某一点的导数描述了这个函数在这一点附近的变化率。

因此，如果用代价函数对输出激活值 ${a^L}$ 求导，就可以刻划出输出激活值的改变，会对cost造成多大的影响： $\frac{{\partial C}}{{\partial a_j^L}}$
顺水推舟，作者就定义了一个“误差”的概念，用来表示神经元的输出变化，会对cost造成多大的影响——影响大，误差就大；影响小，误差就小。
但是这里有一个概念上的替换需要注意：作者实际上并没有把误差定义成代价函数对输出激活值  ${a^L}$ 的导数  $\frac{{\partial C}}{{\partial a_j^L}}$ ，而是代价函数对带权输入 $z$  的导数 $\frac{{\partial C}}{{\partial z_j^l}}$
我第一眼看到这个定义的时候，觉得把误差定义成代价函数对输出激活值的导数更自然——作者已经在书里解释了为什么要这样做：结果是差不多的，但是数学推导会变得更复杂，所以就把误差定义成了一个看起来“不那么自然”的东西。
文章来源：http://www.codelast.com/
总结一下：
已知 $C = C(a)$ ， $a = \sigma (z)$ ，并且我们希望用 C 对 z 的导数 $\frac{{\partial C}}{{\partial z}}$ 来表示神经元的输出对 cost 造成的影响，所以根据复合函数的求导法则，就可以得到反向传播的第一个基本方程了。

但有一点奇怪的是，为什么要定义这个“误差”呢？定义它是为了能找到计算  $\frac{{\partial C}}{{\partial w}}$ 以及  $\frac{{\partial C}}{{\partial b}}$ 的方法——计算这两个值就是反向传播的目的。

文章来源：https://www.codelast.com/
➤➤ 版权声明 ➤➤ 
转载需注明出处：codelast.com 
感谢关注我的微信公众号（微信扫一扫）：

在给出一个完整的清单之前，让我解释一下神经网络代码的核心特征，如下。核心是一个Network类，我们用来表示一个神经网络。这是我们用来初始化一个Network对象的代码:

class Network(object):

    def __init__(self, sizes):
        self.num_layers = len(sizes)
        self.sizes = sizes
        self.biases = [np.random.randn(y, 1) for y in sizes[1:]]
        self.weights = [np.random.randn(y, x) 
                        for x, y in zip(sizes[:-1], sizes[1:])]

net = Network([2, 3, 1])

self.biases = [np.random.randn(y, 1) for y in sizes[1:]]

a = [i for i in range(3)]
print(a)

a = [5, 6, 8]
print(a[1:])

import numpy as np

import numpy as np

np.random.randn(3, 1)

输出结果如下：

array([[ 1.33160979],

       [ 0.66314905],

       [ 0.27303603]])

可见，它输出的是一个3行，1列的随机数矩阵——你看这输出多体贴，为了表明“3行1列”，它没有把数字都排在一行，而是特意放在了3行里。
好了，现在我们已经彻底了解了 biases 的结构，那么再来看看，为什么它的第一个元素是3x1的矩阵，第二个元素是1x1的矩阵呢？
这跟要创建的神经网络层的结构有关。
文章来源：https://www.codelast.com/
如作者书中所说，“假设第一层神经元是一个输入层，并对这些神经元不设置任何偏差，因为偏差仅在之后的层中使用”，所以 biases 只有两个元素，而不是3个。但知道了这一点并不能解决我们心中的疑惑：为什么 biases[0] 是一个 3x1 的矩阵，biases[1] 是一个 1x1 的矩阵呢？

这就跟weight（权重）有关了，所以，我们不妨先来看看代码中，weight是如何定义的：

self.weights = [np.random.randn(y, x) for x, y in zip(sizes[:-1], sizes[1:])]

这个冗长的实现需要“细细品味”。
首先，中括号表明 weights 是一个list，中括号里的代码对这个list的每一个元素进行赋值，list中的每一个元素都是一个 np.random.randn(y, x) ——这个东西我们刚才在解释 biases 的时候已经说过了，它是一个y行x列的随机数矩阵。那么y和x的具体值又是什么呢？它们是由for循环定义的：

for x, y in zip(sizes[:-1], sizes[1:])

首先要注意，这里是按 x, y 的顺序来赋值的，而不是 y, x，这和 np.random.randn(y, x) 中的顺序相反。
其中，zip()是Python的一个内建函数，它接受一系列可迭代的对象（例如，在这里是两个list）作为参数，将对象中对应的元素打包成一个个tuple（元组），然后返回由这些tuples组成的list。
为了形象地说明zip()的作用，我们来看看这句简单的代码：

zip([3, 4], [5, 9])

它的输出是：

[(3, 5), (4, 9)]

可见，zip() 分别取出 [3, 4] 以及 [5, 9] 这两个 list 的第一个、第二个元素，然后合成了两个 tuple：(3, 5) 和 (4, 9)，然后再把这两个tuple组成一个list：[(3, 5), (4, 9)]。所以，假设我们有如下代码：

for x, y in zip([3, 4], [5, 9])

那么 x, y 的取值就有两组了：3, 5 和 4, 9。
有了这样直观的对比，我们已经可以理解 for x, y in zip(sizes[:-1], sizes[1:]) 是什么含义了。其实 sizes 就是一个含有3个元素的list：[2, 3, 1]，因此 sizes[:-1] 就是去掉最后一个元素的子list，即 [2, 3]；而 sizes[1:] 就是去掉第一个元素的子list，即 [3, 1]。
所以现在真相大白：x, y 的取值有两组，一组是 2, 3，另一组是 3, 1。
再回去看 weights 的赋值代码，于是可以秒懂：weights 的第一个元素 weights[0] 是一个 3x2 的随机数矩阵，weights 的第二个元素 weights[1] 是一个 1x3 的随机数矩阵。
文章来源：https://www.codelast.com/
现在总结一下：
biases[0]：3x1 的矩阵
biases[1]：1x1 的矩阵
weights[0]：3x2 的矩阵
weights[1]：1x3 的矩阵

虽然我们已经精确分析出了那段代码的含义，但有人可能还是要问：为什么创建的bias和weight是这些维度的？
为了能帮助理解，我们画出这个神经网络的结构（第一层有2个神经元，第二层有3个神经元，最后一层有1个神经元）：

文章来源：https://www.codelast.com/
从图上我们可以一眼看出，第一层的输入向量（也就是  $wx + b$ 中的  $x$ ）是一个2行1列的向量，或者说是一个 2x1 的矩阵；第二层的  $x$ 是一个3行1列的向量，或者说是一个 3x1 的矩阵。
我们知道，除了输出层（output）之外，每一层的输入 $x$ 都要经过一个 $wx + b$ 的运算（这里忽略了激励函数），得到一个矩阵，作为下一层的输入。式中既然有weight（w）和  $x$  向量的点乘，weight矩阵的列数就必须和 $x$ 向量的行数相等，所以这里是不是恰好符合这个规则呢？
来看看：
第一层→第二层的 $wx + b$ 运算就是 weight[0]矩阵 $\cdot x$ + biases[0] 矩阵，即 (3x2矩阵) $\cdot$ (2x1矩阵) + (3x1矩阵)，结果是一个 3x1 的矩阵，这个矩阵，作为下一层的输入，实际上就是下一层的  $x$ 。前面我们分析过，第二层的  $x$ 应该是一个 3x1 的矩阵，这与运算结果完全相符。
第二层→第三层的  $wx + b$ 运算就是 weight[1]矩阵 $\cdot x$ + biases[1] 矩阵，即 (1x3矩阵) $\cdot$ (3x1矩阵) + (1x1矩阵)，结果是一个 1x1 的矩阵，其实就是一个标量，由于后面已经没有其他层，所以这个标量就是整个神经网络的output。

通过以上不厌其烦的分析，相信任何人都能搞明白那仅有不到10行的代码是如何巧妙地定义了一个神经网络，搞定！
文章来源：https://www.codelast.com/
➤➤ 版权声明 ➤➤ 
转载需注明出处：codelast.com 
感谢关注我的微信公众号（微信扫一扫）：