DL 在线书籍源码阅读（二）

GjzCVCode

---

IO 部分

仍然是 IO 部分，上一篇针对的是只有一个隐藏层的网络，这本在线书后两章介绍了 DNN，以及其中一种 model： ConvNet，本书中的 ConvNet 的 Python 实现与之前的有一个不同之处：Thenao 的使用。

1.1 Theano

Theano 可以借助 GPU 加速，在读取数据时多了一个将数据 copy 到 GPU 的过程，就是下面的 shared() 函数，这里有一些细节：

return shared_x, T.cast(shared_y, "int32")

以上这行代码的返回值是 tuple 形式，T.cast 应该是将 shared_y，就是表示 digit的 10 维向量转换为 int32 datatype，但 GPU 运算的时候还是使用 float32 格式。Theano 调用 GPU，只需调用 Theano.shared() 函数，很方便，当然，底层是通过 cuda 来运作的（具体的机制不清楚，只能靠大概的猜测，Theano 调用 cuda 库的函数）。自己的 mint 系统装不了 cuda，另一个 ubuntu 系统上还没花时间配置 theano 等库。目前只用 CPU 跑。

def load_data_shared(filename="../data/mnist.pkl.gz"):
    f = gzip.open(filename, 'rb')
    training_data, validation_data, test_data = cPickle.load(f)
    f.close()
    def shared(data):
        """Place the data into shared variables.  This allows Theano to copy
        the data to the GPU, if one is available.
        """
        shared_x = theano.shared(
            np.asarray(data[0], dtype=theano.config.floatX), borrow=True)
        shared_y = theano.shared(
            np.asarray(data[1], dtype=theano.config.floatX), borrow=True)
        return shared_x, T.cast(shared_y, "int32")
    return [shared(training_data), shared(validation_data), shared(test_data)]

仔细看了下代码，要开启 GPU mode，配置如下

theano.config.device = 'gpu'

1.2 小结

IO 部分应该就是这么多内容，关于 Theano 写的很少，因为还没花时间研究。接下来会写网络具体实现的部分。

NN 部分

关于单个隐藏层的 NN （不知道用什么 term 来描述）的实现，我先花一点时间笼统地总结一下这个，然后总结下 CNN ，CNN 是以 NN 为基础的，如果我把这些全忘了（十年内应该不会全忘），我可能会先从基础部分的 NN 看起。

2.1 Earlier NN

我想带着问题，对源码进行通读是个不错的选择。假设已经对 NN 有了一个大概的概念，比如知道 [input|hideen|output]layer, neuron(unit), weights, biases, activation function 这些词的意思。

2.1.1 如何初始化一个网络？

Python 是 OO (面向对象)的，初始化网络的部分当然要放在 contruction (构造函数)部分中。

网络的规模

首先是网络的规模，由一个 list 中的变量表示，784×100×10 就用

sizes = [784, 100, 10]

表示，网络的规模是可调的，隐藏层的 unit
个数一般多多益善，但会增长训练的时间。

初始值

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

接下来是 weights, biases 的初始值问题，上面这段代码用的是高斯分布 $N(0, 1)$，但这种方法可能会导致网络过早 saturate，训练不动（即 weights、biases 没啥变化），就我知道的有两种改进方法，一是用 $N(0, 1) / \sqrt {n_{in}}$，这是从 $\sigma(z)$ 和 $z = \sum_j w_j x_j+b$ 两个式子搞出来的，大概原因是大量 $z$ 分布在远大于 $1$ 和远小于 $-1$ 的位置，使得 hidden layer 的输出 $\sigma(z)$ 接近 $0$ 或 $1$，网络训练不动，改进后，分布在远大于 $1$ 和远小于 $-1$ 的位置变少了，二是用 dropout 的方法，就是在训练的时候，每次只选择，随机地去掉一半的 hidden layer 中的 unit 数目，其实 dropout 这个 trick 应该属于 train 过程中的，不过既然想到了就按这个顺序写吧。

2.1.2 网络的 feedforward 过程？

网络的前向计算过程容易理解，但是在 Python 处理的时候，要特别注意整个符号体系以及下标。为了简化代码，乘积运算用的都是矩阵或向量的形式。代码很短。

def feedforward(self, a):
    """Return the output of the network if ``a`` is input."""
    for b, w in zip(self.biases, self.weights):
        a = sigmoid(np.dot(w, a)+b)
    return a

调参似乎不涉及到 feedfoward 过程，在这个过程能下功夫的就是矩阵运算的优化了，Python 的 numpy 有一些优化，不过有专门处理 Linear Algebra 的库，比如 BLAS 等库，我曾在 C++ 中简单地用过 Armadillo 库。不过在训练过程中，运算的优化起到明显效果的，针对的应该不是 feedfoward，而是 backpropagate 过程。当然，拿一个训练好的模型来用的话，矩阵运算优化对 feedfoward 就很重要了，因为直接决定了效率。

2.1.3 网络是如何训练的？

网络的训练其实是 weights 和 biases 的调整过程，BP 算法提供梯度计算的方法，Stochastic Gradient Descent 算法（有变种，如 Hessian，Momemtum-based，我还没研究）其实是对求目标函数最小值算法的复杂度的一个优化（有点绕）。具体说一下，$C$ 是最终的优化目标函数（这里的 $C$ 用的是 quadratic cost function，还有 cross-entropy，其余的我还没了解，但推导过程应该类似），$x$ 是 input，即 784 维的向量。

$$\begin{eqnarray} C = \frac{1}{2n} \sum_x \|y(x)-a^L(x)\|^2, \tag{1}\end{eqnarray}$$

但是 BP 算法是计算这个目标函数的梯度。

$$\tag{2} C_x = \frac{1}{2} \|y-a^L \|^2$$
理论上，计算 $\frac{\partial C}{\partial w^l_{jk}}$, $\frac{\partial C}{\partial b^l_j}$ 是要 $(2)$ 式所有的 $x$ 的和，这个规模是训练数据集的规模，很大，比如 $50000$ 张 images，就是 $50000$ 的规模，现在一般计算机 cpu 频率在 $10^8$ ~ $10^9$ 上下，粗略估计了下，一个 784 × 100 × 10 规模的简单网络，只训练一个 epoch，大概在小时左右的级别。SGD 算法就是来拯救这种局面的，SGD 可以使用小规模的 sample 来近似目标函数 $C$ 的梯度，这个小规模就是 mini_batch_size，然后规模变成了 mini_batch_size × mini_batch_size，mini_batch_size 若为 10，计算规模（局部，不是整体）就下降到 100，训练速度一下子提升了 500 倍，如果训练数据规模更大的话，SGD（以及变种） 的效果就更明显。我测试了一下，一个 epoch，mini_batch_size 设置为 10，784 × 100 × 10 的网络，Python 版本（cpu mode，只用了 numpy，theano 等库没用）需要 30s。

具体的训练过程，可以参考这个：BP 算法以及 BP+SGD 算法描述。这是核心的算法。关于 BP、SGD 的算法的推导证明的在此忽略（SGD 我还具体去看）。

至于代码部分，先定位到 SGD() 函数，我删除了部分代码，只留下核心算法。

def SGD(self, training_data, epochs, mini_batch_size, etalmbda = 0.0):
    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, lmbda, len(training_data))
            print "Epoch %s training complete" % j

random.shuffle 随机排列 list 数据，即 training_data（是一个list），mini_batches list 存储了 mini_batch_size × mini_batch_size 张 images，，即 inputs。每一个 mini_batch 作为 update_mini_batch() 函数的参数，update_mini_batch() 会调用 backprop() 函数计算每一个 input $x$ 时，$C_x$ 的梯度，然后用这个梯度来更新 weights 和 biases 的值。其它的看看 doc string 就能明白。update_mini_batch() 和 backprop() 都有几十行，就不贴了。这是完整代码。

训练过程中涉及到的参数比较多，可调的参数，可能涉及的 trick，加上之前的，把我能想到的都列在这。

• size：网络规模
• cost function：QuadraticCost, CrossEntropyCost
• weight initialization：初始化边的不同的方法
• training data： 可以 expand，就是创建更多的数据集，减轻 overfit
• epochs
• mini batch size
• eta
• lmbda： 网络的 regularization 的参数，有 L1, L2 类型等，是在 cost function
  中添加的参数，为了减轻 overfit，更好的训练
• activication function：有 sigmoid, tanh() ，max{0, z} 等
• dropout
• softmax layer

其中，数 regularization 和 dropout 比较黑科技，expand training
data 比较有趣。另外，书中有相当长的篇幅是介绍如何调参的，hyper parameter。

---