大城小馆（二）

2022-08-31

东江人家客家菜

第一次知道这家店的时候是我在2019年的初夏，我刚来北京不久。某天，和远道而来的朋友临时约了我们俩中间的位置，在惠新西街南口吃饭，出了地铁C口，也不知道吃什么，一直向前走，过了不久，见到一个饭馆门口聚集了很多人等位置。抬头一看，很朴素的招牌——东江人家，店外窗口排了一条长龙，在等刚出炉的烧鹅，吊在窗前，外皮油亮油亮的，肉汁滴答滴答向下落。看到这阵势，就有想吃的冲动，于是就叫了号。一看单子，店面不大，还要等7桌，考虑到朋友离得不近，就找了附近的店，简单的吃了点火锅。但这个馆子深深扎进我的心里，下次一定要试试，过了差不多一个月我就再次来了。。。

惠州烧鹅

他家招牌菜，每桌必点，六两起售，外皮油光四射，晶莹透亮，犹如琥珀一般。大刀快斩，肉汁流淌，香气扑鼻。夹起一块，深深的沾满特制的梅子酱，放入口中咀嚼，外皮的焦酥，鹅肉的咸香，在青梅味道衬托下，能感到一丝清香，看似油腻的菜，但大口大口的吃根本停不下来。

腊味煲仔饭

一份优秀的煲仔饭，一定要具备三点，料好、汁浓、锅巴。这家煲仔饭算是完全达到了，米选用广东丝苗米，米粒细长，无腹、心白，透明晶莹，素有中国米中之王称号。煲饭完成，保证只有最外层的米粒成了饭焦，薄薄一层，只有一粒米的厚度，呈金黄色泽，而非焦黑深黄，焦而不糊，非常考验火候。在腊肠、腊肉上浇上浓浓的特制酱汁，用勺子由底向上翻拌，满屋飘香。一勺送到嘴了，感受的直通天灵盖的美味。

甜酸咕咾肉

很正宗的做法，以往我吃过都算是咕咾肉中异类，他家选用排骨肉作为主料，上生粉偏厚，保证炸制过程中，外皮酥脆，但肉汁饱满。一口下去，肉汁混合着甜酸汁，幸福感爆棚。

干炒牛河

非常考验粤菜基本功的一道菜。他家干炒牛河色泽油润亮泽、牛肉滑嫩焦香、河粉爽滑筋道、盘中干爽无汁。这菜一定要刚出锅，趁着有锅气吃，凉了味道会大大折扣。

生啫芥兰

芥兰是广东特有的蔬菜，颜色翠绿，清脆爽口。但对于我一个肉食主义者，清炒有些寡淡，只有配上油脂浓浓的土猪肉，砂锅生啫的做法才适合我。盖上盖子，这么一焖，芥兰混合的土猪肉的香气，不来两碗米饭都对不起这道菜。

地址：北京市朝阳区北土城东路元大都遗址公园6号

展开全文 >>

大城小馆（一）

2022-08-28

北京是一个多元化的大城市，也是极具包容性的城市，每天都有来自不同城市的打工人生活亦或生存。对于我来说，唯有美食才能慰藉疲惫心灵，找到些许异在他乡的安慰。

八条一号餐厅

这是一家隐蔽在胡同里的小馆子，店面不大，集合了云南菜和北京菜的特色，店内外布满了绿植，顾客也都是胡同周边的人，菜品风味独特，价格平民，总之富有烟火气。该菜馆也是受到陈晓卿先生、蔡澜先生所青睐，我也去了不下十次。

金亚小炒

餐厅老板叫张金亚，故名思意，这道菜就是他发明的，也是该店的必点菜。金亚小炒主要有鸡腿肉、大虾、腰果、灯笼椒等组成，这道菜味道酸甜咸鲜，口感焦酥，肉质汁水丰富。无论味道还是口感都是一级棒，调汁恰到好处，尤其是酸甜的比例，出锅酸味直通鼻腔，但吃起来酸甜刚好合适，甜度多一分则腻，酸度多一份则冲，具备菜品风味的同时，保留了食材的本味，非常值得推荐！分为精品版和普通版，区别在于普通版使用花生，精品版使用腰果，第一次建议精品版。

烙饼卷肘子

一道热量爆炸的菜！我是一个大饼卷肉的忠实粉丝，这道菜也是他家招牌菜，肘子软烂咸香，菜码丰富多样，烙饼酥香酥脆。一角饼劈开，加两片肥瘦相间的大肉片儿，再加入香椿苗、黄瓜条、葱丝萝卜丝啥的。大口张开，一口咬下去，满口流油，用郭德纲的段子形容，大口吃这个，旁边枪击你爸爸，你都不带心疼的。。。

昆明煎土豆

昆明煎土豆是云南特色小吃，这道菜焦香酥脆，土豆块大小均匀，看起来金黄金黄的，口感非常棒，表皮酥脆，里面软软绵绵的，烹饪的方式是先炸后炒，出锅之后撒了一点辣椒面调味，值得一试，吃多了会略显油腻。

风味油豆腐丝

算是这家的隐藏菜，在菜单不起眼的位置，价格便宜，第一次去这个家店就点了，很出乎意料的一道菜，要是就着大米粥吃，我能吃三碗。咸鲜口，酱味浓郁，也很适合和朋友下酒聊天。

红酒煎猪肝

猪肝做的火候特别嫩，吃起来无脏器味，一点也不像猪肝，浓油赤酱，略有果味，挺惊艳的一道菜，这也算是我目前吃过最好吃的猪肝做的菜。

地址：北京市西城区西四北八条1号

展开全文 >>

ResNet算法解读

2021-09-02

引言

深度残差网络（Deep residual network,ResNet）的提出是CNN图像史上的一件里程碑事件，让我们先看一下ResNet在ILSVRC和COCO 2015上的战绩：

图1 ResNet在ILSVRC和COCO 2015上的战绩

ResNet取得了5项第一，并又一次刷新了CNN模型在ImageNet上的历史：

图2 ImageNet分类Top-5误差

ResNet的作者何凯明也因此摘得CVPR2016最佳论文奖，当然何博士的成就远不止于此，感兴趣的可以去搜一下他后来的辉煌战绩。那么ResNet为什么会有如此优异的表现呢？其实ResNet是解决了深度CNN模型难训练的问题，从图2中可以看到14年的VGG才19层，而15年的ResNet多达152层，这在网络深度完全不是一个量级上，所以如果是第一眼看这个图的话，肯定会觉得ResNet是靠深度取胜。事实当然是这样，但是ResNet还有架构上的trick，这才使得网络的深度发挥出作用，这个trick就是残差学（Residual learning）。下面详细讲述ResNet的理论及实现。

深度网络的退化问题

从经验来看，网络的深度对模型的性能至关重要，当增加网络层数后，网络可以进行更加复杂的特征模式的提取，所以当模型更深时理论上可以取得更好的结果，从图2中也可以看出网络越深而效果越好的一个实践证据。但是更深的网络其性能一定会更好吗？实验发现深度网络出现了退化问题（Degradation problem）：网络深度增加时，网络准确度出现饱和，甚至出现下降。这个现象可以在图3中直观看出来：56层的网络比20层网络效果还要差。这不会是过拟合问题，因为56层网络的训练误差同样高。我们知道深层网络存在着梯度消失或者爆炸的问题，这使得深度学习模型很难训练。但是现在已经存在一些技术手段如BatchNorm来缓解这个问题。因此，出现深度网络的退化问题是非常令人诧异的。

图3 20层与56层网络在CIFAR-10上的误差

残差学习

深度网络的退化问题至少说明深度网络不容易训练。但是我们考虑这样一个事实：现在你有一个浅层网络，你想通过向上堆积新层来建立深层网络，一个极端情况是这些增加的层什么也不学习，仅仅复制浅层网络的特征，即这样新层是恒等映射（Identitymapping）。在这种情况下，深层网络应该至少和浅层网络性能一样，也不应该出现退化现象。好吧，你不得不承认肯定是目前的训练方法有问题，才使得深层网络很难去找到一个好的参数。

这个有趣的假设让何博士灵感爆发，他提出了残差学习来解决退化问题。对于一个堆积层结构（几层堆积而成）当输入为 $\displaystyle x$ 时其学习到的特征记为 $\displaystyle H(x)$ ，现在我们希望其可以学习到残差 $\displaystyle F(x)=H(x)-x$，这样其实原始的学习特征是 $\displaystyle F(x)+x$ 。之所以这样是因为残差学习相比原始特征直接学习更容易。当残差为0时，此时堆积层仅仅做了恒等映射，至少网络性能不会下降，实际上残差不会为0，这也会使得堆积层在输入特征基础上学习到新的特征，从而拥有更好的性能。残差学习的结构如图4所示。这有点类似与电路中的“短路”，所以是一种短路连接（shortcut connection）。

图4 残差学习单元
为什么残差学习相对更容易，从直观上看残差学习需要学习的内容少，因为残差一般会比较小，学习难度小点。不过我们可以从数学的角度来分析这个问题，首先残差单元可以表示为：

其中 $\displaystyle x_{l}$ 和 $\displaystyle x_{l+1}$ 分别表示的是第 $\displaystyle l$ 个残差单元的输入和输出，注意每个残差单元一般包含多层结构。 $\displaystyle F$ 是残差函数，表示学习到的残差，而$\displaystyle h(x_{l})=x_{l}$ 表示恒等映射， $\displaystyle f$ 是ReLU激活函数。基于上式，我们求得从浅层 $\displaystyle l$ 到深层 $\displaystyle L$ 的学习特征为：

利用链式规则，可以求得反向过程的梯度：

式子的第一个因子表示的损失函数到达 $\displaystyle L$ 的梯度，小括号中的1表明短路机制可以无损地传播梯度，而另外一项残差梯度则需要经过带weights的层，梯度不是直接传递过来的。残差梯度不会那么巧全为-1，而且就算其比较小，有1的存在也不会导致梯度消失。所以残差学习会更容易。要注意上面的推导并不是严格的证明。

ResNet的网络结构

ResNet网络是参考了VGG19网络，在其基础上进行了修改，并通过短路机制加入了残差单元，如图5所示。变化主要体现在ResNet直接使用stride=2的卷积做下采样，并且用global average pool层替换了全连接层。ResNet的一个重要设计原则是：当feature map大小降低一半时，feature map的数量增加一倍，这保持了网络层的复杂度。从图5中可以看到，ResNet相比普通网络每两层间增加了短路机制，这就形成了残差学习，其中虚线表示feature map数量发生了改变。图5展示的34-layer的ResNet，还可以构建更深的网络如表1所示。从表中可以看到，对于18-layer和34-layer的ResNet，其进行的两层间的残差学习，当网络更深时，其进行的是三层间的残差学习，三层卷积核分别是1x1，3x3和1x1，一个值得注意的是隐含层的feature map数量是比较小的，并且是输出feature map数量的1/4。

图5 ResNet网络结构图

表1 不同深度的ResNet

下面我们再分析一下残差单元，ResNet使用两种残差单元，如图6所示。左图对应的是浅层网络，而右图对应的是深层网络。对于短路连接，当输入和输出维度一致时，可以直接将输入加到输出上。但是当维度不一致时（对应的是维度增加一倍），这就不能直接相加。有两种策略：（1）采用zero-padding增加维度，此时一般要先做一个downsamp，可以采用strde=2的pooling，这样不会增加参数；（2）采用新的映射（projection shortcut），一般采用1x1的卷积，这样会增加参数，也会增加计算量。短路连接除了直接使用恒等映射，当然都可以采用projection shortcut。

图6 不同的残差单元

作者对比18-layer和34-layer的网络效果，如图7所示。可以看到普通的网络出现退化现象，但是ResNet很好的解决了退化问题。

图7 18-layer和34-layer的网络效果

最后展示一下ResNet网络与其他网络在ImageNet上的对比结果，如表2所示。可以看到ResNet-152其误差降到了4.49%，当采用集成模型后，误差可以降到3.57%。

表2 ResNet与其他网络的对比结果

说一点关于残差单元题外话，上面我们说到了短路连接的几种处理方式，其实作者在文献[2]
中又对不同的残差单元做了细致的分析与实验，这里我们直接抛出最优的残差结构，如图8所示。改进前后一个明显的变化是采用pre-
activation，BN和ReLU都提前了。而且作者推荐短路连接采用恒等变换，这样保证短路连接不会有阻碍。感兴趣的可以去读读这篇文章。

图8
改进后的残差单元及效果

ResNet的TensorFlow实现

这里给出ResNet50的TensorFlow实现，模型的实现参考了 Caffe版本的实现，核心代码如下：

class ResNet50(object):
    def __init__(self, inputs, num_classes=1000, is_training=True,
                 scope="resnet50"):
        self.inputs =inputs
        self.is_training = is_training
        self.num_classes = num_classes

        with tf.variable_scope(scope):
            # construct the model
            net = conv2d(inputs, 64, 7, 2, scope="conv1") # -> [batch, 112, 112, 64]
            net = tf.nn.relu(batch_norm(net, is_training=self.is_training, scope="bn1"))
            net = max_pool(net, 3, 2, scope="maxpool1")  # -> [batch, 56, 56, 64]
            net = self._block(net, 256, 3, init_stride=1, is_training=self.is_training,
                              scope="block2")           # -> [batch, 56, 56, 256]
            net = self._block(net, 512, 4, is_training=self.is_training, scope="block3")
                                                        # -> [batch, 28, 28, 512]
            net = self._block(net, 1024, 6, is_training=self.is_training, scope="block4")
                                                        # -> [batch, 14, 14, 1024]
            net = self._block(net, 2048, 3, is_training=self.is_training, scope="block5")
                                                        # -> [batch, 7, 7, 2048]
            net = avg_pool(net, 7, scope="avgpool5")    # -> [batch, 1, 1, 2048]
            net = tf.squeeze(net, [1, 2], name="SpatialSqueeze") # -> [batch, 2048]
            self.logits = fc(net, self.num_classes, "fc6")       # -> [batch, num_classes]
            self.predictions = tf.nn.softmax(self.logits)


    def _block(self, x, n_out, n, init_stride=2, is_training=True, scope="block"):
        with tf.variable_scope(scope):
            h_out = n_out // 4
            out = self._bottleneck(x, h_out, n_out, stride=init_stride,
                                   is_training=is_training, scope="bottlencek1")
            for i in range(1, n):
                out = self._bottleneck(out, h_out, n_out, is_training=is_training,
                                       scope=("bottlencek%s" % (i + 1)))
            return out

    def _bottleneck(self, x, h_out, n_out, stride=None, is_training=True, scope="bottleneck"):
        """ A residual bottleneck unit"""
        n_in = x.get_shape()[-1]
        if stride is None:
            stride = 1 if n_in == n_out else 2

        with tf.variable_scope(scope):
            h = conv2d(x, h_out, 1, stride=stride, scope="conv_1")
            h = batch_norm(h, is_training=is_training, scope="bn_1")
            h = tf.nn.relu(h)
            h = conv2d(h, h_out, 3, stride=1, scope="conv_2")
            h = batch_norm(h, is_training=is_training, scope="bn_2")
            h = tf.nn.relu(h)
            h = conv2d(h, n_out, 1, stride=1, scope="conv_3")
            h = batch_norm(h, is_training=is_training, scope="bn_3")

            if n_in != n_out:
                shortcut = conv2d(x, n_out, 1, stride=stride, scope="conv_4")
                shortcut = batch_norm(shortcut, is_training=is_training, scope="bn_4")
            else:
                shortcut = x
            return tf.nn.relu(shortcut + h)

完整实现可以参见 GitHub
。

展开全文 >>

Numpy可视化图解

2020-05-23

本文用可视化的方式介绍了 NumPy 的功能和使用示例。

NumPy 软件包是 Python 生态系统中数据分析、机器学习和科学计算的主力军。它极大地简化了向量和矩阵的操作处理。Python 的一些主要软件包（如 scikit-learn、SciPy、pandas 和 tensorflow）都以 NumPy 作为其架构的基础部分。除了能对数值数据进行切片（slice）和切块（dice）之外，使用 NumPy 还能为处理和调试上述库中的高级实例带来极大便利。

本文将介绍使用 NumPy 的一些主要方法，以及在将数据送入机器学习模型之前，它如何表示不同类型的数据（表格、图像、文本等）。

import numpy as np

创建数组

我们可以通过传递一个 python 列表并使用 np.array（）来创建 NumPy 数组（极大可能是多维数组）。在本例中，python 创建的数组如下图右所示：

通常我们希望 NumPy 能初始化数组的值，为此 NumPy 提供了 ones()、zeros() 和 random.random()
等方法。我们只需传递希望 NumPy 生成的元素数量即可：

一旦创建了数组，我们就可以尽情对它们进行操作。

数组运算

让我们创建两个 NumPy 数组来展示数组运算功能。我们将下图两个数组称为 data 和 ones：

将它们按位置相加（即每行对应相加），直接输入 data + ones 即可：

当我开始学习这些工具时，我发现这样的抽象让我不必在循环中编写类似计算。此类抽象可以使我在更高层面上思考问题。除了「加」，我们还可以进行如下操作：

通常情况下，我们希望数组和单个数字之间也可以进行运算操作（即向量和标量之间的运算）。比如说，我们的数组表示以英里为单位的距离，我们希望将其单位转换为千米。只需输入data*1.6 即可：

看到 NumPy 是如何理解这个运算的了吗？这个概念叫做广播机制（broadcasting），它非常有用。

索引

我们可以我们像对 python 列表进行切片一样，对 NumPy 数组进行任意的索引和切片：

聚合

NumPy 还提供聚合功能：

除了 min、max 和 sum 之外，你还可以使用 mean 得到平均值，使用 prod 得到所有元素的乘积，使用 std 得到标准差等等。

更多维度

上述的例子都在一个维度上处理向量。NumPy 之美的关键在于，它能够将上述所有方法应用到任意数量的维度。

创建矩阵

我们可以传递下列形状的 python 列表，使 NumPy 创建一个矩阵来表示它：

np.array([[1,2],[3,4]])

我们也可以使用上面提到的方法（ones()、zeros() 和 random.random()），只要写入一个描述我们创建的矩阵维数的元组即可：

矩阵运算

如果两个矩阵大小相同，我们可以使用算术运算符（+-*/）对矩阵进行加和乘。NumPy 将它们视为 position-wise 运算：

我们也可以对不同大小的两个矩阵执行此类算术运算，但前提是某一个维度为 1（如矩阵只有一列或一行），在这种情况下，NumPy 使用广播规则执行算术运算：

点乘

算术运算和矩阵运算的一个关键区别是矩阵乘法使用点乘。NumPy 为每个矩阵赋予 dot() 方法，我们可以用它与其他矩阵执行点乘操作：

我在上图的右下角添加了矩阵维数，来强调这两个矩阵的临近边必须有相同的维数。你可以把上述运算视为：

矩阵索引

当我们处理矩阵时，索引和切片操作变得更加有用：

矩阵聚合

我们可以像聚合向量一样聚合矩阵：

我们不仅可以聚合矩阵中的所有值，还可以使用 axis 参数执行跨行或跨列聚合：

转置和重塑

处理矩阵时的一个常见需求是旋转矩阵。当需要对两个矩阵执行点乘运算并对齐它们共享的维度时，通常需要进行转置。NumPy 数组有一个方便的方法 T来求得矩阵转置：

在更高级的实例中，你可能需要变换特定矩阵的维度。在机器学习应用中，经常会这样：某个模型对输入形状的要求与你的数据集不同。在这些情况下，NumPy 的reshape() 方法就可以发挥作用了。只需将矩阵所需的新维度赋值给它即可。可以为维度赋值-1，NumPy 可以根据你的矩阵推断出正确的维度：

再多维度

NumPy 可以在任意维度实现上述提到的所有内容。其中心数据结构被叫作 ndarray（N 维数组）不是没道理的。

在很多情况下，处理一个新的维度只需在 NumPy 函数的参数中添加一个逗号：

实际用法

以下是 NumPy 可实现的有用功能的实例演示。

公式

实现可用于矩阵和向量的数学公式是 NumPy 的关键用例。这就是 NumPy 是 python 社区宠儿的原因。例如均方差公式，它是监督机器学习

在 NumPy 中实现该公式很容易：

这样做的好处在于，NumPy 并不关心 predictions 和 labels
包含一个值还是一千个值（只要它们大小相同）。我们可以通过一个示例依次执行上面代码行中的四个操作：

预测和标签向量都包含三个值，也就是说 n 的值为 3。减法后，得到的值如下：

然后将向量平方得到：

现在对这些值求和：

得到的结果即为该预测的误差值和模型质量评分。

数据表示

考虑所有需要处理和构建模型所需的数据类型（电子表格、图像、音频等），其中很多都适合在 n 维数组中表示：

表格和电子表格

电子表格或值表是二维矩阵。电子表格中的每个工作表都可以是它自己的变量。python 中最流行的抽象是 pandas 数据帧，它实际上使用了 NumPy并在其之上构建。

音频和时间序列

音频文件是样本的一维数组。每个样本都是一个数字，代表音频信号的一小部分。CD 质量的音频每秒包含 44,100 个样本，每个样本是-65535 到65536 之间的整数。这意味着如果你有一个 10 秒的 CD 质量 WAVE 文件，你可以将它加载到长度为 10 * 44,100 = 441,000 的NumPy 数组中。如果想要提取音频的第一秒，只需将文件加载到 audio 的 NumPy 数组中，然后获取 audio[:44100]。

以下是一段音频文件：

时间序列数据也是如此（如股票价格随时间变化）。

图像

图像是尺寸（高度 x 宽度）的像素矩阵。

如果图像是黑白（即灰度）的，则每个像素都可以用单个数字表示（通常在 0（黑色）和 255（白色）之间）。想要裁剪图像左上角 10 x 10 的像素吗？在NumPy写入即可。

下图是一个图像文件的片段：

如果图像是彩色的，则每个像素由三个数字表示——红色、绿色和蓝色。在这种情况下，我们需要一个三维数组（因为每个单元格只能包含一个数字）。因此彩色图像由尺寸为（高 x 宽 x3）的 ndarray 表示：

语言

如果我们处理文本，情况就不同了。文本的数字表示需要一个构建词汇表的步骤（模型知道的唯一字清单）和嵌入步骤。让我们看看用数字表示以下文字的步骤：

模型需要先查看大量文本，再用数字表示这位诗人的话语。我们可以让它处理一个小数据集，并用它来构建一个词汇表（71,290 个单词）：

这个句子可以被分成一个 token 数组（基于通用规则的单词或单词的一部分）：

然后我们用词汇表中的 ID 替换每个单词：

这些 ID 仍然没有为模型提供太多信息价值。因此，在将这一组单词输入到模型之前，我们需要用嵌入替换 token/单词（在本例中为 50 维 word2vec嵌入）：

可以看到，该 NumPy 数组的维度为 [embedding_dimension x sequence_length]。出于性能原因，深度学习模型倾向于保留批大小的第一维（因为如果并行训练多个示例，模型训练速度会加快）。在这种情况下，reshape()变得非常有用。如像 BERT 这样的模型期望的输入形式是：[batch_size，sequence_length，embedding_size]。

现在这是 numeric volume 形式，模型可以处理并执行相应操作。其他行虽然留空，但是它们会被填充其他示例以供模型训练（或预测）。

_原文链接：_ https:// jalammar.github.io/visu al-numpy/

展开全文 >>

代码整洁之道

2020-04-30

很多新手在开始学一门新的语言的时候，往往会忽视一些不应该忽视的细节，比如变量命名和函数命名以及注释等一些内容的规范性，久而久之养成了一种习惯。对此呢，我特意收集了一些适合所有学习
Python 的人，代码整洁之道。

写出 Pythonic 代码

谈到规范首先想到就是 Python 有名的 PEP8 代码规范文档，它定义了编写Pythonic代码的最佳实践。可以在 https://www.
python.org/dev/peps/pep -0008/
上查看。但是真正去仔细研究学习这些规范的朋友并不是很多，对此呢这篇文章摘选一些比较常用的代码整洁和规范的技巧和方法，下面让我们一起来学习吧！

命名

所有的编程语言都有变量、函数、类等的命名约定，以美之称的 Python 当然更建议使用命名约定。接下来就针对类、函数、方法等等内容进行学习。

变量和函数

使用小写字母命名函数和变量，并用下划线分隔单词，提高代码可读性。

变量的声明

names = "Python" #变量名 
namejob_title = "Software Engineer" #带有下划线的变量名
populated_countries_list = []  #带有下划线的变量名

还应该考虑在代码中使用非 Python 内置方法名，如果使用 Python 中内置方法名请使用一个或两个下划线()。

_books = {}# 变量名私有化
__dict = []# 防止python内置库中的名称混淆

那如何选择是用_还是__呢？

如果不希望外部类访问该变量，应该使用一个下划线（_）作为类的内部变量的前缀。如果要定义的私有变量名称是 Python 中的关键字如 dict
就要使用(__)。

函数的声明

def get_data(): 
    pass
def calculate_tax_data():
    pass

函数的声明和变量一样也是通过小写字母和单下划线进行连接。
当然对于函数私有化也是和声明变量类似。

def _get_data():
   pass

函数的开头使用单下划线，将其进行私有化。对于使用 Pyton 中的关键字来进行命名的函数
要使用双下划线。

def __path():
    pass

除了遵循这些命名规则之外，使用清晰易懂的变量名和很重要。

函数名规范

# Wrong Way
def get_user_info(id):
   db = get_db_connection()
   user = execute_query_for_user(id)
   return user

# Right way
def get_user_by(user_id):
    db = get_db_connection()
    user = execute_user_query(user_id) 
    return user

这里，第二个函数 get_user_by 确保使用相同的参数来传递变量，从而为函数提供正确的上下文。第一个函数 get_user_info
就不怎么不明确了，因为参数 id 意味着什么这里我们不能确定，它是用户 ID，还是用户付款ID或任何其他
ID？这种代码可能会对使用你的API的其他开发人员造成混淆。为了解决这个问题，我在第二个函数中更改了两个东西;
我更改了函数名称以及传递的参数名称，这使代码可读性更高。

作为开发人员，你有责任在命名变量和函数时仔细考虑，要写让人能够清晰易懂的代码。
当然也方便自己以后去维护。

类的命名规范

类的名称应该像大多数其他语言一样使用驼峰大小写。

class UserInformation:
     def get_user(id):
          db = get_db_connection()
          user = execute_query_for_user(id)
          return user

常量的命名规范

通常应该用大写字母定义常量名称。

TOTAL = 56
TIMOUT = 6
MAX_OVERFLOW = 7

函数和方法的参数

函数和方法的参数命名应遵循与变量和方法名称相同的规则。因为类方法将self作为第一个关键字参数。所以在函数中就不要使用 self
作为关键字作为参数，以免造成混淆 .

def calculate_tax(amount, yearly_tax):
    passs

class Player:
    def get_total_score(self, player_name):
         pass

关于命名大概就强调这些，下面让我们看看表达式和语句中需要的问题。

代码中的表达式和语句

users = [
    {"first_name":"Helen", "age":39},
    {"first_name":"Buck", "age":10},
    {"first_name":"anni", "age":9}
]
users = sorted(users, key=lambda user: user["first_name"].lower())

这段代码有什么问题?
乍一看并不容易理解这段代码，尤其是对于新开发人员来说，因为 lambdas 的语法很古怪，所以不容易理解。虽然这里使用 lambda
可以节省行，然而，这并不能保证代码的正确性和可读性。同时这段代码无法解决字典缺少键出现异常的问题。

让我们使用函数重写此代码，使代码更具可读性和正确性; 该函数将判断异常情况，编写起来要简单得多。

users = [
    {"first_name":"Helen", "age":39},
    {"first_name":"Buck", "age":10},
    {"name":"anni", "age":9}
]
def get_user_name(users):
    """Get name of the user in lower case"""
    return users["first_name"].lower()
def get_sorted_dictionary(users):
    """Sort the nested dictionary"""
    if not isinstance(users, dict):
        raise ValueError("Not a correct dictionary")
    if not len(users):
       raise ValueError("Empty dictionary")
    users_by_name = sorted(users, key=get_user_name)
    return users_by_name

如你所见，此代码检查了所有可能的意外值，并且比起以前的单行代码更具可读性。单行代码虽然看起来很酷节省了行，但是会给代码添加很多复杂性。但是这并不意味着单行代码就不好
这里提出的一点是，如果你的单行代码使代码变得更难阅读，那么就请避免使用它，记住写代码不是为了炫酷的，尤其在项目组中。

让我们再考虑一个例子，你试图读取 CSV 文件并计算 CSV 文件处理的行数。下面的代码展示使代码可读的重要性，以及命名如何在使代码可读中发挥重要作用。

import csv
with open("employee.csv", mode="r") as csv_file:
    csv_reader = csv.DictReader(csv_file)
    line_count = 0
    for row in csv_reader:
        if line_count == 0:
            print(f'Column names are {", ".join(row)}')
            line_count += 1
            print(f'\t{row["name"]} salary: {row["salary"]}'
            f'and was born in {row["birthday month"]}.')
        line_count += 1
    print(f'Processed {line_count} lines.')

将代码分解为函数有助于使复杂的代码变的易于阅读和调试。
这里的代码在 with 语句中执行多项操作。为了提高可读性，您可以将带有 process salary 的代码从 CSV
文件中提取到另一个函数中，以降低出错的可能性。

import csv
with open("employee.csv", mode="r") as csv_file:
    csv_reader = csv.DictReader(csv_file)
    line_count = 0
    process_salary(csv_reader)    


def process_salary(csv_reader):
"""Process salary of user from csv file."""
    for row in csv_reader:
            if line_count == 0:
                print(f'Column names are {", ".join(row)}')
                line_count += 1
                print(f'\t{row["name"]} salary: {row["salary"]}'
                f'and was born in {row["birthday month"]}.')
            line_count += 1
        print(f'Processed {line_count} lines.')

代码是不是变得容易理解了不少呢。
在这里，创建了一个帮助函数，而不是在with语句中编写所有内容。这使读者清楚地了解了函数的实际作用。如果想处理一个特定的异常或者想从CSV文件中读取更多的数据，可以进一步分解这个函数，以遵循单一职责原则，一个函数一做一件事。这个很重要。

return语句的类型尽量一致

如果希望函数返回一个值，请确保该函数的所有执行路径都返回该值。但是，如果期望函数只是在不返回值的情况下执行操作，则 Python 会隐式返回 None
作为函数的默认值。
先看一个错误示范

def calculate_interest(principle, time rate):    
     if principle > 0:
         return (principle * time * rate) / 100
def calculate_interest(principle, time rate):    
    if principle < 0:
        return    
    return (principle * time * rate) / 100ChaPTER 1  PyThonIC ThInkIng

正确的示范应该是下面这样

def calculate_interest(principle, time rate):    
     if principle > 0:
         return (principle * time * rate) / 100
     else:
        return None
def calculate_interest(principle, time rate):    
    if principle < 0:
        return None    
    return (principle * time * rate) / 100ChaPTER 1  PyThonIC ThInkIng

还是那句话写易读的代码，代码多写点没关系，可读性很重要。

使用 isinstance() 方法而不是 type() 进行比较

当比较两个对象类型时，请考虑使用 isinstance() 而不是 type，因为 isinstance() 判断一个对象是否为另一个对象的子类是
true。考虑这样一个场景：如果传递的数据结构是dict 的子类，比如 orderdict。type()
对于特定类型的数据结构将失败;然而，isinstance() 可以将其识别出它是 dict 的子类。

错误示范

user_ages = {"Larry": 35, "Jon": 89, "Imli": 12}
type(user_ages) == dict:

正确选择

user_ages = {"Larry": 35, "Jon": 89, "Imli": 12}
if isinstance(user_ages, dict):

比较布尔值

在Python中有多种方法可以比较布尔值。
错误示范

if is_empty = False
if is_empty == False:
if is_empty is False:

正确示范

is_empty = False
if is_empty

使用文档字符串

Docstrings可以在 Python 中声明代码的功能的。通常在方法，类和模块的开头使用。docstring是该对象的doc特殊属性。
Python 官方语言建议使用“”三重双引号“”来编写文档字符串。你可以在 PEP8 官方文档中找到这些实践。下面让我们简要介绍一下在 Python
代码中编写 docstrings 的一些最佳实践。

方法中使用docstring

def get_prime_number():
    """Get list of prime numbers between 1 to 100.""""

关于docstring的格式的写法，目前存在多种风格，但是这几种风格都有一些统一的标准。

即使字符串符合一行，也会使用三重引号。当你想要扩展时，这种注释非常有用。‘
三重引号中的字符串前后不应有任何空行
使用句点（.）结束docstring中的语句
类似地，可以应用 Python 多行 docstring 规则来编写多行
docstring。在多行上编写文档字符串是用更具描述性的方式记录代码的一种方法。你可以利用 Python 多行文档字符串在 Python
代码中编写描述性文档字符串，而不是在每一行上编写注释。

多行的docstring

def call_weather_api(url, location):
    """Get the weather of specific location.

    Calling weather api to check for weather by using weather api and 
    location. Make sure you provide city name only, country and county 
    names won't be accepted and will throw exception if not found the 
    city name.

    :param url:URL of the api to get weather.
    :type url: str
    :param location:Location of the city to get the weather.
    :type location: str
    :return: Give the weather information of given location.
    :rtype: str"""

说一下上面代码的注意点

第一行是函数或类的简要描述
每一行语句的末尾有一个句号
文档字符串中的简要描述和摘要之间有一行空白

如果使用 Python3.6 可以使用类型注解对上面的docstring以及参数的声明进行修改。

def call_weather_api(url: str, location: str) -> str:
    """Get the weather of specific location.

    Calling weather api to check for weather by using weather api and 
    location. Make sure you provide city name only, country and county 
    names won't be accepted and will throw exception if not found the 
    city name.
    """

怎么样是不是简洁了不少，如果使用 Python 代码中的类型注解，则不需要再编写参数信息。
关于类型注解(type hint)的具体用法可以参考我之前写的 python类型检测最终指南—Typing的使用

模块级别的docstring

一般在文件的顶部放置一个模块级的 docstring 来简要描述模块的使用。
这些注释应该放在在导包之前，模块文档字符串应该表明模块的使用方法和功能。
如果觉得在使用模块之前客户端需要明确地知道方法或类，你还可以简要地指定特定方法或类。

"""This module contains all of the network related requests. 
This module will check for all the exceptions while making the network 
calls and raise exceptions for any unknown exception.
Make sure that when you use this module,
you handle these exceptions in client code as:
NetworkError exception for network calls.
NetworkNotFound exception if network not found.
"""

import urllib3
import json

在为模块编写文档字符串时，应考虑执行以下操作：

对当前模块写一个简要的说明
如果想指定某些对读者有用的模块，如上面的代码，还可以添加异常信息，但是注意不要太详细。

NetworkError exception for network calls.
NetworkNotFound exception if network not found.

将模块的docstring看作是提供关于模块的描述性信息的一种方法，而不需要详细讨论每个函数或类具体操作方法。

类级别的docstring

类docstring主要用于简要描述类的使用及其总体目标。让我们看一些示例，看看如何编写类文档字符串

单行类docstring

class Student:
   """This class handle actions performed by a student."""
   def __init__(self):
      pass

这个类有一个一行的 docstring，它简要地讨论了学生类。如前所述，遵守了所以一行docstring 的编码规范。

多行类docstring

class Student:
    """Student class information.

    This class handle actions performed by a student.
    This class provides information about student full name, age, 
    roll-number and other information.
    Usage:
        import student
        student = student.Student()
        student.get_name()
        >>> 678998
   """
   def __init__(self):
       pass

这个类 docstring 是多行的; 我们写了很多关于 Student 类的用法以及如何使用它。

函数的docstring

函数文档字符串可以写在函数之后，也可以写在函数的顶部。

def is_prime_number(number):
    """Check for prime number.

    Check the given number is prime number 
    or not by checking against all the numbers 
    less the square root of given number.

    :param number:Given number to check for prime
    :type number: int
    :return: True if number is prime otherwise False.
    :rtype: boolean
    """

如果我们使用类型注解对其进一步优化。

def is_prime_number(number: int)->bool:
    """Check for prime number.

    Check the given number is prime number 
    or not by checking against all the numbers 
    less the square root of given number.
    """

结语

当然关于 Python 中的规范还有很多很多，建议大家参考 Python 之禅和 Pep8 对代码进行优化，养成编写 Pythonic 代码的良好习惯。

展开全文 >>

如何优雅的使用Git

2020-04-24

尽管 Git 是一款非常强大的工具，但如果我说 Git 用起来简直是噩梦，大多数人也会认同我的说法。我发现在使用 Git
时，在头脑里可视化地想象它会非常有用：当我执行一个特定命令时，这些分支会如何交互，又会怎样影响历史记录？为什么当我在 master 上执行硬重启，force
push 到原分支以及 rimraf 我们的 .git 文件夹时，我的同事哭了？

我觉得创建一些最常用且最有用的 Git
命令的可视化示例会是一个完美的用例！下面我将介绍的很多命令都有可选参数——你可以使用这些参数来改变对应命令的行为。而我的示例只会涵盖命令的默认行为，而不会添加（或添加太多）可选配置！

合并

拥有多个分支是很方便的，这样可以将不同的新修改互相隔离开，而且还能确保你不会意外地向生产代码推送未经许可或破损的代码修改。但一旦这些修改得到了批准许可，我们就需要将其部署到我们的生产分支中！

可将一个分支的修改融入到另一个分支的一种方式是执行 git merge。Git 可执行两种类型的合并：fast-forward 和 no-fast-
forward。现在你可能分不清，但我们马上就来看看它们的差异所在。

Fast-forward (—ff)

在当前分支相比于我们要合并的分支没有额外的提交（commit）时，可以执行 fast-forward 合并。Git
很懒，首先会尝试执行最简单的选项：fast-forward！这类合并不会创建新的提交，而是会将我们正在合并的分支上的提交直接合并到当前分支。

完美！现在，我们在 dev 分支上所做的所有改变都合并到了 master 分支上。那么 no-fast-forward 又是什么意思呢？

No-fast-foward (—no-ff)

如果你的当前分支相比于你想要合并的分支没有任何提交，那当然很好，但很遗憾现实情况很少如此！如果我们在当前分支上提交我们想要合并的分支不具备的改变，那么
git 将会执行 no-fast-forward 合并。

使用 no-fast-forward 合并时，Git 会在当前活动分支上创建新的 merging commit。这个提交的父提交（parent
commit）即指向这个活动分支，也指向我们想要合并的分支！

没什么大不了的，完美的合并！现在，我们在 dev 分支上所做的所有改变都合并到了 master 分支上。

合并冲突

尽管 Git
能够很好地决定如何合并分支以及如何向文件添加修改，但它并不总是能完全自己做决定。当我们想要合并的两个分支的同一文件中的同一行代码上有不同的修改，或者一个分支删除了一个文件而另一个分支修改了这个文件时，Git
就不知道如何取舍了。

在这样的情况下，Git 会询问你想要保留哪种选择？假设在这两个分支中，我们都编辑了 README.md 的第一行。

如果我们想把 dev 合并到 master，就会出现一个合并冲突：你想要标题是 Hello! 还是 Hey!？

当尝试合并这些分支时，Git 会向你展示冲突出现的位置。我们可以手动移除我们不想保留的修改，保存这些修改，再次添加这个已修改的文件，然后提交这些修改。

完成！尽管合并冲突往往很让人厌烦，但这是合理的：Git 不应该瞎猜我们想要保留哪些修改。

变基（Rebasing）

我们刚看到可通过执行 git merge 将一个分支的修改应用到另一个分支。另一种可将一个分支的修改融入到另一个分支的方式是执行 git rebase。

git rebase 会将当前分支的提交复制到指定的分支之上。

完美，现在我们在 dev 分支上获取了 master 分支上的所有修改。

变基与合并有一个重大的区别：Git 不会尝试确定要保留或不保留哪些文件。我们执行 rebase
的分支总是含有我们想要保留的最新近的修改！这样我们不会遇到任何合并冲突，而且可以保留一个漂亮的、线性的 Git 历史记录。

上面这个例子展示了在 master 分支上的变基。但是，在更大型的项目中，你通常不需要这样的操作。git rebase 在为复制的提交创建新的 hash
时会修改项目的历史记录。

如果你在开发一个 feature 分支并且 master 分支已经更新过，那么变基就很好用。你可以在你的分支上获取所有更新，这能防止未来出现合并冲突。

交互式变基（Interactive Rebase）

在为提交执行变基之前，我们可以修改它们！我们可以使用交互式变基来完成这一任务。交互式变基在你当前开发的分支上以及想要修改某些提交时会很有用。

在我们正在 rebase 的提交上，我们可以执行以下 6 个动作：

reword：修改提交信息；
edit：修改此提交；
squash：将提交融合到前一个提交中；
fixup：将提交融合到前一个提交中，不保留该提交的日志消息；
exec：在每个提交上运行我们想要 rebase 的命令；
drop：移除该提交。

很棒！这样我们就能完全控制我们的提交了。如果你想要移除一个提交，只需 drop 即可。

如果你想把多个提交融合到一起以便得到清晰的提交历史，那也没有问题！

交互式变基能为你在 rebase 时提供大量控制，甚至可以控制当前的活动分支。

重置（Resetting）

当我们不想要之前提交的修改时，就会用到这个命令。也许这是一个 WIP 提交或者可能是引入了 bug 的提交，这时候就要执行 git reset。

git reset 能让我们不再使用当前台面上的文件，让我们可以控制 HEAD 应该指向的位置。

软重置

软重置会将 HEAD 移至指定的提交（或与 HEAD 相比的提交的索引），而不会移除该提交之后加入的修改！

假设我们不想保留添加了一个 style.css 文件的提交 9e78i，而且我们也不想保留添加了一个 index.js 文件的提交
035cc。但是，我们确实又想要保留新添加的 style.css 和 index.js 文件！这是软重置的一个完美用例。

输入 git status 后，你会看到我们仍然可以访问在之前的提交上做过的所有修改。这很好，这意味着我们可以修复这些文件的内容，之后再重新提交它们！

硬重置

有时候我们并不想保留特定提交引入的修改。不同于软重置，我们应该再也无需访问它们。Git
应该直接将整体状态直接重置到特定提交之前的状态：这甚至包括你在工作目录中和暂存文件上的修改。

Git 丢弃了 9e78i 和 035cc 引入的修改，并将状态重置到了 ec5be 的状态。

还原（Reverting）

另一种撤销修改的方法是执行 git revert。通过对特定的提交执行还原操作，我们会创建一个包含已还原修改的新提交。

假设 ec5be 添加了一个 index.js 文件。但之后我们发现其实我们再也不需要由这个提交引入的修改了。那就还原 ec5be 提交吧！

完美！提交 9e78i 还原了由提交 ec5be 引入的修改。在撤销特定的提交时，git revert 非常有用，同时也不会修改分支的历史。

拣选（Cherry-picking）

当一个特定分支包含我们的活动分支需要的某个提交时，我们对那个提交执行 cherry-pick！对一个提交执行 cherry-pick
时，我们会在活动分支上创建一个新的提交，其中包含由拣选出来的提交所引入的修改。

假设 dev 分支上的提交 76d12 为 index.js 文件添加了一项修改，而我们希望将其整合到 master 分支中。我们并不想要整个 dev
分支，而只需要这个提交！

现在 master 分支包含 76d12 引入的修改了。

取回（Fetching）

如果你有一个远程 Git 分支，比如在 GitHub
上的分支，当远程分支上包含当前分支没有的提交时，可以使用取回。比如当合并了另一个分支或你的同事推送了一个快速修复时。

通过在这个远程分支上执行 git fetch，我们就可在本地获取这些修改。这不会以任何方式影响你的本地分支：fetch 只是单纯地下载新的数据而已。

现在我们可以看到自上次推送以来的所有修改了。这些新数据也已经在本地了，我们可以决定用这些新数据做什么了。

拉取（Pulling）

尽管 git fetch 可用于获取某个分支的远程信息，但我们也可以执行 git pull。git pull 实际上是两个命令合成了一个：git fetch
和 git merge。当我们从来源拉取修改时，我们首先是像 git fetch 那样取回所有数据，然后最新的修改会自动合并到本地分支中。

很好，我们现在与远程分支完美同步了，并且也有了所有最新的修改！

Reflog

每个人都会犯错，但犯错其实没啥！有时候你可能感觉你把 git repo 完全搞坏了，让你想完全删了了事。

git reflog 是一个非常有用的命令，可以展示已经执行过的所有动作的日志。包括合并、重置、还原，基本上包含你对你的分支所做的任何修改。

如果你犯了错，你可以根据 reflog 提供的信息通过重置 HEAD 来轻松地重做！

假设我们实际上并不需要合并原有分支。当我们执行 git reflog 命令时，我们可以看到这个 repo 的状态在合并前位于
HEAD@{1}。那我们就执行一次 git reset，将 HEAD 重新指向在 HEAD@{1} 的位置。

我们可以看到最新的动作已被推送给 reflog。

git常用指令

展开全文 >>

计算机视觉科普

2020-03-25

如果你刚刚接触cv领域，下面的视频会给你巨大的收获，短短十分钟介绍了传统图像处理算法及深度学习原理。

图形组成原理
竖直边缘与水平边缘检测
滤波器的概念
卷积原理
Prewitt算子
人脸检测原理
卷积神经网络概念
微表情判断
人体关节点识别与跟踪

展开全文 >>

Faster RCNN 算法解读

2020-03-24

经过R-CNN和Fast RCNN的积淀，Ross B. Girshick在2016年提出了新的Faster RCNN，在结构上，Faster
RCNN已经将特征抽取(feature extraction)，proposal提取，bounding box regression(rect
refine)，classification都整合在了一个网络中，使得综合性能有较大提高，在检测速度方面尤为明显。

目录
1 Conv layers
2 Region Proposal Networks(RPN)
- 2.1 多通道图像卷积基础知识介绍
- 2.2 anchors
- 2.3 softmax判定positive与negative
- 2.4 bounding box regression原理
- 2.5 对proposals进行bounding box regression
- 2.6 Proposal Layer
3 RoI pooling
- 3.1 为何需要RoI Pooling
- 3.2 RoI Pooling原理
4 Classification
5 Faster RCNN训练
- 5.1 训练RPN网络
- 5.2 通过训练好的RPN网络收集proposals
- 5.3 训练Faster RCNN网络
Questions and Answer

图1 Faster
RCNN基本结构（来自原论文）

依作者看来，如图1，Faster RCNN其实可以分为4个主要内容：

Conv layers。作为一种CNN网络目标检测方法，Faster RCNN首先使用一组基础的conv+relu+pooling层提取image的feature maps。该feature maps被共享用于后续RPN层和全连接层。
Region Proposal Networks。RPN网络用于生成region proposals。该层通过softmax判断anchors属于positive或者negative，再利用bounding box regression修正anchors获得精确的proposals。
Roi Pooling。该层收集输入的feature maps和proposals，综合这些信息后提取proposal feature maps，送入后续全连接层判定目标类别。
Classification。利用proposal feature maps计算proposal的类别，同时再次bounding box regression获得检测框最终的精确位置。

所以本文以上述4个内容作为切入点介绍Faster R-CNN网络。

图2展示了python版本中的VGG16模型中的faster_rcnn_test.pt的网络结构，可以清晰的看到该网络对于一副任意大小PxQ的图像，首先缩放至固定大小MxN，然后将MxN图像送入网络；而Conv
layers中包含了13个conv层+13个relu层+4个pooling层；RPN网络首先经过3x3卷积，再分别生成positive
anchors和对应bounding box regression偏移量，然后计算出proposals；而Roi
Pooling层则利用proposals从feature maps中提取proposal
feature送入后续全连接和softmax网络作classification（即分类proposal到底是什么object）。

图2
faster_rcnn_test.pt网络结构
（pascal_voc/VGG16/faster_rcnn_alt_opt/faster_rcnn_test.pt）

_本文不会讨论任何关于R-CNN家族的历史，分析清楚最新的Faster R-CNN就够了，并不需要追溯到那么久。实话说我也不了解R-
CNN，更不关心。有空不如看看新算法。_

1 Conv layers

Conv
layers包含了conv，pooling，relu三种层。以python版本中的VGG16模型中的faster_rcnn_test.pt的网络结构为例，如图2，Conv
layers部分共有13个conv层，13个relu层，4个pooling层。这里有一个非常容易被忽略但是又无比重要的信息，在Conv layers中：

所有的conv层都是：kernel_size=3，pad=1，stride=1
所有的pooling层都是：kernel_size=2，pad=1，stride=1 $\displaystyle \text{kernel_size}=2$ ， $\displaystyle \text{pad}=0$ ， $\displaystyle \text{stride}=2$

为何重要？在Faster RCNN Conv layers中对所有的卷积都做了扩边处理（ pad=1，即填充一圈0），导致原图变为
(M+2)x(N+2)大小，再做3x3卷积后输出MxN 。正是这种设置，导致Conv layers中的conv层不改变输入和输出矩阵大小。如图3：

图3 卷积示意图

类似的是，Conv
layers中的pooling层kernel_size=2，stride=2。这样每个经过pooling层的MxN矩阵，都会变为(M/2)x(N/2)大小。综上所述，在整个Conv
layers中，conv和relu层不改变输入输出大小，只有pooling层使输出长宽都变为输入的1/2。

那么，一个MxN大小的矩阵经过Conv layers固定变为(M/16)x(N/16)！这样Conv layers生成的feature
map中都可以和原图对应起来。

2 Region Proposal Networks(RPN)

经典的检测方法生成检测框都非常耗时，如OpenCV adaboost使用滑动窗口+图像金字塔生成检测框；或如R-CNN使用SS(Selective
Search)方法生成检测框。而Faster RCNN则抛弃了传统的滑动窗口和SS方法，直接使用RPN生成检测框，这也是Faster
R-CNN的巨大优势，能极大提升检测框的生成速度。

图4 RPN网络结构

上图4展示了RPN网络的具体结构。可以看到RPN网络实际分为2条线，上面一条通过softmax分类anchors获得positive和negative分类，下面一条用于计算对于anchors的bounding
box regression偏移量，以获得精确的proposal。而最后的Proposal层则负责综合positive anchors和对应bounding
box regression偏移量获取proposals，同时剔除太小和超出边界的proposals。其实整个网络到了Proposal
Layer这里，就完成了相当于目标定位的功能。

2.1 多通道图像卷积基础知识介绍

在介绍RPN前，还要多解释几句基础知识，已经懂的看官老爷跳过就好。

对于单通道图像+单卷积核做卷积，第一章中的图3已经展示了；
对于多通道图像+多卷积核做卷积，计算方式如下：

图5 多通道卷积计算方式

如图5，输入有3个通道，同时有2个卷积核。对于每个卷积核，先在输入3个通道分别作卷积，再将3个通道结果加起来得到卷积输出。所以对于某个卷积层，无论输入图像有多少个通道，输出图像通道数总是等于卷积核数量！

对多通道图像做1x1卷积，其实就是将输入图像于每个通道乘以卷积系数后加在一起，即相当于把原图像中本来各个独立的通道“联通”在了一起。

2.2 anchors

提到RPN网络，就不能不说anchors。所谓anchors，实际上就是一组由rpn/generate_anchors.py生成的矩形。直接运行作者demo中的generate_anchors.py可以得到以下输出：

[[ -84.  -40.   99.   55.]
 [-176.  -88.  191.  103.]
 [-360. -184.  375.  199.]
 [ -56.  -56.   71.   71.]
 [-120. -120.  135.  135.]
 [-248. -248.  263.  263.]
 [ -36.  -80.   51.   95.]
 [ -80. -168.   95.  183.]
 [-168. -344.  183.  359.]]

其中每行的4个值 $\displaystyle (x_1, y_1, x_2, y_2)$
表矩形左上和右下角点坐标。9个矩形共有3种形状，长宽比为大约为 $\displaystyle \text{width:height}\in\\{1:1, 1:2, 2:1\\}$ 三种，如图6。实际上通过anchors就引入了检测中常用到的多尺度方法。

图6 anchors示意图

注：关于上面的anchors size，其实是根据检测图像设置的。在python
demo中，会把任意大小的输入图像reshape成800x600（即图2中的M=800，N=600）。再回头来看anchors的大小，anchors中长宽1:2中最大为352x704，长宽2:1中最大736x384，基本是cover了800x600的各个尺度和形状。

那么这9个anchors是做什么的呢？借用Faster RCNN论文中的原图，如图7，遍历Conv layers计算获得的feature
maps，为每一个点都配备这9种anchors作为初始的检测框。这样做获得检测框很不准确，不用担心，后面还有2次bounding box
regression可以修正检测框位置。

图7

解释一下上面这张图的数字。

在原文中使用的是ZF model中，其Conv Layers中最后的conv5层num_output=256，对应生成256张特征图，所以相当于feature map每个点都是256-dimensions
在conv5之后，做了rpn_conv/3x3卷积且num_output=256，相当于每个点又融合了周围3x3的空间信息（猜测这样做也许更鲁棒？反正我没测试），同时256-d不变（如图4和图7中的红框）
假设在conv5 feature map中每个点上有k个anchor（默认k=9），而每个anhcor要分positive和negative，所以每个点由256d feature转化为cls=2k scores；而每个anchor都有(x, y, w, h)对应4个偏移量，所以reg=4k coordinates
补充一点，全部anchors拿去训练太多了，训练程序会在合适的anchors中随机选取128个postive anchors+128个negative anchors进行训练（什么是合适的anchors下文5.1有解释）

注意，在本文讲解中使用的VGG conv5 num_output=512，所以是512d，其他类似。

其实RPN最终就是在原图尺度上，设置了密密麻麻的候选Anchor。然后用cnn去判断哪些Anchor是里面有目标的positive
anchor，哪些是没目标的negative anchor。所以，仅仅是个二分类而已！

那么Anchor一共有多少个？原图800x600，VGG下采样16倍，feature map每个点设置9个Anchor，所以：

$\displaystyle \text{ceil}(800/16) \times \text{ceil}(600/16) \times 9=50\times38 \times9=17100$

其中ceil()表示向上取整，是因为VGG输出的feature map size= 50*38。

图8 Gernerate
Anchors

2.3 softmax判定positive与negative

一副MxN大小的矩阵送入Faster RCNN网络后，到RPN网络变为(M/16)x(N/16)，不妨设
W=M/16，H=N/16。在进入reshape与softmax之前，先做了1x1卷积，如图9：

图9
RPN中判定positive/negative网络结构

该1x1卷积的caffe prototxt定义如下：

layer {
  name: "rpn_cls_score"
  type: "Convolution"
  bottom: "rpn/output"
  top: "rpn_cls_score"
  convolution_param {
    num_output: 18   # 2(positive/negative) * 9(anchors)
    kernel_size: 1 pad: 0 stride: 1
  }
}

可以看到其num_output=18，也就是经过该卷积的输出图像为WxHx18大小（注意第二章开头提到的卷积计算方式）。这也就刚好对应了feature
maps每一个点都有9个anchors，同时每个anchors又有可能是positive和negative，所有这些信息都保存WxHx(9*2)大小的矩阵。为何这样做？后面接softmax分类获得positive
anchors，也就相当于初步提取了检测目标候选区域box（一般认为目标在positive anchors中）。

那么为何要在softmax前后都接一个reshape
layer？其实只是为了便于softmax分类，至于具体原因这就要从caffe的实现形式说起了。在caffe基本数据结构blob中以如下形式保存数据：

blob=[batch_size, channel，height，width]

对应至上面的保存positive/negative anchors的矩阵，其在caffe blob中的存储形式为[1, 2x9, H,
W]。而在softmax分类时需要进行positive/negative二分类，所以reshape layer会将其变为[1, 2, 9xH,
W]大小，即单独“腾空”出来一个维度以便softmax分类，之后再reshape回复原状。贴一段caffe
softmax_loss_layer.cpp的reshape函数的解释，非常精辟：

"Number of labels must match number of predictions; "
"e.g., if softmax axis == 1 and prediction shape is (N, C, H, W), "
"label count (number of labels) must be N*H*W, "
"with integer values in {0, 1, ..., C-1}.";

综上所述，RPN网络中利用anchors和softmax初步提取出positive
anchors作为候选区域（另外也有实现用sigmoid代替softmax，原理类似）。

2.4 bounding box regression原理

如图9所示绿色框为飞机的Ground Truth(GT)，红色为提取的positive
anchors，即便红色的框被分类器识别为飞机，但是由于红色的框定位不准，这张图相当于没有正确的检测出飞机。所以我们希望采用一种方法对红色的框进行微调，使得positive
anchors和GT更加接近。

图10

对于窗口一般使用四维向量 $\displaystyle (x, y, w, h)$ 表示，分别表示窗口的中心点坐标和宽高。对于图
11，红色的框A代表原始的positive Anchors，绿色的框G代表目标的GT，我们的目标是寻找一种关系，使得输入原始的anchor
A经过映射得到一个跟真实窗口G更接近的回归窗口G’，即：

给定anchor $\displaystyle A=(A_{x}, A_{y}, A_{w}, A_{h})$ 和 $\displaystyle GT=[G_{x}, G_{y}, G_{w}, G_{h}]$
寻找一种变换 F，使得： $\displaystyle F(A_{x}, A_{y}, A_{w}, A_{h})=(G_{x}^{'}, G_{y}^{'}, G_{w}^{'}, G_{h}^{'})$ ，其中 $\displaystyle (G_{x}^{'}, G_{y}^{'}, G_{w}^{'}, G_{h}^{'})≈(G_{x}, G_{y}, G_{w}, G_{h})$

图11

那么经过何种变换 F 才能从图10中的anchor A变为G’呢？比较简单的思路就是:

先做平移

$\displaystyle G_x'=A_w\cdot d_x(A) +A_x\\\$ $\displaystyle G_y'=A_h\cdot d_y(A) +A_y\\\$

再做缩放

$\displaystyle G_w'=A_w\cdot \exp(d_w(A))\\\$ $\displaystyle G_h'=A_h\cdot \exp(d_h(A))\\\$

观察上面4个公式发现，需要学习的是 $\displaystyle d_{x}(A),d_{y}(A),d_{w}(A),d_{h}(A)$
这四个变换。当输入的anchor A与GT相差较小时，可以认为这种变换是一种线性变换，那么就可以用线性回归来建模对窗口进行微调（注意，只有当anchors
A和GT比较接近时，才能使用线性回归模型，否则就是复杂的非线性问题了）。

接下来的问题就是如何通过线性回归获得 $\displaystyle d_{x}(A),d_{y}(A),d_{w}(A),d_{h}(A)$
了。线性回归就是给定输入的特征向量X, 学习一组参数W, 使得经过线性回归后的值跟真实值Y非常接近，即 $\displaystyle Y=WX$
。对于该问题，输入X是cnn feature map，定义为Φ；同时还有训练传入A与GT之间的变换量，即 $\displaystyle (t_{x}, t_{y}, t_{w}, t_{h})$ 。输出是 $\displaystyle d_{x}(A),d_{y}(A),d_{w}(A),d_{h}(A)$ 四个变换。那么目标函数可以表示为：

$\displaystyle d_*(A)=W_*^T\cdot \phi(A)\\\$

其中 $\displaystyle \phi(A)$ 是对应anchor的feature map组成的特征向量， $\displaystyle W_*$ 是需要学习的参数， $\displaystyle d_*(A)\\\$
是得到的预测值（表示x，y，w，h，也就是每一个变换对应一个上述目标函数）。为了让预测值 $$\displaystyle d_(A) $与真实值$ \displaystyle t_*$$ 差距最小，设计L1损失函数：

$\displaystyle \text{Loss}=\sum_{i}^{N}{|t_*^i-W_*^T\cdot \phi(A^i)|} \\\$

函数优化目标为：

$\displaystyle \hat{W}_*=\text{argmin}_{W_*}\sum_{i}^{n}|t_*^i- W_*^T\cdot \phi(A^i)|+\lambda||W_*|| \\\$

为了方便描述，这里以L1损失为例介绍，而真实情况中一般使用soomth-L1损失。

需要说明，只有在GT与需要回归框位置比较接近时，才可近似认为上述线性变换成立。
说完原理，对应于Faster RCNN原文，positive anchor与ground truth之间的平移量 $\displaystyle (t_x, t_y)$ 与尺度因子 $\displaystyle (t_w, t_h)$ 如下：

$\displaystyle t_x=(x-x_a)/w_a\ \ \ \ t_y=(y-y_a)/h_a\\\$ $\displaystyle t_w=\log(w/w_a)\ \ \ \ t_h=\log(h/h_a)\\\$

对于训练bouding box regression网络回归分支，输入是cnn feature Φ，监督信号是Anchor与GT的差距 $\displaystyle (t_x, t_y, t_w, t_h)$ ，即训练目标是：输入Φ的情况下使网络输出与监督信号尽可能接近。那么当bouding boxregression工作时，再输入Φ时，回归网络分支的输出就是每个Anchor的平移量和变换尺度 $\displaystyle (t_x, t_y,t_w, t_h)$ ，显然即可用来修正Anchor位置了。

2.5 对proposals进行bounding box regression

在了解bounding box regression后，再回头来看RPN网络第二条线路，如图12。

图12 RPN中的bbox reg

先来看一看上图11中1x1卷积的caffe prototxt定义：

layer {
  name: "rpn_bbox_pred"
  type: "Convolution"
  bottom: "rpn/output"
  top: "rpn_bbox_pred"
  convolution_param {
    num_output: 36   # 4 * 9(anchors)
    kernel_size: 1 pad: 0 stride: 1
  }
}

可以看到其 num_output=36，即经过该卷积输出图像为WxHx36，在caffe blob存储为[1, 4x9, H,
W]，这里相当于feature maps每个点都有9个anchors，每个anchors又都有4个用于回归的

$\displaystyle [d_{x}(A),d_{y}(A),d_{w}(A),d_{h}(A)]\\\$

变换量。

回到图8，VGG输出 $\displaystyle 50*38*512$ 的特征，对应设置 $\displaystyle 50*38*k$
个anchors，而RPN输出：

大小为 $\displaystyle 50*38*2k$ 的positive/negative softmax分类特征矩阵
大小为 $\displaystyle 50*38*4k$ 的regression坐标回归特征矩阵

恰好满足RPN完成positive/negative分类+bounding box regression坐标回归.

2.6 Proposal Layer

Proposal Layer负责综合所有 $\displaystyle [d_{x}(A),d_{y}(A),d_{w}(A),d_{h}(A)]$
变换量和positive anchors，计算出精准的proposal，送入后续RoI Pooling Layer。还是先来看看Proposal
Layer的caffe prototxt定义：

layer {
  name: 'proposal'
  type: 'Python'
  bottom: 'rpn_cls_prob_reshape'
  bottom: 'rpn_bbox_pred'
  bottom: 'im_info'
  top: 'rois'
  python_param {
    module: 'rpn.proposal_layer'
    layer: 'ProposalLayer'
    param_str: "'feat_stride': 16"
  }
}

Proposal Layer有3个输入：positive vs negative
anchors分类器结果rpn_cls_prob_reshape，对应的bbox reg的 $\displaystyle [d_{x}(A),d_{y}(A),d_{w}(A),d_{h}(A)]$
变换量rpn_bbox_pred，以及im_info；另外还有参数feat_stride=16，这和图4是对应的。
首先解释im_info。对于一副任意大小PxQ图像，传入Faster RCNN前首先reshape到固定MxN，im_info=[M, N,
scale_factor]则保存了此次缩放的所有信息。然后经过Conv
Layers，经过4次pooling变为WxH=(M/16)x(N/16)大小，其中feature_stride=16则保存了该信息，用于计算anchor偏移量。

图13

Proposal Layer forward（caffe layer的前传函数）按照以下顺序依次处理：

生成anchors，利用 $\displaystyle [d_{x}(A),d_{y}(A),d_{w}(A),d_{h}(A)]$ 对所有的anchors做bbox regression回归（这里的anchors生成和训练时完全一致）
按照输入的positive softmax scores由大到小排序anchors，提取前pre_nms_topN(e.g. 6000)个anchors，即提取修正位置后的positive anchors
限定超出图像边界的positive anchors为图像边界，防止后续roi pooling时proposal超出图像边界（见文章底部QA部分图21）
剔除尺寸非常小的positive anchors
对剩余的positive anchors进行NMS（nonmaximum suppression）
Proposal Layer有3个输入：positive和negative anchors分类器结果rpn_cls_prob_reshape，对应的bbox reg的(e.g. 300)结果作为proposal输出

之后输出proposal=[x1, y1, x2,
y2]，注意，由于在第三步中将anchors映射回原图判断是否超出边界，所以这里输出的proposal是对应MxN输入图像尺度的，这点在后续网络中有用。另外我认为，严格意义上的检测应该到此就结束了，后续部分应该属于识别了。

RPN网络结构就介绍到这里，总结起来就是：
生成anchors - > softmax分类器提取positvie anchors -> bbox reg回归positive anchors ->
Proposal Layer生成proposals

3 RoI pooling

而RoI Pooling层则负责收集proposal，并计算出proposal feature maps，送入后续网络。从图2中可以看到Rol
pooling层有2个输入：

原始的feature maps
RPN输出的proposal boxes（大小各不相同）

3.1 为何需要RoI Pooling

先来看一个问题：对于传统的CNN（如AlexNet和VGG），当网络训练好后输入的图像尺寸必须是固定值，同时网络输出也是固定大小的vector or
matrix。如果输入图像大小不定，这个问题就变得比较麻烦。有2种解决办法：

从图像中crop一部分传入网络
将图像warp成需要的大小后传入网络

图14 crop与warp破坏图像原有结构信息

两种办法的示意图如图14，可以看到无论采取那种办法都不好，要么crop后破坏了图像的完整结构，要么warp破坏了图像原始形状信息。

回忆RPN网络生成的proposals的方法：对positive anchors进行bounding box
regression，那么这样获得的proposals也是大小形状各不相同，即也存在上述问题。所以Faster R-CNN中提出了RoI
Pooling解决这个问题。不过RoI Pooling确实是从 Spatial Pyramid Pooling
发展而来，但是限于篇幅这里略去不讲，有兴趣的读者可以自行查阅相关论文。

3.2 RoI Pooling原理

分析之前先来看看RoI Pooling Layer的caffe prototxt的定义：

layer {
  name: "roi_pool5"
  type: "ROIPooling"
  bottom: "conv5_3"
  bottom: "rois"
  top: "pool5"
  roi_pooling_param {
    pooled_w: 7
    pooled_h: 7
    spatial_scale: 0.0625 # 1/16
  }
}

其中有新参数pooled_w和pooled_h，另外一个参数spatial_scale认真阅读的读者肯定已经知道知道用途。RoI Pooling layer
forward过程：

由于proposal是对应MXN尺度的，所以首先使用spatial_scale参数将其映射回(M/16)X(N/16)大小的feature map尺度；
再将每个proposal对应的feature map区域水平分为 $\displaystyle \text{pooled_w}\times \text{pooled_h}$ 的网格；
对网格的每一份都进行max pooling处理。

这样处理后，即使大小不同的proposal输出结果都是 $\displaystyle \text{pooled_w}\times \text{pooled_h}$ 固定大小，实现了固定长度输出。

图15 proposal示意图

4 Classification

Classification部分利用已经获得的proposal feature maps，通过full
connect层与softmax计算每个proposal具体属于那个类别（如人，车，电视等），输出cls_prob概率向量；同时再次利用bounding
box
regression获得每个proposal的位置偏移量bbox_pred，用于回归更加精确的目标检测框。Classification部分网络结构如图16。

图16 Classification部分网络结构图

从RoI Pooling获取到7x7=49大小的proposal feature maps后，送入后续网络，可以看到做了如下2件事：

通过全连接和softmax对proposals进行分类，这实际上已经是识别的范畴了
再次对proposals进行bounding box regression，获取更高精度的rect box

这里来看看全连接层InnerProduct layers，简单的示意图如图17，

图17 全连接层示意图

其计算公式如下：

其中W和bias B都是预先训练好的，即大小是固定的，当然输入X和输出Y也就是固定大小。所以，这也就印证了之前Roi
Pooling的必要性。到这里，我想其他内容已经很容易理解，不在赘述了。

5 Faster RCNN训练

Faster R-CNN的训练，是在已经训练好的model（如VGG_CNN_M_1024，VGG，ZF）的基础上继续进行训练。实际中训练过程分为6个步骤：

在已经训练好的model上，训练RPN网络，对应stage1_rpn_train.pt
利用步骤1中训练好的RPN网络，收集proposals，对应rpn_test.pt
第一次训练Fast RCNN网络，对应stage1_fast_rcnn_train.pt
第二训练RPN网络，对应stage2_rpn_train.pt
再次利用步骤4中训练好的RPN网络，收集proposals，对应rpn_test.pt
第二次训练Fast RCNN网络，对应stage2_fast_rcnn_train.pt

可以看到训练过程类似于一种“迭代”的过程，不过只循环了2次。至于只循环了2次的原因是应为作者提到：”A similar alternating
training can be run for more iterations, but we have observed negligible
improvements”，即循环更多次没有提升了。接下来本章以上述6个步骤讲解训练过程。

下面是一张训练过程流程图，应该更加清晰（图来源）。

图18 Faster RCNN训练步骤

5.1 训练RPN网络

在该步骤中，首先读取RBG提供的预训练好的model（本文使用VGG），开始迭代训练。来看看stage1_rpn_train.pt网络结构，如图19。

图19
stage1_rpn_train.pt（考虑图片大小，Conv Layers中所有的层都画在一起了，如红圈所示，后续图都如此处理）

与检测网络类似的是，依然使用Conv Layers提取feature maps。整个网络使用的Loss如下：

$\displaystyle \text{L}(\{p_i\},\{t_i\})=\frac{1}{N_{\text{cls}}}\sum_{i}\text{L}_\text{cls}(p_i,p_i^*)+\lambda\frac{1}{N_{\text{reg}}}\sum_{i}p_i^*\text{L}_\text{reg}(t_i,t_i^*)\\\$

上述公式中 $\displaystyle i$ 表示anchors index， $\displaystyle p_{i}$
表示positive softmax probability， $\displaystyle p_{i}^{*}$ 代表对应的GT
predict概率（即当第i个anchor与GT间IoU>0.7，认为是该anchor是positive， $\displaystyle p_{i}^{*}=1$ ；反之IoU<0.3时，认为是该anchor是negative， $\displaystyle p_{i}^{*}=0$
；至于那些0.3<IoU<0.7的anchor则不参与训练）； $\displaystyle t$ 代表predict bounding box，

$\displaystyle t^{*}$$ 代表对应positive anchor对应的GT box。可以看到，整个Loss分为2部分： 1. cls loss，即rpn_cls_loss层计算的softmax loss，用于分类anchors为positive与negative的网络训练 2. reg loss，即rpn_loss_bbox层计算的soomth L1 loss，用于bounding box regression网络训练。注意在该loss中乘了 $$\displaystyle p_{i}^{*}$$ ，相当于只关心positive anchors的回归（其实在回归中也完全没必要去关心negative）。由于在实际过程中， $$\displaystyle N_\text{cls}$$ 和 $$\displaystyle N_\text{reg}$

差距过大，用参数λ平衡二者（如 $\displaystyle N_\text{cls}=256$ ， $\displaystyle N_\text{reg}=2400$ 时设置 $\displaystyle λ=\frac{N_\text{reg}}{N_\text{cls}}\approx10$
），使总的网络Loss计算过程中能够均匀考虑2种Loss。这里比较重要是 $\displaystyle \text{L}_\text{reg}$
使用的soomth L1 loss，计算公式如下：

$\displaystyle \text{L}_\text{reg}(t_i,t_i^*)=\sum_{i\in\\{x,y,w,h\\}}^{}\text{smooth}_{\text{L1}}(t_i- t_i^*)\\\$ $\displaystyle \text{soomth}_\text{L1}(x) = \begin{cases} 0.5x^2 & \text{if |x|<1 } \\\ |x|-0.5 & \text{otherwise} \end{cases}\\\$

了解数学原理后，反过来看图18：

在RPN训练阶段，rpn-data（python AnchorTargetLayer）层会按照和test阶段Proposal层完全一样的方式生成Anchors用于训练
对于rpn_loss_cls，输入的rpn_cls_scors_reshape和rpn_labels分别对应 $\displaystyle p$ 与 $\displaystyle p^{*}$ ， $\displaystyle N_\text{cls}$ 参数隐含在 $\displaystyle p$ 与 $\displaystyle p^{*}$ 的caffe blob的大小中
对于rpn_loss_bbox，输入的rpn_bbox_pred和rpn_bbox_targets分别对应 $\displaystyle t$ 与 $\displaystyle t^{*}$ ，rpn_bbox_inside_weigths对应 $\displaystyle p^{*}$ ，rpn_bbox_outside_weigths未用到（从soomth_L1_Loss layer代码中可以看到），而 $\displaystyle N_\text{reg}$ 同样隐含在caffe blob大小中

这样，公式与代码就完全对应了。特别需要注意的是，在训练和检测阶段生成和存储anchors的顺序完全一样，这样训练结果才能被用于检测！

5.2 通过训练好的RPN网络收集proposals

在该步骤中，利用之前的RPN网络，获取proposal rois，同时获取positive softmax
probability，如图20，然后将获取的信息保存在python pickle文件中。该网络本质上和检测中的RPN网络一样，没有什么区别。

图20 rpn_test.pt

5.3 训练Faster RCNN网络

读取之前保存的pickle文件，获取proposals与positive probability。从data层输入网络。然后：

将提取的proposals作为rois传入网络，如图21蓝框
计算bbox_inside_weights+bbox_outside_weights，作用与RPN一样，传入soomth_L1_loss layer，如图21绿框

这样就可以训练最后的识别softmax与最终的bounding box regression了。

图21 stage1_fast_rcnn_train.pt

之后的stage2训练都是大同小异，不再赘述了。Faster R-CNN还有一种end-to-
end的训练方式，可以一次完成train，有兴趣请自己看作者GitHub吧。

rbgirshick py-faster-rcnn

QA

此篇文章初次成文于2016年内部学习分享，再后来经多次修正和完善成为现在的样子。感谢大家一直以来的支持，现在总结常见疑问回答如下：

为什么Anchor坐标中有负数

回顾anchor生成步骤：首先生成9个base anchor，然后通过坐标偏移在 $\displaystyle 50 \ast 38$ 大小的$\displaystyle \frac{1}{16}$ 下采样FeatureMap每个点都放上这9个base anchor，就形成了 $\displaystyle 50 \ast 38 \ast k$ 个anhcors。至于这9个base anchor坐标是什么其实并不重要，不同代码实现也许不同。

显然这里面有一部分边缘anchors会超出图像边界，而真实中不会有超出图像的目标，所以会有clip anchor步骤。

图21 clip anchor

Anchor到底与网络输出如何对应

VGG输出 $\displaystyle 50*38*512$ 的特征，对应设置 $\displaystyle 50*38*k$
个anchors，而RPN输出 $\displaystyle 50*38*2k$ 的分类特征矩阵和 $\displaystyle 50*38*4k$ 的坐标回归特征矩阵。

图22 anchor与网络输出如何对应方式

其实在实现过程中，每个点的 $\displaystyle 2k$ 个分类特征与 $\displaystyle 4k$ 回归特征，与

$\displaystyle k$ 个anchor逐个对应即可，这实际是一种“人为设置的逻辑映射”。当然，也可以不这样设置，但是无论如何都需要保证
在训练和测试过程中映射方式必须一致 。

为何有ROI Pooling还要把输入图片resize到固定大小的MxN

由于引入ROI Pooling，从原理上说Faster
R-CNN确实能够检测任意大小的图片。但是由于在训练的时候需要使用大batch训练网络，而不同大小输入拼batch在实现的时候代码较为复杂，而且当时以Caffe为代表的第一代深度学习框架也不如Tensorflow和PyTorch灵活，所以作者选择了把输入图片resize到固定大小的800x600。这应该算是历史遗留问题。

另外很多问题，都是属于具体实现问题，真诚的建议读者阅读代码自行理解。

参考文献

Object Detection and Classification using R-CNNs

拓展

检测算法的评价指标：

请问目标检测中的detection performance一般是指那个指标，还是一个统称？

Faster RCNN在文字检测中的应用：CTPN

场景文字检测—CTPN原理与实现

Faster RCNN在高德导航中的应用：

机器学习在交通标志检测与精细分类中的应用

展开全文 >>

揭开深度学习的神秘面纱

2020-03-24

分享的内容分四部分，分别是 入门、基础、进阶和发展趋势 。

深度学习简单入门

2016年3月份，AlphaGo以4：1战胜韩国围棋手李世石，一举震惊了世界。

人工智能一下就引爆了整个世界。有种趋势就是，不谈人工智能，就落伍了。

以前资本圈融资都谈的是“互联网+”，现在都在谈“AI+”了。

有人说，马上人工智能时代就要来了，甚至有人宣扬人工智能威胁论。

那么，当我们谈论人工智能的时候，我们究竟在谈论什么呢？

我们先来讨论下“人工智能”的定义。

什么叫做智能呢？所谓智能，其实就是对人某些高级功能的模拟，让计算机去完成一些以前只有人才能完成的工作，比如思考、决策、解决问题等等。

比如以前只有人可以进行数学计算，而现在计算机也可以进行计算，而且算的比人还准，还快，我们说计算机有一点智能了。

人工智能的发展经历了好几个发展阶段，从最开始的简单的逻辑推理，到中期的基于规则（Rule-
based）的专家系统，这些都已经有一定的的智能了，但距离我们想象的人工智能还有一大段距离。直到机器学习诞生以后，人工智能界感觉终于找到了感觉。基于机器学习的图像识别和语音识别在某些垂直领域达到了跟人相媲美的程度。人工智能终于能够达到一定的高度了。

当前机器学习的应用场景非常普遍，比如图像识别、语音识别，中英文翻译，数据挖掘等，未来也会慢慢融入到各行各业。

虽然都是机器学习，但是背后的训练方法和模型是完全不同的。

根据训练的方法不同，机器学习算法可以大致分类为 监督学习、无监督学习 和 强化学习 三种。

监督学习，就是训练数据是有标签的，也就是每个数据都是标注过的，是有正确答案的。训练的时候会告诉模型什么是对的，什么的错的，然后找到输入和输出之间正确的映射关系，比如物体种类的图像识别，识别一张图片内容是只狗，还是棵树。

非监督学习，就是训练数据没有标签的，只有部分特征。模型自己分析数据的特征，找到数据别后隐含的架构关系，比如说自己对数据进行学习分类等等，常见的算法有聚类算法，给你一堆数据，将这数据分为几类。比如在银行的数据库中，给你所有客户的消费记录，让你挑选出哪些可以升级成VIP客户，这就是聚类算法。

还有一种是强化学习，目标是建立环境到行为之间的最佳映射。强化学习的训练是不需要数据的，你告诉他规则或者给他明确一个环境，让模型自己通过不断地尝试，自己根据结果来自己摸索。

Deep Mind的AlphaGo Zero就是通过强化学习训练的,号称花了3天的训练时间就能100：0打败AlphaGo。

比较适合强化学习的一般是环境到行为之间的结果规则比较明确，或者环境比较单一、不太容易受噪音干扰等等，比如下围棋的输赢等等，还可以模拟直升机起降、双足机器人行走等等。

我们今天讨论的就是基于监督学习在图像识别领域的应用。

接下来我们再看下人工智能的历史。

虽说我们感觉人工智能最近几年才开始火起来，但是这个概念一点也不新鲜。

起源于上世纪五、六十年代就提出人工智能的概念了，当时叫 感知机
（perceptron），拥有输入层、输出层和一个隐含层。输入的特征向量通过隐含层变换达到输出层，在输出层得到分类结果，当时的人们对此非常乐观，号称要在10年内解决所有的问题。但是，单层感知机有一个严重得不能再严重的问题，即它对稍复杂一些的函数都无能为力（比如最为典型的“异或”逻辑），连异或都不能拟合。当时有一个专家叫明斯基，号称人工智能之父，在一次行业大会上公开承认，人工智能连一些基本的逻辑运算（比如异或运算）都无能为力，于是政府所有的资助全部都停掉了，于是进入人工智能的第一个冬天。

随着数学的发展，这个缺点直到上世纪八十年代才发明了 多层感知机
克服，同时也提出了梯度下降、误差反向传播（BP）算法等当前深度学习中非常基础的算法。之前被人诟病的问题已经被解决了，希望的小火苗又重新点燃了，于是人工智能开始再次兴起。

但是没过多久大家发现了，虽然理论模型是完善了，但是并没有实际用途，还不能解决实际问题，于是又冷下去了，人工智能的第二个冬天降临。

直到2012年开始第三次兴起，也就是最近几年人工智能的热潮。

下面我们就来第三次热潮是如何兴起的。

在这之前，我们先介绍一个比赛。这个比赛是一项图像识别的挑战赛，给你大量图片去做图像识别，比赛看谁的识别错误低。在2012年之前，错误率降低到30%以后，再往下降就很难了，每年只能下降个2，3个百分点。

直到2012年，有一个哥们叫Alex，这哥们在寝室用GPU死磕了一个卷积神经网络的模型，将识别错误率从26%下降到了16%，下降了10%左右，一举震惊了整个人工智能界，当之无愧的获得了当年的冠军。

从此之后，卷积神经网络一炮而红。之后每年挑战赛的冠军，胜者都是利用卷积神经网络来训练的。2015年，挑战赛的错误率已经降低到3.5%附近，而在同样的图像识别的任务，人眼的辨识错误率大概在5.1%，也就是目前的深度学习模型的识别能力已经超过了人眼。

下图是最近几年比较有代表性的模型的架构。

大家可以看出来，深度学习的模型的发展规律，深，更深。没有最深，只有更深。

那么Alex的卷积神经网络这么厉害，是因为这个哥们是个学术大牛，有什么独创性的学术研究成果么？

其实并不是。

他所采用的模型是1998年Yann Lecun就提出了这个模型，当时Yann
Lecun把这个模型应用在识别手写邮编数字的识别上，取得了很好的效果，他搭建的网络，命名为Lenet。这个人的名字——Yann
Lecun，大家一定要记住，因为我们后面的内容将会以Lenet作为范本来讲解。

这个模型是1998年提出来的，可为什么时隔这么多年才开始火起来呢？

人工智能突然爆发背后深层次的原因是什么？我总结了一下，背后的原因主要有三个：

1.算法的成熟，尤其是随机梯度下降的方法的优化，以及一些能够有效防止过拟合的算法的提出，至于什么是随机梯度下降和过拟合，后面我们会详细讲到

2.数据获取，互联网的爆发，尤其是移动互联网和社交网络的普及，可以比较容易的获取大量的互联网资源，尤其是图片和视频资源，因为做深度学习训练的时候需要大量的数据。

3.计算能力的提升，因为要训练的数据量很大（都是百万级以上的数据），而且训练的参数也很大（有的比较深的模型有几百万甚至上千万个的参数需要同时优化），而多亏了摩尔定律，能够以较低的价格获取强大的运算能力，也多亏了Nvida，开发了GPU这个神器，可以大幅降低训练时间。

GPU的运算速度是CPU的5-10倍左右，同样的模型需要训练，如果用CPU训练需要一个礼拜的话，那使用GPU，只需要一天时间就可以了。

_截止到目前，我们汇总下我们的学习内容，我们了解了人工智能的简单介绍，大致了解了人工智能的算法分类以及发展历史。_

深度学习基础知识

接下来我们了解一下基础知识。

我们上面也提到了，我们这次主要以卷积神经网络在图像识别领域的应用来介绍深度学习的。

卷积神经网络，这个词听起来非常深奥。

但其实没什么复杂的，我们可以分开成两个词来理解，卷积和神经网络。

先看下卷积。

卷积时数学的定义，在数学里是有明确的公式定义的。

是不是觉得公式太抽象，看不明白？没关系，我们举个栗子就明白了。

还是以图像识别为例，我们看到的图像其实是由一个个像素点构成的。

一般彩色图像的是RGB格式的，也就是每个像素点的颜色，都是有RGB（红绿蓝三原色混合而成的），是三个值综合的表现。

假设f函数为5x5（对应到图片上即为5x5像素）为例，h函数为3x3的函数，大家可以理解为为一个手电筒（也就是筛选器），依次扫过这个5x5的区间。在照过一个区域，就像对应区域里的值就和框里的数据去做运算。最终输出为我们的输出图。

手电筒本身是一个函数，在3x3的区域内，他在每个位置都有参数，它的参数和对应到图片上相应位置的数字，先相乘，然后再把相乘的数字相加的结果输出，依次按照这些去把整个图片全部筛选一遍，就是我们所说的卷积运算了。

还是比较抽象，没关系，看下面这个图片就清楚了。

那我们为什么要做卷积呢？我们其实就是建立一个输入和输出的函数，图像识别的目的就是把输入的信息（像素点信息）对应到我们输出结果（识别类别）上去，所以是逐层提取有用特征，去除无用信息的过程。

比如下图所示，第一层可以识别一些边缘信息，后面逐层抽象，汇总到最后，就可以输出我们想要的结果，也就是我们的识别结果。

虽然我们知道特征是逐层抽象提取的，但是不幸的是，我们并不知道那一层是具体做什么的，也就不知道那个层数具体是什么意思。

也就是说，其实深度学习网络对于我们而言，是个黑盒子，我们只能通过他的输出来判断其好坏，而不能直接去调整某个参数。

那么，什么是神经网络呢？其实这个模型来自于心理学和神经学，人工智能的专家借鉴了这个结构。

左侧为神经元，神经元接收外界的输入刺激或者其他神经元的传递过来的信号，经过处理，传递给外界或者给其他神经元。

右侧为我们根据神经元的生物学特征抽象出来的数学模型，其中x是输入，包括一开始数据来源（外部刺激）的输入，也包括其他节点（神经元）的输入。

w为参数（weight），每个节点还有一个b，这个b其实是一个偏置。

大家在学习新东西的时候，凡事多问个为什么？只有知道背后的原因了，这样你才能理解的更深刻。有句话说得好，还有什么比带着问题学习更有效率的学习方法呢?

为什么要加这个b呢？大家想想看，如果没有b的话，当输入x为0的时候，输出全部为0，这是我们不想看到的。所以要加上这个b，引入更多的参数，带来更大的优化空间。

大家看一下，目前为止，这个神经元里的函数（对输入信号的处理）都还是线性的，也就是说输出与输入是线性相关的，但是根据神经元的生物学研究，发现其接受到的刺激与输入并不是线性相关的，也为了能够表征一些非线性函数，所以必须要再引入一个函数，也就是下面我们要讲的激活函数（activation
function）。

为什么需要激活函数？因为需要引入一些非线性的特性在里面。

常见的激活函数有这些。

以前是sigmoid比较常见，但是现在ReLU用的比较多一些。

就类似于下图这样，在节点经过线性运算后，经过非线性的ReLU,然后进入下一层的下一个节点。中间的w和b，就是我们卷积神经网络的参数，也是我们模型中需要训练的对象。

大家看LeNet模型中，就是在输入数据多次进行卷积神经网络的处理。

对于模型而已，我们习惯把输入的数据叫做输入层，中间的网络叫做隐藏层，输出的结果叫做输出层。中间层数越多，模型越复杂，所需要训练的参数也就越多。

所谓的deep learning中的deep，指的就是中间层的层数，右图中GoogLenet有22层。

一般说来，模型越复杂，所能实现的功能也越强大，所能达到的精度也越高，目前最深的模型大概有10的7次方个神经元，其神经元比相对原始的脊椎动物如青蛙的神经系统还要小。
自从引入隐藏单元，人工神经网络的大小大约每 2.4 年翻一倍，按照现在的发展速度，大概要到2050年左右才能达到人类大脑的神经元数量的规模。

损失函数

怎么判断一个模型训练的好坏呢？我们需要一个评价指标（也就是KPI考核指标），也就是损失函数。

我们最初的目标是什么？是建立输入输出的映射关系。

比如我们的目标是判断一张图片上是只猫，还是一棵树。那这张图片上所有的像素点就是输入，而判断结果就是输出。

那怎么表征这个模型的好坏呢？很简单，大家应该很容易想到，就是把模型输出的答案和正确答案做一下比对，看一下相差多少。

我们一般用下面这个公式（平均平方误差，即MSE）来评估我们的模型好坏。

我们就是通过对比输出结果与预期结果的差异，其中带帽子的yu就是预期的结果（也就是标签值，即是真值），而前面的不带帽子的yu就是实际的输出结果。当训练结果非常好的时候，比如说是全对的时候，平均误差就是0。当训练结果非常差的时候，比如说全错的时候，误差即为1.

于是我们知道了，这个E越小越好，最好变成0.

大家注意下，这个求和的标识，表示是所有的数据的和，而不是一个的数值。我们常说大数据来训练模型，其实这就是大数据。我们训练的时候需要上百万张的图片，最终得出来的误差，就是这里，然后再除以数量，取平均值。

那怎么去降低这个误差呢？要回答这个问题，就涉及到卷积神经网络的核心思想了，也就是反向传播。

反向传播/梯度下降

既然讲到机器学习，那当然是让机器自己去通过数据去学习，那机器是如何进行自学习的呢？下面就要敲黑板，划重点了，因为这就是深度学习的重中之重了，也就是机器学习的核心了，理解了这个概念，基本上就理解了一多半了。

这个概念就是反向传播。听名字比较玄乎，其实这个概念大家在高等数学里都接触过这个概念了——梯度，其实也就是求导。

对于一维函数而言，函数梯度下降的方向就是导数的反方向。

对于二维函数而言，就是把误差对每个变量求偏导，偏导的反方向即为梯度下降的方向。

说起来有点抽象，我们举个实例来说明一下。

下面是我们的参数和损失函数的值。

我们先对第一个参数加一个极小值，算出新的损失函数。

然后用损失函数的变化去除这个极小值，就是这个参数的梯度了。

同样我们可以使用同样的方法去求得其他参数的梯度。

只要找到梯度下降的方向，按照方向去优化这些参数就好了。这个概念就是梯度下降。

但是我们知道，我们要训练的参数非常多，数据量也非常大，经常是百万、千万量级的，如果每次都把全部训练数据都重新计算一遍，计算损失函数，然后再反向传播，计算梯度，这样下去，模型的误差优化的非常非常慢。

那有没有更快的方法呢？

当然有了。

这些参数（weights），数量非常多，大概有上百万个，为了保证能够更好、更快的计算，节省算力，一般选用随机梯度下降方法，随机抽取一定数量（即为批量，batch）的样本，去计算梯度值，一般选择32/64/128。

这个方法就是随机梯度下降，这个批量（batch）这也是大家经常要调的参数。

我们可以这样理解随机梯度下降，其核心思想是，梯度是期望。期望可使用小规模的样本近似估计。具体而言，在算法的每一步，我们从训练集中均匀抽出小批量样本来代替全部数据的梯度，因为其梯度期望是一致的。

值得一提是：这些batch中的样本，必须是随机抽取的，否则其期望就准确了。选的批量（batch）的值越小，进行一次参数优化的计算量越小，就越快，但是其随机性会比较大一些，如果选取的批量值比较大，则计算会稍微慢一些，但是随机性会小一些，这是我们需要权衡的。

前向计算一次，反向反馈一下，更新一下参数，叫做一个Epoch.

Epoch的次数也是个超参数，也是需要搭建模型的时候可以调整的参数。

在整个模型中也是类似的。

_简单总结下，截止到目前，我们已经了解了一些深度学习的基本概念，比如什么是卷积神经网络，了解了反向传播的传播的概念，如何梯度下降的方法去优化误差。_

基本上深度学习是什么回事，大家已经知道了，但是深度学习还需要注意一些细节。有句话说的好，细节就是魔鬼，细节处理的好坏很大程度上决定了你是一个高手，还是一个菜鸟。

深度学习之高手进阶

我们在进行深度学习的时候一般会按照这4个步骤进行。

获取数据

很大程度上，数据的多少决定模型所能达到的精度。再好的模型，没有足够数据，也是白瞎。

对于监督学习而言，需要大量标定的数据。

数据的获取是有成本的，尤其是我们需要的数据都是百万、千万量级的，成本非常高。亚马逊有个专门发布标定任务的平台，叫做Amazon Mechanical
Turk.

很多大的数据，比如IMAGENET就是在这上面做label的。

Amazon从中抽取20%的费用，也就是说，需求方发布100美元的任务，得多交20美元给Amazon，躺着也挣钱。

由于数据的获取是有成本的，而且成本很高的。

所以我们需要以尽量低的价格去获得更多的数据，所以，在已经获得数据基础上，仅仅通过软件处理去扩展数据，就是非常重要的，常见的数据扩展的方法见下图。

数据预处理-归一化

为了更好的计算数据，避免出现太大或者太小的数据，从而出现计算溢出或者精度失真，一般在开始做数据处理之前，需要进行归一化处理，就是将像素保持在合理的范围内，如[0,1]或者[-1,1]。

模型搭建

除了上面提到的卷积神经网络之外，我们在搭建模型的时候，还需要一些其他层，最常见的是输出控制。

全连接层Fully-connected

全连接层，其字面意思就是将每个输入值和每个输出值都连接起来，全连接层的目的其实就是控制输出数量。

比如我们最终分类是有10类，那我们需要把输出控制为10个，那就需要一个全连接层来链接输出层。

softmax

我们用数值来表征其可能性大小，数值越大，其可能性越大，有的值可能很大，有的值可能很小，是负的。

怎么用概率来表征其可能性呢？总不能加起来一除吧，但是有负数怎么办呢？全连接之后，我们每个类别得到一个值，那怎么转化表征其可能性的概率呢？我们一般通过softmax来转化。

softmax的目的就是把数值转化给每个标签的概率，就是将最终各个值的得分，转化成各个输出值的概率。

独热编码 One-Hot Encoding

独热编码,又叫做一位有效编码

有多少标签，就转化为多少行的单列矩阵，其本质就是将连续值转化为离散值。

这样可以直接直接将输出值直接输出，得到一个唯一值。

就像一个筛子，只留一个最大值，其他全部筛掉。

我们以LeNet为例串起来看（见下图），输出值经过全连接层，转化为10个标签值，然后经过softmax和one-hot
encoding，最终转化为唯一的识别标签值，就是我们想要的结果。

客观评价——交叉验证

讲完输出控制，我们再讲一下评价方法。

我们有一些数据，希望利用现有的数据去训练模型，同时利用这些数据去评价这个模型的好坏，也就是我们需要知道，这个模型的准确率是50%，还是90%，还是99%？

具体怎么去做呢？

最先想到的是，用全部的数据去训练，然后评价的时候，从中抽取一定数量的样本去做验证。这不是很简单嘛？

但是，这样不行。

想像一下，在高考考场上，你打开试卷，看了一眼之后高兴坏了。因为你发现这些试题你之前做练习的时候都做过。

其实是一个道理。如果拿训练过的数据去做验证，那得到的误差率会比实际的误差率要低得多，也就失去了意义。

那怎么办呢？我们需要把训练数据和最终评价的数据（也就是验证数据）要分开。这样才能保证你验证的时候看的是全新的数据，才能保证得到的结果是客观可靠地结果。所以我们会得到两个误差率，一个是训练集的误差率，一个是验证集的误差率，记住这两个误差率，后面会用到。

拿到数据的第一步，先把所有的数据随机分成两部分：训练集和验证集。一般而言，训练集占总数据的80%左右，验证集占20%左右。

训练的时候，随机从训练集中抽取一个批量的数据，去训练，也就是一次正向传播和一次反向传播。

这一轮做完之后，从验证集里随机抽取一定数量来评价下其误差率。

每做一轮学习，一次正向传播一次反向传播，就随机从验证集里抽取一定数量数据来评价其模型的准确率，一轮之后我们获得训练误差率和验证误差率。

接下来就是重点了，就是模型训练。

模型训练

实际训练模型的时候，我们会碰到两大终极难题，一个是欠拟合，一个是过拟合。

所谓欠拟合，就是训练误差率和验证误差率都很高。

所谓过拟合，就是训练集的误差率很低，但是验证集的误差率很高。

欠拟合和过拟合其实跟模型的复杂程度有很大的关系。

比如这张图里面，本来是抛物线的数据，如果用线性模型去拟合的话，效果很很差。如果用9次方模型去拟合的话，虽然训练集表现非常好，但是测试新数据的时候，你会发现表现很差。

欠拟合的原因其实比较简单，就是模型的深度不够，只需要把模型变得复杂一些就能解决。

过拟合的原因就比较多了，一般来说，简单粗暴的增加训练集的数量就能解决这个问题，但是有时候受限于客观条件，我们没有那么多数据。这时候我们就需要调整一些参数来解决过拟合的问题了。

模型中能调整的参数叫做超参数。

调整这些参数，有时候有道理，有时候又没有道理，更多的是靠的一种感觉。有人说，调整超参数与其说是个科学，其实更像是一项艺术。

常见的调整的超参数有以下几种，下面我们逐项介绍一下。

学习率

上面提到的随机梯度下降中，我们会在梯度的前面加一个系数，我们管它叫做学习率，这个参数直接影响了我们误差下降的快慢。

当我们遇到问题的时候，先尝试调整下学习率，说不定就能解决问题。

选择一个合适的学习率可能是困难的。学习率太小会导致收敛的速度很慢，学习率太大会妨碍收敛，导致损失函数在最小值附近波动甚至偏离最小值。下面这张图比较好的说明了学习率高低对模型误差下降的影响。

冲量Momentum

冲量的概念其实就是在梯度下降的时候，把上次的梯度乘以一个系数pho，加上本次计算的梯度，然后乘以学习率，作为本次下降用的梯度。pho一般选取0.9或者0.99。其本质就是加上了之前梯度下降的惯性在里面，所以叫做冲量。

有时候会采用冲量（momentum）能够有效的提高训练速度，并且也能够更好的消除SGD的噪音（相当于加了平均值），但是有个问题，就是容易冲过头了，不过总体来说，表现还是很不错的，一般用的也比较多。

下面这两张图也能看出来，SGD+冲量能够有效的加快优化速度，还能够避免随机的噪音。

轮数epochs

前面提到，一次正向传播，一次反向传播就是一轮，也就是一个epoch。

一般来说，轮数越多，其误差会越好，但是当学习的越多的时候，他会把一些不太关键的特征作为一些重要的判别标准，从而出现了过拟合。如果发现这种情况（下图），我们需要尽早停止学习。

参数初始化（weights initialization）

对于模型的所有参数，我们均随机进行初始化，但是初始化的时候我们一般会让其均值为0，公差为sigma，sigma一般选择比较大，这样其分散效果比较好，训练效果也比较好。

但是有时候仅仅调整超参数并不能解决过拟合的问题，这时候我们需要在模型上做一些文章，在模型上做一些处理，来避免过拟合。

Dropout

最常见的方法就是dropout.

drop的逻辑非常简单粗暴，就是在dropout过程中，有一半的参数不参与运算。

比如说公司里，每天随机有一般人不来上班，为了正常运转，每个岗位都需要有好几个人来备份，这样公司就不会过于依赖某一个人，其实是一个道理。

dropout的本质是冗余。为了避免过拟合，我们需要额外增加很多冗余，使得其输出结果不依赖于某一个或几个特征。

Pooling池化

除此之外，池化也是比较常用到的。

Pooling主要的作用为降维，降维的同时能够保留主要特征，能够防止过拟合。

Pooling主要有两种：一种是最大化Pooling，还有一中是平均池化。

最大池化就是把区域的最大值传递到下一层（见下图），平均池化就是把区域内的平均值传递到下一层。

一般在Pooling之后会加上一个1x1的卷积层，这样能够以非常低的成本（运算量），带来更多的参数，

更深的深度，而且验证下来效果也非常好。

接下来我们可以分析下Lenet的数据，看的出来是卷积—>池化—>卷积—>池化—>平化（Flatten，将深度转化为维度）—>全连接—>全连接—>全连接。

下面这个模型也比较简单，经过多层卷积、池化之后，平化，然后经过softmax转化。

_截止到目前，我们又了解了训练模型所需要的技巧，如获取数据、预处理数据、模型搭建和模型调试，重点了解了如何防止过拟合。_

恭喜你，现在你已经完全了解了深度学习的全部思想，成功晋级成深度学习高手了~

接下来我们看下深度学习的发展趋势。

深度学习发展趋势

目前深度学习在图像识别领域取得了很多突破，比如可以对一张图片多次筛选获取多个类别，并标注在图片上。

还可以进行图像分割。

在做图像分割标注的时候，难度很大，需要把每个类别的范围用像素级的精度画出来。这对标注者的素质要求很高。

还可以根据图像识别的结果直接生成语句。

Google翻译可以直接将图片上的字母翻译过来，显示在图片上，很厉害。

最近媒体上很多新闻，说人工智能可以作诗，写文章，画画等等，这也都是比较简单的。

但是当前图像识别领域还存在一些问题，最大的就是其抗干扰能力比较差。

下图中左侧的图片为原始图片，模型可以轻易识别，但是人工加上一些干扰之后，对于肉眼识别不会造成干扰，但是会引起模型的严重误判。

这种情况可能会在某些很重要的商业应用中带来一些风险，比如在自动驾驶的物体识别时，如果有人故意对摄像头造成干扰，就会引起误判，从而可能会引起严重后果。

深度学习在自动驾驶领域有比较多的应用，下面是我做自动驾驶项目中的视频。

车辆识别：

https://www.zhihu.com/video/920687534550446080

行为克隆：

https://www.zhihu.com/video/920687705740943360

下图为加特纳技术曲线，就是根据技术发展周期理论来分析新技术的发展周期曲线（从1995年开始每年均有报告），以便帮助人们判断某种新技术是否采用。其把技术成熟经过5个阶段：1是萌芽期，人们对新技术产品和概念开始感知，并且表现出兴趣；2是过热期，人们一拥而上，纷纷采用这种新技术，讨论这种新技术；3是低谷期，又称幻想破灭期。过度的预期，严峻的现实，往往会把人们心理的一把火浇灭；4是复苏期，又称恢复期。人们开始反思问题，并从实际出发考虑技术的价值。相比之前冷静不少；5是成熟期，又称高原期。该技术已经成为一种平常。

当前机器学习和自动驾驶就处在过热期。

说到底，人工智能其实就是一种工具而已，只不过这项工具能做的事情多了一些而已。

未来人工智能会融入到生活中的方方面面，我们不可能阻挡这种趋势，所以我们唯一能做的，就是好好利用好这个工具，让未来的工作和生活更加方便一些。

送大家一句话：

关于人工智能威胁论

当前有些媒体在肆意宣扬人工智能威胁论，这其实是毫无道理的。

当人类对自己不了解的事物会本能的产生恐惧，越是不了解，越是会产生恐惧。

大家今天看下来，是不是也觉得人工智能也没啥。

其实就是因为了解了，所以才不会恐惧。我们只有了解他，才能更好的利用好它。

当前有部分无良媒体以及所谓的专家，在传播人工智能威胁论。

其实所谓的专家根本就不是这个领域的专家，如果他不是这个领域的专家，那他对这个话题其实就没有话语权，他说话的分量就跟一个普通人说的没什么区别。

流传比较广的，比如说某个坐在轮椅上的英国物理学家，对，没错，我说的就是霍金。

还有某国际著名新能源汽车公司的CEO，对，我说的就是Elon Musk。

他们对人工智能其实也完全是一知半解。

相信大家今天看完这篇文章之后，对人工智能的理解就可以秒杀他们了。

最近看到吴军的一句话，来解释人工智能威胁论，觉得非常恰当。

说一下人工智能的边界：
1. 世界上有很多问题，其中只有一小部分是数学问题；
2. 在数学问题中，只有一小部分是有解的；
3. 在有解的问题中，只有一部分是理想状态的图灵机可以解决的；
4. 在后一类的问题中，又只有一部分是今天实际的计算机可以解决的；
5. 而人工智能可以解决的问题，又只是计算机可以解决问题的一部分。

最后分享一下学习资料：

Stanford CS231n课程： http:// cs231n.stanford.edu/
MIT自动驾驶课程： _ https :// selfdrivingcars.mit.edu / _
Deep Learning书籍: http://deeplearningbook.org
Foundational papers: http:// deeplearning.net/readin g-list
快速上手 http://www. fast.ai/
图解机器学习 http://www. r2d3.us/visual-intro-to -machine-learning-part-1/

本文的脑图链接：
https://www.processon.com/view/link/5e8a9161e4b07e41dc2d7a8d#map

展开全文 >>