deep learning – 编码无悔 / Intent & Focused https://www.codelast.com 最优化之路 Mon, 27 Apr 2020 18:00:47 +0000 zh-Hans hourly 1 https://wordpress.org/?v=6.9.4 [原创] 《Neural Networks and Deep Learning》读书笔记：最简单的识别MNIST的神经网络程序(2) https://www.codelast.com/%e5%8e%9f%e5%88%9b-%e3%80%8aneural-networks-and-deep-learning%e3%80%8b%e8%af%bb%e4%b9%a6%e7%ac%94%e8%ae%b0%ef%bc%9a%e6%9c%80%e7%ae%80%e5%8d%95%e7%9a%84%e8%af%86%e5%88%abmnist%e7%9a%84%e7%a5%9e-2/ https://www.codelast.com/%e5%8e%9f%e5%88%9b-%e3%80%8aneural-networks-and-deep-learning%e3%80%8b%e8%af%bb%e4%b9%a6%e7%ac%94%e8%ae%b0%ef%bc%9a%e6%9c%80%e7%ae%80%e5%8d%95%e7%9a%84%e8%af%86%e5%88%abmnist%e7%9a%84%e7%a5%9e-2/#comments Thu, 31 Aug 2017 16:52:30 +0000 http://www.codelast.com/?p=9083 本文是上一篇文章的续文。
《Neural Networks and Deep Learning》一书的中文译名是《神经网络与深度学习》，书如其名，不需要解释也知道它是讲什么的，这是本入门级的好书。
在第一章中，作者展示了如何编写一个简单的、用于识别MNIST数据的Python神经网络程序。
本文接着上一篇文章对程序代码进行解析。

下面来看看 SGD() 方法的实现。先把它的完整代码贴上来：

def SGD(self, training_data, epochs, mini_batch_size, eta,
        test_data=None):
    """Train the neural network using mini-batch stochastic
    gradient descent.
… Read More ]]> 本文是上一篇文章的续文。
《Neural Networks and Deep Learning》一书的中文译名是《神经网络与深度学习》，书如其名，不需要解释也知道它是讲什么的，这是本入门级的好书。
在第一章中，作者展示了如何编写一个简单的、用于识别MNIST数据的Python神经网络程序。
本文接着上一篇文章对程序代码进行解析。

下面来看看 SGD() 方法的实现。先把它的完整代码贴上来：

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
可见，它会使k从0开始，按mini_batch_size的大小为步长递增，但最大值不超过第二个参数。
所以，training_data也是按这个套路实现了分割。
文章来源：https://www.codelast.com/
在training_data分割得到了若干个mini batch之后，下面就是对每一个mini batch分别进行训练，从而求得参数向量 w 和 b 的值。但这里是一个串行的计算，也就是说第一个mini batch计算完了，才轮到第二个mini batch计算，依此类推。
对每一个mini batch求解参数向量，其实就是这一句代码调用（eta即 \eta ，学习率，这是一个人为设定其值的超参数）：

self.update_mini_batch(mini_batch, eta)

有人可能会说，这跟待求的参数向量 w 和 b 没什么关系啊？在上一篇文章中我们看到， w 和 b 被定义成了Network类的成员变量，update_mini_batch()其实是在函数体内计算出、并更新了它们的值，所以只是表面上看起来“没关系”，实际上完全有关系。

在循环迭代完所有的mini batch之后， w 和 b 的值也就被更新完了，即“学习”的过程也就结束了。所以，随着迭代的进行， w 和 b 的值越来越接近理想值，所有迭代结束之后，我们就认为 w 和 b 的值已经达到了理想值。
文章来源：https://www.codelast.com/
在每一轮迭代的最后，有下面这段代码：

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

在每一轮迭代更新完 w 和 b 的值之后，如果test_data不为空的话，那么就会用evaluate()方法对本轮的计算结果进行评估。理论上，随着迭代一轮一轮的进行，评估结果应该越来越好。
文章来源：https://www.codelast.com/
所以，现在最关键的代码就封装在了update_mini_batch()方法中。这个方法是怎么对 w 和 b 进行计算的呢？且听下回分解。
文章来源：https://www.codelast.com/
➤➤ 版权声明 ➤➤ 
转载需注明出处：codelast.com 
感谢关注我的微信公众号（微信扫一扫）：

wechat qrcode of codelast

]]> https://www.codelast.com/%e5%8e%9f%e5%88%9b-%e3%80%8aneural-networks-and-deep-learning%e3%80%8b%e8%af%bb%e4%b9%a6%e7%ac%94%e8%ae%b0%ef%bc%9a%e6%9c%80%e7%ae%80%e5%8d%95%e7%9a%84%e8%af%86%e5%88%abmnist%e7%9a%84%e7%a5%9e-2/feed/ 8 [原创] 《Neural Networks and Deep Learning》读书笔记：反向传播的4个基本方程(1) https://www.codelast.com/%e5%8e%9f%e5%88%9b-%e3%80%8aneural-networks-and-deep-learning%e3%80%8b%e8%af%bb%e4%b9%a6%e7%ac%94%e8%ae%b0%ef%bc%9a%e5%8f%8d%e5%90%91%e4%bc%a0%e6%92%ad%e7%9a%844%e4%b8%aa%e5%9f%ba%e6%9c%ac%e6%96%b9/ https://www.codelast.com/%e5%8e%9f%e5%88%9b-%e3%80%8aneural-networks-and-deep-learning%e3%80%8b%e8%af%bb%e4%b9%a6%e7%ac%94%e8%ae%b0%ef%bc%9a%e5%8f%8d%e5%90%91%e4%bc%a0%e6%92%ad%e7%9a%844%e4%b8%aa%e5%9f%ba%e6%9c%ac%e6%96%b9/#respond Sat, 21 Jan 2017 09:40:11 +0000 http://www.codelast.com/?p=9085 从反向传播的4个基本方程这部分内容开始，《Neural Networks and Deep Learning》一书基本上是满屏的数学公式了，然而，得益于作者强大的、深入浅出的表述能力，理解起来并不会让人感觉那么难。
本文将描述反向传播的4个基本方程中的第一个——输出层误差的方程：

\delta _j^L = \frac{{\partial C}}{{\partial a_j^L}}\sigma '\left( {z_j^L} \right)
就算完全看不懂这个公式的含义，也千万不要被吓到，毕竟它才如此之短。
本文将解释一下这个公式的含义。但我必须得说，如果没有上下文的话，再怎么看解释也是没用的，毕竟这些符号是什么意思都是作者定义的，所以，必须结合原书来理解。
其中：
（1） \delta _j^L  代表神经网络的第 L 层、第 j 个神经元产生的误差。
（2）C 代表代价函数（cost function），a 代表神经网络的输出激活（activation）值，由于每一个神经元都有一个输出激活值，所以 a 是一个向量。把 a 看成一个变量， \frac{{\partial C}}{{\partial a}} 就表示用代价函数对输出激活值求导。
（3） \sigma 是作者书中所说的“向量化函数”，其实就是激活函数，因为作者在书的前面章节中已经定义过  {a^l} = \sigma ({w^l}{a^{l - 1}} + {b^l}) ，所以输出激活值就是把带权输入再应用一个  \sigma ，这就是激活函数。
（4）z 代表的是带权输入，即  {z^l} = {w^l}{a^{l - 1}} + {b^l} ，把 z 看作变量，所以  \sigma '\left( {z_j^L} \right) 表示的就是激活函数对带权输入求导。数学公式已经忘得差不多的话，一定要注意这里不是表示两个式子相乘，而是一个表示求导的式子。
文章来源：http://www.codelast.com/… Read More

]]> 从反向传播的4个基本方程这部分内容开始，《Neural Networks and Deep Learning》一书基本上是满屏的数学公式了，然而，得益于作者强大的、深入浅出的表述能力，理解起来并不会让人感觉那么难。
本文将描述反向传播的4个基本方程中的第一个——输出层误差的方程：

\delta _j^L = \frac{{\partial C}}{{\partial a_j^L}}\sigma '\left( {z_j^L} \right)
就算完全看不懂这个公式的含义，也千万不要被吓到，毕竟它才如此之短。
本文将解释一下这个公式的含义。但我必须得说，如果没有上下文的话，再怎么看解释也是没用的，毕竟这些符号是什么意思都是作者定义的，所以，必须结合原书来理解。
其中：
（1） \delta _j^L  代表神经网络的第 L 层、第 j 个神经元产生的误差。
（2）C 代表代价函数（cost function），a 代表神经网络的输出激活（activation）值，由于每一个神经元都有一个输出激活值，所以 a 是一个向量。把 a 看成一个变量， \frac{{\partial C}}{{\partial a}} 就表示用代价函数对输出激活值求导。
（3） \sigma 是作者书中所说的“向量化函数”，其实就是激活函数，因为作者在书的前面章节中已经定义过  {a^l} = \sigma ({w^l}{a^{l - 1}} + {b^l}) ，所以输出激活值就是把带权输入再应用一个  \sigma ，这就是激活函数。
（4）z 代表的是带权输入，即  {z^l} = {w^l}{a^{l - 1}} + {b^l} ，把 z 看作变量，所以  \sigma '\left( {z_j^L} \right) 表示的就是激活函数对带权输入求导。数学公式已经忘得差不多的话，一定要注意这里不是表示两个式子相乘，而是一个表示求导的式子。
文章来源：http://www.codelast.com/
现在先看（1）：为了理解这句话，要从此书前面部分的『关于代价函数的两个假设』一节说起。“两个假设”中的其中一个就是，神经网络的代价（cost）可以写成神经网络输出的激活值的函数：
C = C({a^L})
这里的 {a^L} 是一个向量，因为神经网络的某一层，会有N个神经元，每一个神经元都有一个输出激活值，例如  a_1^L ， a_2^L ，等等。

知道了这一点，再来看看这句话里所说的误差是什么？在机器学习中，我们的目的是最小化代价函数（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 
感谢关注我的微信公众号（微信扫一扫）：

wechat qrcode of codelast

]]> https://www.codelast.com/%e5%8e%9f%e5%88%9b-%e3%80%8aneural-networks-and-deep-learning%e3%80%8b%e8%af%bb%e4%b9%a6%e7%ac%94%e8%ae%b0%ef%bc%9a%e5%8f%8d%e5%90%91%e4%bc%a0%e6%92%ad%e7%9a%844%e4%b8%aa%e5%9f%ba%e6%9c%ac%e6%96%b9/feed/ 0 [原创] 《Neural Networks and Deep Learning》读书笔记：最简单的识别MNIST的神经网络程序(1) https://www.codelast.com/%e5%8e%9f%e5%88%9b-%e3%80%8aneural-networks-and-deep-learning%e3%80%8b%e8%af%bb%e4%b9%a6%e7%ac%94%e8%ae%b0%ef%bc%9a%e6%9c%80%e7%ae%80%e5%8d%95%e7%9a%84%e8%af%86%e5%88%abmnist%e7%9a%84%e7%a5%9e/ https://www.codelast.com/%e5%8e%9f%e5%88%9b-%e3%80%8aneural-networks-and-deep-learning%e3%80%8b%e8%af%bb%e4%b9%a6%e7%ac%94%e8%ae%b0%ef%bc%9a%e6%9c%80%e7%ae%80%e5%8d%95%e7%9a%84%e8%af%86%e5%88%abmnist%e7%9a%84%e7%a5%9e/#comments Wed, 04 Jan 2017 16:27:05 +0000 http://www.codelast.com/?p=9040 《Neural Networks and Deep Learning》一书的中文译名是《神经网络与深度学习》，书如其名，不需要解释也知道它是讲什么的，这是本入门级的好书。
在第一章中，作者展示了如何编写一个简单的、用于识别MNIST数据的Python神经网络程序。对于武林高手来说，看懂程序不会有任何困难，但对于我这样的Python渣则有很多困惑。所以我对做了一些笔记，希望同时也可以帮助有需要的人。

『1』原文及程序
在这里，先把中译版部分贴上来，以方便后面的笔记记录（这只是一部分）：

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

class Network(object):

    def __init__(self, sizes):
        self.num_layers = len(sizes)
        self.sizes = sizes
        self.biases
… Read More ]]> 《Neural Networks and Deep Learning》一书的中文译名是《神经网络与深度学习》，书如其名，不需要解释也知道它是讲什么的，这是本入门级的好书。
在第一章中，作者展示了如何编写一个简单的、用于识别MNIST数据的Python神经网络程序。对于武林高手来说，看懂程序不会有任何困难，但对于我这样的Python渣则有很多困惑。所以我对做了一些笔记，希望同时也可以帮助有需要的人。

『1』原文及程序
在这里，先把中译版部分贴上来，以方便后面的笔记记录（这只是一部分）：

在给出一个完整的清单之前，让我解释一下神经网络代码的核心特征，如下。核心是一个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:])]

在这段代码中，列表sizes包含各层的神经元的数量。因此举个例子，如果我们想创建一个在第一层有2个神经元，第二层有3个神经元，最后一层有1个神经元的network对象，我们应这样写代码：
net = Network([2, 3, 1])
Network对象的偏差和权重都是被随机初始化的，使用Numpy的np.random.randn函数来生成均值为0，标准差为1的高斯分布。随机初始化给了我们的随机梯度下降算法一个起点。在后面的章节中我们将会发现更好的初始化权重和偏差的方法，但是现在将采用随机初始化。注意Network初始化代码假设第一层神经元是一个输入层，并对这些神经元不设置任何偏差，因为偏差仅在之后的层中使用。
同样注意，偏差和权重以列表存储在Numpy矩阵中。因此例如net.weights[1]是一个存储着连接第二层和第三层神经元权重的Numpy矩阵。（不是第一层和第二层，因为Python列中的索引从0开始）因此net.weights[1]相当冗长， 让我们就这样表示矩阵 w 。矩阵中的 {w_{jk}} 是连接第二层的 {k^{th}} 神经元和第三层的 {j^{th}} 神经元的权重。

『2』程序解读
正如上面的代码示例，创建一个Network对象的时候，传入的是一个list，例如 [2, 3, 1]，list中有几个元素就表示神经网络有几层，从list中的第一个元素开始，每一个元素依次表示第1层、每2层、……第n层的神经元的数量。
这个不难理解，比较难理解的是 bias（偏差）以及 weight（权重）的表示方式。
文章来源：https://www.codelast.com/
我们先来看 bias（偏差）：

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

首先需要明确的是，中括号表明了 biases 是一个list，中括号里的内容是对这个list进行赋值的代码，它采用了一个for循环的方式来赋值，例如下面的代码：

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

会输出结果：

[0, 1, 2]

所以，np.random.randn(y, 1) for y in sizes[1:] 这部分代码表达的就是—— list中的每一个元素都是 np.random.randn(y, 1) 这个表达式的计算结果，而这个表达式是含有变量 y 的，y 必须要有实际的值才能计算，所以用一个for循环来给 y 赋值，y 能取的所有值就是对 sizes[1:] 这个list进行遍历得到的。前面已经说过了，sizes本身是一个list，而sizes[1:] 表示的是取这个 list 从第2个元素开始的子集，给个例子：

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

会输出：

[6, 8]

所以，在我们前面用 net = Network([2, 3, 1]) 这样的代码来创建了一个对象之后，sizes[1:] 的内容其实就是 [3, 1]，所以 y 的取值就是 3 和 1，所以 biases 这个list的第一个元素就是 np.random.randn(3, 1)，第二个元素就是 np.random.randn(1, 1)。
文章来源：https://www.codelast.com/
我觉得经过这样解释，biases 在结构上看来是什么东西已经比较清楚了吧？
那么话说回来，我们虽然知道了 np.random.randn(3, 1) 是 biases 的第一个元素，但 np.random.randn() 又是什么鬼？
且听我道来：
np 是这个Python程序 import 进来的Numpy库的缩写：

import numpy as np

randn() 是Numpy这个库中，用于生成标准正态分布数据的一个函数。其实 randn(3, 1) 生成的是一个3x1的随机矩阵，我们可以在Python命令行中直接试验一下：

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个神经元）：
three layer neural network
文章来源：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 
感谢关注我的微信公众号（微信扫一扫）：

wechat qrcode of codelast

]]> https://www.codelast.com/%e5%8e%9f%e5%88%9b-%e3%80%8aneural-networks-and-deep-learning%e3%80%8b%e8%af%bb%e4%b9%a6%e7%ac%94%e8%ae%b0%ef%bc%9a%e6%9c%80%e7%ae%80%e5%8d%95%e7%9a%84%e8%af%86%e5%88%abmnist%e7%9a%84%e7%a5%9e/feed/ 4 [原创] 加快TensorFlow在树莓派上的执行速度——服务常驻内存 https://www.codelast.com/%e5%8e%9f%e5%88%9b-%e5%8a%a0%e5%bf%abtensorflow%e5%9c%a8%e6%a0%91%e8%8e%93%e6%b4%be%e4%b8%8a%e7%9a%84%e6%89%a7%e8%a1%8c%e9%80%9f%e5%ba%a6-%e6%9c%8d%e5%8a%a1%e5%b8%b8%e9%a9%bb/ https://www.codelast.com/%e5%8e%9f%e5%88%9b-%e5%8a%a0%e5%bf%abtensorflow%e5%9c%a8%e6%a0%91%e8%8e%93%e6%b4%be%e4%b8%8a%e7%9a%84%e6%89%a7%e8%a1%8c%e9%80%9f%e5%ba%a6-%e6%9c%8d%e5%8a%a1%e5%b8%b8%e9%a9%bb/#respond Sun, 11 Dec 2016 06:19:30 +0000 http://www.codelast.com/?p=8995 本文软硬件环境：
树莓派：3代 Model B V1.2，内存1GB
OS：Arch Linux ARM

在上一篇文章中，我尝试了加快TensorFlow预测速度的一个方法——模型“预热”，实验证明它非常有效，但那仍然没有解决一个问题：每次运行程序，都要加载一次模型，然后预热N次，这个过程非常耗时，因此减少这部分时间也是非常关键的。把TensorFlow做成一个常驻内存的服务就可以解决这个问题。
解决这个问题的正确姿势是：TensorFlow已经提供了一个叫作 TensorFlow Serving 的library来实现这个需求。但麻烦的是，在树莓派上编译TensorFlow Serving会遇到很多问题，所以，在没有人搞出在树莓派上一键安装的Python wheel包之前，还是算了吧...
因此，下面我用一个很挫的办法来实现一个简陋的TensorFlow service。

『1』简单的思路
服务端，用Python实现一个web server，处理HTTP Get请求，通过解析URL中的参数（例如 http://127.0.0.1:8080/?image_path=/root/abc.jpg 中的 /root/abc.jpg），来获取待处理的图片的路径，处理完之后，把处理结果返回给客户端。
客户端，通过 curl 命令就可以调用服务了，例如：

curl http://127.0.0.1:8080/?image_path=/root/abc.jpg

这表示让服务端处理 /root/abc.jpg 这个文件。
当然，为了简单，这里的设定有一个局限：server和client都在同一个树莓派上，如果要跨机器，那么需要client把图片post到server端，server取出来之后再处理，但本文不涉及这种情况。
文章来源：http://www.codelast.com/
『2』简单Python web server的实现
不考虑什么并发，多线程之类的情况，我们可以用非常简单的一点代码就实现一个Python web server。

#!/usr/bin/python3.5
… Read More
]]> 本文软硬件环境：
树莓派：3代 Model B V1.2，内存1GB
OS：Arch Linux ARM

在上一篇文章中，我尝试了加快TensorFlow预测速度的一个方法——模型“预热”，实验证明它非常有效，但那仍然没有解决一个问题：每次运行程序，都要加载一次模型，然后预热N次，这个过程非常耗时，因此减少这部分时间也是非常关键的。把TensorFlow做成一个常驻内存的服务就可以解决这个问题。
解决这个问题的正确姿势是：TensorFlow已经提供了一个叫作 TensorFlow Serving 的library来实现这个需求。但麻烦的是，在树莓派上编译TensorFlow Serving会遇到很多问题，所以，在没有人搞出在树莓派上一键安装的Python wheel包之前，还是算了吧...
因此，下面我用一个很挫的办法来实现一个简陋的TensorFlow service。

『1』简单的思路
服务端，用Python实现一个web server，处理HTTP Get请求，通过解析URL中的参数（例如 http://127.0.0.1:8080/?image_path=/root/abc.jpg 中的 /root/abc.jpg），来获取待处理的图片的路径，处理完之后，把处理结果返回给客户端。
客户端，通过 curl 命令就可以调用服务了，例如：

curl http://127.0.0.1:8080/?image_path=/root/abc.jpg

这表示让服务端处理 /root/abc.jpg 这个文件。
当然，为了简单，这里的设定有一个局限：server和client都在同一个树莓派上，如果要跨机器，那么需要client把图片post到server端，server取出来之后再处理，但本文不涉及这种情况。
文章来源：http://www.codelast.com/
『2』简单Python web server的实现
不考虑什么并发，多线程之类的情况，我们可以用非常简单的一点代码就实现一个Python web server。

#!/usr/bin/python3.5


from http.server import BaseHTTPRequestHandler, HTTPServer
from urllib.parse import parse_qsl

class MyRequestHandler(BaseHTTPRequestHandler):
  def do_GET(self):
    # e.g. "/?image_path=/root/mobike.jpg"                                                                                                                   
    path = self.path
    # e.g. "/root/mobike.jpg"                                                                                                                                
    image_path = parse_qsl(path[2:])[0][1] + '\n'

    # send response status code                                                                                                                              
    self.send_response(200)

    # send headers                                                                                                                                           
    self.send_header('Content-type','text/html')
    self.end_headers()

    # send message back to client, write content as utf-8 data                                                                                               
    self.wfile.write(bytes(image_path, "utf8"))
    return

def start_web_server():
  print('Starting web server...')

  server_address = ('127.0.0.1', 8080)
  httpd = HTTPServer(server_address, MyRequestHandler)
  httpd.serve_forever()


start_web_server()

其中，在 MyRequestHandler 这个类中，我们会处理每一个客户端的请求，这里只是把从URL中解析到的图片文件路径简单地发送回客户端。
此代码可在我的GitHub中下载。
文章来源：http://www.codelast.com/
『3』TensorFlow服务测试
按“模型加载1次，预热10次”的原则，再结合上面的简单web server代码，我们可以很容易地把TensorFlow做成服务。具体代码比较长，这里就不粘贴上来了，在我的GitHub可以下载到。

下面测试一下效果。
把service启动起来：

./run-tensorflow-service.sh

经历几十秒的漫长等待之后，模型加载&预热就完成了（命令行输出会有提示），此时，我们再在同一台树莓派上运行client，向server发送一个处理图片的请求：

./client.sh /root/raspberry-pi/ai/tensorflow-related/resource/test-images/mobike.jpg

大概4秒多之后，client端会打印出如下信息：

mountain bike, all-terrain bike, off-roader (score = 0.56671)
tricycle, trike, velocipede (score = 0.12035)
bicycle-built-for-two, tandem bicycle, tandem (score = 0.08768)
lawn mower, mower (score = 0.00651)
alp (score = 0.00387)
Prediction used time:4.171393394470215 Seconds
换一张大小相仿的图片来测试，消耗的时间也是差不多的，达到了我们预期的效果。至此，它距离“实用”又更近了一步。

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

wechat qrcode of codelast

]]> https://www.codelast.com/%e5%8e%9f%e5%88%9b-%e5%8a%a0%e5%bf%abtensorflow%e5%9c%a8%e6%a0%91%e8%8e%93%e6%b4%be%e4%b8%8a%e7%9a%84%e6%89%a7%e8%a1%8c%e9%80%9f%e5%ba%a6-%e6%9c%8d%e5%8a%a1%e5%b8%b8%e9%a9%bb/feed/ 0 [原创] 在树莓派上用TensorFlow玩深度学习(Deep Learning) https://www.codelast.com/%e5%8e%9f%e5%88%9b-%e5%9c%a8%e6%a0%91%e8%8e%93%e6%b4%be%e4%b8%8a%e7%94%a8tensorflow%e7%8e%a9%e6%b7%b1%e5%ba%a6%e5%ad%a6%e4%b9%a0deep-learning/ https://www.codelast.com/%e5%8e%9f%e5%88%9b-%e5%9c%a8%e6%a0%91%e8%8e%93%e6%b4%be%e4%b8%8a%e7%94%a8tensorflow%e7%8e%a9%e6%b7%b1%e5%ba%a6%e5%ad%a6%e4%b9%a0deep-learning/#comments Tue, 06 Dec 2016 17:08:58 +0000 http://www.codelast.com/?p=8941 本文软硬件环境：
树莓派：3代 Model B V1.2，内存1GB
OS：Arch Linux ARM

深度学习（Deep Learning）现在这么火，树莓派玩家们当然也不会放过，目前已经有很多树莓派项目都搭上了Deep Learning的车，纯粹出于“好玩”的目的，我在树莓派上也实验了一把，用TensorFlow来识别一张图片里的物体“是什么”。

『1』对深度学习（Deep Learning）的简单介绍
以下解释来自维基百科：

深度学习是机器学习拉出的分支，它试图使用包含复杂结构或由多重非线性变换构成的多个处理层对数据进行高层抽象的算法。

深度学习的用途实在太广泛，最为普通人所熟知的，就是以下和民生相关的应用：人脸识别，语音识别，图像搜索，在线翻译，等等。
目前流行的深度学习框架有TensorFlow（Google开源），MXNet（得到Amazon支持），Theano等，利用这些框架，我们只需要做比较少的工作，就能把深度学习能力带入我们自己的程序。
文章来源：http://www.codelast.com/
『3』树莓派上的深度学习
当前，主流的深度学习框架都不是主要为了移动平台／嵌入式平台而准备的——这是由于计算能力所限，在移动平台上运行local的深度学习程序，计算速度通常会非常慢。因此，移动平台上主要还是采用向云端提交计算请求、云端计算完成后返回结果的方式来处理数据。
作为一个“类嵌入式”平台，树莓派虽然是同类型里最受关注的产品，但我认为在深度学习的世界里，树莓派还没到像Android、iOS那种“开发一个App必须要支持”的程度。
因此，把任何一个主流的深度学习框架，在树莓派上跑起来都将是一个耗时耗力的工作。
好在TensorFlow是如此流行，并且IT界永远不缺牛人，已经有人把它成功地“移植”到了树莓派3代上（看这里），所以，在树莓派上用TensorFlow来实现深度学习应用是一个不错的选择。
文章来源：http://www.codelast.com/
『3』在树莓派上安装TensorFlow
按作者的文档，通过极其简单的几步操作，就可以在树莓派上把TensorFlow跑起来。如果你有兴趣，可以直接去看作者写的教程。
首先要声明的是：

  • 作者在树莓派上使用的最流行的Linux发行版Raspbian，而我使用的OS是Arch Linux ARM，不过这无所谓，经过我的测试，没有问题（至少我没遇到）
  • 由于在树莓派上开发其他程序的原因，我已经预先安装过了比较多的开发库／软件，类似于Protocol Buffers，NumPy，pip等，而这些软件有些可能会被TensorFlow依赖，所以，我就不需要像作者的文档里说的一样另外再去安装它们了

文章来源：http://www.codelast.com/… Read More

]]> 本文软硬件环境：
树莓派：3代 Model B V1.2，内存1GB
OS：Arch Linux ARM

深度学习（Deep Learning）现在这么火，树莓派玩家们当然也不会放过，目前已经有很多树莓派项目都搭上了Deep Learning的车，纯粹出于“好玩”的目的，我在树莓派上也实验了一把，用TensorFlow来识别一张图片里的物体“是什么”。

『1』对深度学习（Deep Learning）的简单介绍
以下解释来自维基百科：

深度学习是机器学习拉出的分支，它试图使用包含复杂结构或由多重非线性变换构成的多个处理层对数据进行高层抽象的算法。

深度学习的用途实在太广泛，最为普通人所熟知的，就是以下和民生相关的应用：人脸识别，语音识别，图像搜索，在线翻译，等等。
目前流行的深度学习框架有TensorFlow（Google开源），MXNet（得到Amazon支持），Theano等，利用这些框架，我们只需要做比较少的工作，就能把深度学习能力带入我们自己的程序。
文章来源：http://www.codelast.com/
『3』树莓派上的深度学习
当前，主流的深度学习框架都不是主要为了移动平台／嵌入式平台而准备的——这是由于计算能力所限，在移动平台上运行local的深度学习程序，计算速度通常会非常慢。因此，移动平台上主要还是采用向云端提交计算请求、云端计算完成后返回结果的方式来处理数据。
作为一个“类嵌入式”平台，树莓派虽然是同类型里最受关注的产品，但我认为在深度学习的世界里，树莓派还没到像Android、iOS那种“开发一个App必须要支持”的程度。
因此，把任何一个主流的深度学习框架，在树莓派上跑起来都将是一个耗时耗力的工作。
好在TensorFlow是如此流行，并且IT界永远不缺牛人，已经有人把它成功地“移植”到了树莓派3代上（看这里），所以，在树莓派上用TensorFlow来实现深度学习应用是一个不错的选择。
文章来源：http://www.codelast.com/
『3』在树莓派上安装TensorFlow
按作者的文档，通过极其简单的几步操作，就可以在树莓派上把TensorFlow跑起来。如果你有兴趣，可以直接去看作者写的教程。
首先要声明的是：

  • 作者在树莓派上使用的最流行的Linux发行版Raspbian，而我使用的OS是Arch Linux ARM，不过这无所谓，经过我的测试，没有问题（至少我没遇到）
  • 由于在树莓派上开发其他程序的原因，我已经预先安装过了比较多的开发库／软件，类似于Protocol Buffers，NumPy，pip等，而这些软件有些可能会被TensorFlow依赖，所以，我就不需要像作者的文档里说的一样另外再去安装它们了

文章来源：http://www.codelast.com/
然后剩下最关键的一步就是，从GitHub下载一个wheel文件并安装。
wheel是众多Python软件安装包格式中的一种，本质上是一个zip包格式，它使用.whl作为扩展名，用于安装Python模块。

如果你使用Python 2.7：

wget https://github.com/samjabrahams/tensorflow-on-raspberry-pi/releases/download/v0.11.0/tensorflow-0.11.0-cp27-none-linux_armv7l.whl
sudo pip install tensorflow-0.11.0-cp27-none-linux_armv7l.whl

如果你使用Python 3.3+（但据作者所说，3.5以及3.6是不保证能支持的，不过，我用3.5.2还是安装成功了）：

wget https://github.com/samjabrahams/tensorflow-on-raspberry-pi/releases/download/v0.11.0/tensorflow-0.11.0-py3-none-any.whl
sudo pip3 install tensorflow-0.11.0-py3-none-any.whl

下载whl安装包的过程可能会比较漫长，我使用的是Python 3.5.2，下面是我的命令行输出内容：

Processing ./tensorflow-0.10.0-py3-none-any.whl
Collecting protobuf==3.0.0b2 (from tensorflow==0.10.0)
  Downloading protobuf-3.0.0b2-py2.py3-none-any.whl (326kB)
    100% |████████████████████████████████| 327kB 11kB/s
Collecting wheel>=0.26 (from tensorflow==0.10.0)
  Downloading wheel-0.29.0-py2.py3-none-any.whl (66kB)
    100% |████████████████████████████████| 71kB 18kB/s
Requirement already satisfied (use --upgrade to upgrade): numpy>=1.8.2 in /usr/lib/python3.5/site-packages (from tensorflow==0.10.0)
Requirement already satisfied (use --upgrade to upgrade): six>=1.10.0 in /usr/lib/python3.5/site-packages (from tensorflow==0.10.0)
Requirement already satisfied (use --upgrade to upgrade): setuptools in /usr/lib/python3.5/site-packages (from protobuf==3.0.0b2->tensorflow==0.10.0)
Installing collected packages: protobuf, wheel, tensorflow
Successfully installed protobuf-3.0.0b2 tensorflow-0.10.0 wheel-0.29.0
You are using pip version 8.1.2, however version 9.0.1 is available.
You should consider upgrading via the 'pip install --upgrade pip' command.

文章来源：http://www.codelast.com/
然后呢？然后就搞定了！就这么简单！

如果上面的步骤失败了，那么你就只能选择从源码来编译TensorFlow，这是一个相当麻烦的工作，只能祝你好运了，不过好消息就是，作者已经帮大家踩过很多坑了，教程在这里。

『4』在树莓派上使用TensorFlow
要识别一张图片里的物体是什么，我们需要先训练一个图像分类模型，这个过程非常消耗计算资源，在树莓派上干这事是不明智的，我们可以直接使用Google已经训练好的Inception-v3模型。

Inception-v3 is trained for the ImageNet Large Visual Recognition Challenge using the data from 2012. This is a standard task in computer vision, where models try to classify entire images into 1000 classes, like "Zebra", "Dalmatian", and "Dishwasher".

先下载Inception-V3模型到任意目录中，并解压出来：

mkdir ~/tensorflow-related/model
cd ~/tensorflow-related/model
wget http://download.tensorflow.org/models/image/imagenet/inception-2015-12-05.tgz
tar xf inception-2015-12-05.tgz

解压出来一堆文件：

classify_image_graph_def.pb
cropped_panda.jpg
imagenet_2012_challenge_label_map_proto.pbtxt
imagenet_synset_to_human_label_map.txt
LICENSE

然后就可以开始进行图像识别啦。在这里我从网上找了一张时下很流行的摩拜单车（Mobike）的图片：
mobike
文章来源：http://www.codelast.com/
用TensorFlow来识别它：

cd /usr/lib/python3.5/site-packages/tensorflow/models/image/imagenet
python3.5 classify_image.py --model_dir /root/tensorflow-related/model --image_file /root/tensorflow-related/test-images/mobike.jpg

其中，/usr/lib/python3.5/site-packages/tensorflow/models/image/imagenet 这个路径是TensorFlow的 Python图像分类程序 classify_image.py 所在的路径，不同的OS可能不一样。
--model_dir 参数传入的是我们前面解压出来的模型文件所在的路径，--image_file 是待识别的图片的路径。
注：如果找不到classify_image.py文件，请参考本文末的更新说明。
输出如下：

/usr/lib/python3.5/site-packages/tensorflow/python/ops/array_ops.py:1750: VisibleDeprecationWarning: converting an array with ndim > 0 to an index will result in an error in the future
  result_shape.insert(dim, 1)
W tensorflow/core/framework/op_def_util.cc:332] Op BatchNormWithGlobalNormalization is deprecated. It will cease to work in GraphDef version 9. Use tf.nn.batch_normalization().
bicycle-built-for-two, tandem bicycle, tandem (score = 0.33731)
tricycle, trike, velocipede (score = 0.16082)
unicycle, monocycle (score = 0.12926)
mountain bike, all-terrain bike, off-roader (score = 0.10689)
parking meter (score = 0.01563)
[root@alarmpi imagenet]# python3.5 classify_image.py --model_dir /root/tensorflow-related/model --image_file /root/tensorflow-related/test-images/mobike.jpg
/usr/lib/python3.5/site-packages/tensorflow/python/ops/array_ops.py:1750: VisibleDeprecationWarning: converting an array with ndim > 0 to an index will result in an error in the future
  result_shape.insert(dim, 1)
W tensorflow/core/framework/op_def_util.cc:332] Op BatchNormWithGlobalNormalization is deprecated. It will cease to work in GraphDef version 9. Use tf.nn.batch_normalization().
mountain bike, all-terrain bike, off-roader (score = 0.56671)
tricycle, trike, velocipede (score = 0.12035)
bicycle-built-for-two, tandem bicycle, tandem (score = 0.08768)
lawn mower, mower (score = 0.00651)
alp (score = 0.00387)

可见，TensorFlow认为图片是山地自行车（mountain bike）／全地形自行车（all-terrain bike）／越野车（off-roader）的概率是0.56671，识别结果还算可以。
文章来源：http://www.codelast.com/
『5』计算速度问题
上面的一次图像识别试验，总共花了50多秒的时间！这么慢的速度在实际应用中基本没有实用价值。
但实际上，这个时间是可以大幅缩短的。

  • 为模型“预热”很有必要。根据作者等人的性能测试结果，在合理预热的情况下，计算时间会减少较多。我测试了一下，请看这篇文章。
  • 我们每运行一次程序，就重新加载一次模型，而模型文件又很大，这非常浪费时间，所以，应该把程序做成一个常驻内存的程序，只加载一次模型，每次识别一幅图像就能减少很多很多时间。我也实验了一下，请看这篇文章。
  • 使用TensorFlow的C++接口来实现程序应该比Python版速度快，可以尝试。
  • 暂时还不能让TensorFlow使用树莓派的GPU来计算（看这里），但大家期待未来有一天这个愿望会实现。

所以至少50多秒这种恐怖的数字是可以避免的。
文章来源：http://www.codelast.com/
『6』在树莓派上跑TensorFlow有什么用
我随意想到的一个可能有意义的应用就是：一个幼儿辅助学习系统。在树莓派上挂载一个摄像头，孩子在摄像头前拿着一样东西，摄像头抓拍一张图片，识别出里面的东西，朗读出概率最大的那个英文单词。
当然，这里面有非常多的工程上的问题需要解决。

我相信，随着树莓派下一代的计算能力继续增强，以及TensorFlow每一次发布，都让性能提高一些，在不久的将来，在树莓派上跑TensorFlow应用的实用性将会非常好。
文章来源：http://www.codelast.com/
『7』更新

  • 2017.03.19更新

在本文写完之后不久，作者就发布了基于TensorFlow 1.0.0的Python wheel包，我试验了一下，它无法在Python 3.6.0的环境下安装，提示错误是：

tensorflow-1.0.0-cp34-cp34m-linux_armv7l.whl is not a supported wheel on this platform

作者说这是因为暂时不支持Python 3.5+。所以为了装上新版的TensorFlow，我用回了Python 2.7，然后就发现可以正常安装了：

pacman -S python2 python2-pip
pip2 install tensorflow-1.0.0-cp27-none-linux_armv7l.whl

期待以后能支持。

  • 2017.08.19更新

如果你安装的是1.1.0版本的TensorFlow on Raspberry Pi，那么你会发现你找不到classify_image.py文件，这是因为此版本确实不再包含该文件，这时你可以在TensorFlow的这个子项目里找到该文件。

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

wechat qrcode of codelast

]]> https://www.codelast.com/%e5%8e%9f%e5%88%9b-%e5%9c%a8%e6%a0%91%e8%8e%93%e6%b4%be%e4%b8%8a%e7%94%a8tensorflow%e7%8e%a9%e6%b7%b1%e5%ba%a6%e5%ad%a6%e4%b9%a0deep-learning/feed/ 16