Merge branch 'master' into master
This commit is contained in:
scutan90
GitHub
commit
95a261712c
|
|
@ -1,18 +1,29 @@
|
|||
# 第一章 数学基础
|
||||
|
||||
> Markdown Revision 1;
|
||||
> Markdown Revision 1; --update 2018/10/30 13:00
|
||||
> Date: 2018/10/25
|
||||
> Editor: 乔成磊-同济大学
|
||||
> Contact: qchl0318@163.com
|
||||
|
||||
## 1.1 标量、向量、张量之间的联系
|
||||
**张量（tensor)**
|
||||
## 1.1 标量、向量、矩阵、张量之间的联系
|
||||
**标量（scalar)**
|
||||
一个标量表示一个单独的数，它不同于线性代数中研究的其他大部分对象（通常是多个数的数组）。我们用斜体表示标量。标量通常被赋予小写的变量名称。
|
||||
|
||||
**向量（vector）**
|
||||
矩阵是具有相同特征和纬度的对象的集合，表现为一张二维数据表。其意义是一个对象表示为矩阵中的一行，一个特征表示为矩阵中的一列，每个特征都有数值型的取值。通常会赋予矩阵粗体的大写变量名称，比如**A**。
|
||||
|
||||
**矩阵（matrix）**
|
||||
一个向量表示组有序排列的数。通过次序中的索引，我们可以确定每个单独的数。通常我们赋予向量粗体的小写变量名称，比如xx。向量中的元素可以通过带脚标的斜体表示。向量x的第一个元素是x1，第二个元素是x2，以此类推。我们也会注明存储在向量中的元素的类型（实数、虚数等）。
|
||||
|
||||
**张量（tensor）**
|
||||
在某些情况下，我们会讨论坐标超过两维的数组。一般地，一个数组中的元素分布在若干维坐标的规则网格中，我们将其称之为张量。使用**$A$**来表示张量“A”。张量**$A$**中坐标为$(i,j,k)$的元素记作$A_{(i,j,k)}$。
|
||||
|
||||
**关系**
|
||||
标量是0阶张量，向量是一阶张量。举例：
|
||||
标量就是知道棍子的长度，但是你不会知道棍子指向哪儿。
|
||||
向量就是不但知道棍子的长度，还知道棍子指向前面还是后面。
|
||||
张量就是不但知道棍子的长度，也知道棍子指向前面还是后面，还能知道这棍子又向上/下和左/右偏转了多少。
|
||||
|
||||
## 1.2 张量与矩阵的区别？
|
||||
1. 从代数角度讲， 矩阵它是向量的推广。向量可以看成一维的“表格”（即分量按照顺序排成一排）， 矩阵是二维的“表格”（分量按照纵横位置排列）， 那么$n$阶张量就是所谓的$n$维的“表格”。 张量的严格定义是利用线性映射来描述的。
|
||||
2. 从几何角度讲， 矩阵是一个真正的几何量，也就是说，它是一个不随参照系的坐标变换而变化的东西。向量也具有这种特性。
|
||||
|
|
@ -20,7 +31,8 @@
|
|||
4. 表示标量的数和表示矢量的三维数组也可分别看作1×1，1×3的矩阵。
|
||||
|
||||
## 1.3 矩阵和向量相乘结果
|
||||
一个$m$行$n$列的矩阵和$n$行向量相乘，最后得到就是一个$m$行的向量。运算法则就是矩阵中的每一行的数据与向量中的数据相乘。
|
||||
一个$m$行$n$列的矩阵和$n$行向量相乘，最后得到就是一个$m$行的向量。运算法则就是矩阵中的每一行数据看成一个行向量与该向量作点乘。
|
||||
|
||||
## 1.4 向量和矩阵的范数归纳
|
||||
**向量的范数**
|
||||
定义一个向量为：$\vec{a}=[-5, 6, 8, -10]$。
|
||||
|
|
@ -28,9 +40,17 @@
|
|||
向量的2范数：向量的每个元素的平方和再开平方根，上述$\vec{a}$的2范数结果就是：15。
|
||||
向量的负无穷范数：向量的所有元素的绝对值中最小的：上述向量$\vec{a}$的负无穷范数结果就是：5。
|
||||
向量的正无穷范数：向量的所有元素的绝对值中最大的：上述向量$\vec{a}$的负无穷范数结果就是：10。
|
||||
向量的L-P范数：$L_p=|\vec{x}|_p=\sqrt[p]{\sum_{i=1}^{n}x_i^p},\vec{x}=( x_1,x_2,...,x_n )$
|
||||
|
||||
**矩阵的范数**
|
||||
定义一个矩阵$A=[-1, 2, -3; 4, -6, 6]$。
|
||||
矩阵的范数定义为
|
||||
$$
|
||||
\|A\|_p :=\sup_{x\neq 0}\frac{\|Ax\|_p}{\|x\|_p}.
|
||||
$$
|
||||
|
||||
当向量取不同范数时, 相应得到了不同的矩阵范数。
|
||||
|
||||
**矩阵的1范数**：矩阵的每一列上的元素绝对值先求和，再从中取个最大的,（列和最大），上述矩阵$A$的1范数先得到$[5,8,9]$，再取最大的最终结果就是：9。
|
||||
**矩阵的2范数**：矩阵$A^TA$的最大特征值开平方根，上述矩阵$A$的2范数得到的最终结果是：10.0623。
|
||||
**矩阵的无穷范数**：矩阵的每一行上的元素绝对值先求和，再从中取个最大的，（行和最大），上述矩阵$A$的1范数先得到$[6；16]$，再取最大的最终结果就是：16。
|
||||
|
|
@ -39,6 +59,7 @@
|
|||
**矩阵的L1范数**：矩阵中的每个元素绝对值之和，它是L0范数的最优凸近似，因此它也可以表示稀疏，上述矩阵$A$最终结果就是：22。
|
||||
**矩阵的F范数**：矩阵的各个元素平方之和再开平方根，它通常也叫做矩阵的L2范数，它的有点在它是一个凸函数，可以求导求解，易于计算，上述矩阵A最终结果就是：10.0995。
|
||||
**矩阵的L21范数**：矩阵先以每一列为单位，求每一列的F范数（也可认为是向量的2范数），然后再将得到的结果求L1范数（也可认为是向量的1范数），很容易看出它是介于L1和L2之间的一种范数，上述矩阵$A$最终结果就是：17.1559。
|
||||
|
||||
## 1.5 如何判断一个矩阵为正定？
|
||||
1. 顺序主子式全大于0；
|
||||
2. 存在可逆矩阵$C$使$C^TC$等于该矩阵；
|
||||
|
|
@ -46,35 +67,52 @@
|
|||
4. 合同于单位矩阵$E$（即：规范形为$E$）
|
||||
5. 标准形中主对角元素全为正；
|
||||
6. 特征值全为正；
|
||||
7. 是某基的度量矩阵
|
||||
7. 是某基的度量矩阵。
|
||||
|
||||
## 1.6 导数偏导计算
|
||||
|
||||
## 1.7 导数和偏导数有什么区别？
|
||||
导数和偏导没有本质区别，都是当自变量的变化量趋于0时，函数值的变化量与自变量变化量比值的极限（如果极限存在的话）。
|
||||
一元函数，一个$y$对应一个$x$，导数只有一个。
|
||||
二元函数，一个$z$对应一个$x$和一个$y$，有两个导数：一个是$z$对$x$的导数，一个是$z$对$y$的导数，称之为偏导。
|
||||
求偏导时要注意，对一个变量求导，则视另一个变量为常数，只对改变量求导，从而将偏导的求解转化成了一元函数的求导了。
|
||||
(http://blog.sina.com.cn/s/blog_5b014d510100axmt.html)
|
||||
|
||||
## 1.8 特征值分解与特征向量
|
||||
特征值分解可以得到特征值与特征向量，特征值表示的是这个特征到底有多重要，而特征向量表示这个特征是什么。
|
||||
如果说一个向量$\vec{v}$是方阵$A$的特征向量，将一定可以表示成下面的形式：$$A\nu = \lambda \nu$$
|
||||
$\lambda$为特征向量$\vec{v}$对应的特征值。特征值分解是将一个矩阵分解为如下形式： $$A=Q\sum Q^{-1}$$
|
||||
|
||||
如果说一个向量$\vec{v}$是方阵$A$的特征向量，将一定可以表示成下面的形式：
|
||||
$$
|
||||
A\nu = \lambda \nu
|
||||
$$
|
||||
$\lambda$为特征向量$\vec{v}$对应的特征值。特征值分解是将一个矩阵分解为如下形式：
|
||||
$$
|
||||
A=Q\sum Q^{-1}
|
||||
$$
|
||||
其中,$Q$是这个矩阵$A$的特征向量组成的矩阵，$\sum$是一个对角矩阵，每一个对角线元素就是一个特征值，里面的特征值是由大到小排列的，这些特征值所对应的特征向量就是描述这个矩阵变化方向（从主要的变化到次要的变化排列）。也就是说矩阵$A$的信息可以由其特征值和特征向量表示。
|
||||
对于矩阵为高维的情况下，那么这个矩阵就是高维空间下的一个线性变换。可以想象，这个变换也同样有很多的变换方向，我们通过特征值分解得到的前N个特征向量，那么就对应了这个矩阵最主要的N个变化方向。我们利用这前N个变化方向，就可以近似这个矩阵（变换）。
|
||||
(http://blog.csdn.net/jinshengtao/article/details/18448355)
|
||||
|
||||
## 1.9 奇异值与特征值有什么关系?
|
||||
那么奇异值和特征值是怎么对应起来的呢？我们将一个矩阵$A$的转置乘以$A$，并对$AA^T$求特征值，则有下面的形式：$$(A^TA)V = \lambda V$$
|
||||
这里$V$就是上面的右奇异向量，另外还有：$$\sigma_i = \sqrt{\lambda\_i}, u\_i=\frac{1}{\sigma\_i}A\mu\_i$$
|
||||
那么奇异值和特征值是怎么对应起来的呢？我们将一个矩阵$A$的转置乘以$A$，并对$AA^T$求特征值，则有下面的形式：
|
||||
$$
|
||||
(A^TA)V = \lambda V
|
||||
$$
|
||||
这里$V$就是上面的右奇异向量，另外还有：
|
||||
$$
|
||||
\sigma_i = \sqrt{\lambda_i}, u_i=\frac{1}{\sigma_i}A\mu_i
|
||||
$$
|
||||
这里的$\sigma$就是奇异值，$u$就是上面说的左奇异向量。【证明那个哥们也没给】
|
||||
奇异值$\sigma$跟特征值类似，在矩阵$\sum$中也是从大到小排列，而且$\sigma$的减少特别的快，在很多情况下，前10%甚至1%的奇异值的和就占了全部的奇异值之和的99%以上了。也就是说，我们也可以用前$r$（$r$远小于$m、n$）个的奇异值来近似描述矩阵，即部分奇异值分解：
|
||||
$$A\_{m\times n}\thickapprox U_{m \times r}\sum\_{r\times r}V\_{r \times n}^T$$
|
||||
|
||||
$$
|
||||
A_{m\times n}\thickapprox U_{m \times r}\sum_{r\times r}V_{r \times n}^T
|
||||
$$
|
||||
右边的三个矩阵相乘的结果将会是一个接近于$A$的矩阵，在这儿，$r$越接近于$n$，则相乘的结果越接近于$A$。
|
||||
|
||||
## 1.10 机器学习为什么要使用概率？
|
||||
事件的概率是衡量该时间发生的可能性的量度。虽然在一次随机试验中某个事件的发生是带有偶然性的，但那些可在相同条件下大量重复的随机试验却往往呈现出明显的数量规律。
|
||||
机器学习除了处理不确定量，也需处理随机量。不确定性和随机性可能来自多个方面，使用概率论来量化不确定性。
|
||||
概率论在机器学习中扮演着一个核心角色，因为机器学习算法的设计通常依赖于对数据的概率假设。
|
||||
|
||||
>例如在机器学习（Andrew Ng）的课中，会有一个朴素贝叶斯假设就是条件独立的一个例子。该学习算法对内容做出假设，用来分辨电子邮件是否为垃圾邮件。假设无论邮件是否为垃圾邮件，单词x出现在邮件中的概率条件独立于单词y。很明显这个假设不是不失一般性的，因为某些单词几乎总是同时出现。然而，最终结果是，这个简单的假设对结果的影响并不大，且无论如何都可以让我们快速判别垃圾邮件。
|
||||
|
||||
## 1.11 变量与随机变量有什么区别？
|
||||
|
|
@ -85,6 +123,7 @@ $$A\_{m\times n}\thickapprox U_{m \times r}\sum\_{r\times r}V\_{r \times n}^T$$
|
|||
比如：
|
||||
当变量$x$值为100的概率为1的话,那么$x=100$就是确定了的,不会再有变化,除非有进一步运算.
|
||||
当变量$x$的值为100的概率不为1,比如为50的概率是0.5,为100的概率是0.5,那么这个变量就是会随不同条件而变化的,是随机变量,取到50或者100的概率都是0.5,即50%。
|
||||
|
||||
## 1.12 常见概率分布？
|
||||
(https://wenku.baidu.com/view/6418b0206d85ec3a87c24028915f804d2b168707)
|
||||
|
||||
|
|
@ -96,7 +135,10 @@ $$A\_{m\times n}\thickapprox U_{m \times r}\sum\_{r\times r}V\_{r \times n}^T$$
|
|||
|
||||
|
||||
## 1.13 举例理解条件概率
|
||||
条件概率公式如下：$$P(A/B) = P(A\cap B) / P(B)$$
|
||||
条件概率公式如下：
|
||||
$$
|
||||
P(A/B) = P(A\cap B) / P(B)
|
||||
$$
|
||||
说明：在同一个样本空间$\Omega$中的事件或者子集$A$与$B$，如果随机从$\Omega$中选出的一个元素属于$B$，那么下一个随机选择的元素属于$A$ 的概率就定义为在$B$的前提下$A$的条件概率。
|
||||
|
||||
|
||||
|
|
@ -105,80 +147,98 @@ $$A\_{m\times n}\thickapprox U_{m \times r}\sum\_{r\times r}V\_{r \times n}^T$$
|
|||
**穷举法**：已知其中一个是女孩，那么样本空间为男女，女女，女男，则另外一个仍然是女生的概率就是1/3;
|
||||
**条件概率法**：$P(女|女)=P(女女)/P(女)$,夫妻有两个小孩，那么它的样本空间为女女，男女，女男，男男，则$P(女女)$为1/4，$P（女）= 1-P(男男)=3/4$,所以最后$1/3$。
|
||||
这里大家可能会误解，男女和女男是同一种情况，但实际上类似姐弟和兄妹是不同情况。
|
||||
|
||||
## 1.14 联合概率与边缘概率联系区别？
|
||||
**区别：**
|
||||
联合概率：联合概率指类似于$P(X=a,Y=b)$ 这样，包含多个条件，且所有条件同时成立的概率。联合概率是指在多元的概率分布中多个随机变量分别满足各自条件的概率。
|
||||
联合概率：联合概率指类似于$P(X=a,Y=b)$这样，包含多个条件，且所有条件同时成立的概率。联合概率是指在多元的概率分布中多个随机变量分别满足各自条件的概率。
|
||||
边缘概率：边缘概率是某个事件发生的概率，而与其它事件无关。边缘概率指类似于$P(X=a)$，$P(Y=b)$这样，仅与单个随机变量有关的概率
|
||||
|
||||
**联系：**
|
||||
联合分布可求边缘分布，但若只知道边缘分布，无法求得联合分布。
|
||||
|
||||
## 1.15条件概率的链式法则
|
||||
由条件概率的定义，可直接得出下面的乘法公式：
|
||||
乘法公式 设$A, B$是两个事件，并且$P(A) > 0$, 则有 $$P(AB) = P(B|A)P(A)$$
|
||||
推广 $$P(ABC)=P(C|AB)P(B)P(B|A)P(A)$$
|
||||
一般地，用归纳法可证：若$P(A\_1A\_2...A\_n)>0$，则有$$P(A\_1A\_2...A\_n)=P(A\_n|A\_1A\_2...A\_{n-1}P(A\_{n-1}|A\_1A\_2...A\_{n-2})...P(A\_2|A\_1)P(A_1)$$
|
||||
乘法公式 设$A, B$是两个事件，并且$P(A) > 0$, 则有
|
||||
$$
|
||||
P(AB) = P(B|A)P(A)
|
||||
$$
|
||||
推广
|
||||
$$
|
||||
P(ABC)=P(C|AB)P(B)P(B|A)P(A)
|
||||
$$
|
||||
一般地，用归纳法可证：若$P(A_1A_2...A_n)>0$，则有
|
||||
$$
|
||||
P(A_1A_2...A_n)=P(A_n|A_1A_2...A_{n-1}P(A_{n-1}|A_1A_2...A_{n-2})...P(A_2|A_1)P(A_1)
|
||||
$$
|
||||
任何多维随机变量联合概率分布，都可以分解成只有一个变量的条件概率相乘形式。
|
||||
|
||||
## 1.16 独立性和条件独立性
|
||||
**独立性**
|
||||
两个随机变量$x$和$y$，概率分布表示成两个因子乘积形式，一个因子只包含$x$，另一个因子只包含$y$，两个随机变量相互独立(independent)。
|
||||
条件有时为不独立的事件之间带来独立，有时也会把本来独立的事件，因为此条件的存在，而失去独立性。
|
||||
举例：$P(XY)=P(X)P(Y)$, 事件$X$和事件$Y$独立。此时给定$Z$，$$P(X,Y|Z) \not = P(X|Z)P(Y|Z)$$
|
||||
举例：$P(XY)=P(X)P(Y)$, 事件$X$和事件$Y$独立。此时给定$Z$，
|
||||
$$
|
||||
P(X,Y|Z) \not = P(X|Z)P(Y|Z)
|
||||
$$
|
||||
事件独立时，联合概率等于概率的乘积。这是一个非常好的数学性质，然而不幸的是，无条件的独立是十分稀少的，因为大部分情况下，事件之间都是互相影响的。
|
||||
|
||||
**条件独立性**
|
||||
给定$Z$的情况下,$X$和$Y$条件独立，当且仅当$$X\bot Y|Z \iff P(X,Y|Z) = P(X|Z)P(Y|Z)$$
|
||||
给定$Z$的情况下,$X$和$Y$条件独立，当且仅当
|
||||
$$
|
||||
X\bot Y|Z \iff P(X,Y|Z) = P(X|Z)P(Y|Z)
|
||||
$$
|
||||
$X$和$Y$的关系依赖于$Z$，而不是直接产生。
|
||||
|
||||
**举例**定义如下事件：
|
||||
$X$：明天下雨；
|
||||
$Y$：今天的地面是湿的；
|
||||
$Z$：今天是否下雨；
|
||||
$Z$事件的成立，对$X$和$Y$均有影响，然而，在$Z$事件成立的前提下，今天的地面情况对明天是否下雨没有影响。
|
||||
|
||||
## 1.17期望、方差、协方差、相关系数总结
|
||||
(http://www.360doc.com/content/13/1124/03/9482_331690142.shtml)
|
||||
|
||||
**期望**
|
||||
在概率论和统计学中，数学期望（或均值，亦简称期望）是试验中每次可能结果的概率乘以其结果的总和。它反映随机变量平均取值的大小。
|
||||
线性运算： $E(ax+by+c) = aE(x)+bE(y)+c$
|
||||
推广形式： $E(\sum\_{k=1}^{n}{a\_ix\_i+c}) = \sum\_{k=1}^{n}{a\_iE(x\_i)x\_i+c}$
|
||||
函数期望：设$f(x)$为$x$的函数，则$f(x)$的期望
|
||||
离散函数： $E(f(x))=\sum\_{k=1}^{n}{f(x\_k)P(x\_k)}$
|
||||
连续函数： $E(f(x))=\int_{-\infty}^{+\infty}{f(x)p(x)dx}$
|
||||
注意：函数的期望不等于期望的函数，即$E(f(x))=f(E(x))$
|
||||
一般情况下，乘积的期望不等于期望的乘积。
|
||||
如果$X$和$Y$相互独立，则$E(xy)=E(x)E(y)$。
|
||||
推广形式： $E(\sum_{k=1}^{n}{a_ix_i+c}) = \sum_{k=1}^{n}{a_iE(x_i)x_i+c}$
|
||||
函数期望：设$f(x)$为$x$的函数，则$f(x)$的期望为
|
||||
- 离散函数： $E(f(x))=\sum_{k=1}^{n}{f(x_k)P(x_k)}$
|
||||
- 连续函数： $E(f(x))=\int_{-\infty}^{+\infty}{f(x)p(x)dx}$
|
||||
|
||||
注意：函数的期望不等于期望的函数，即$E(f(x))=f(E(x))$
|
||||
一般情况下，乘积的期望不等于期望的乘积。
|
||||
如果$X$和$Y$相互独立，则$E(xy)=E(x)E(y)$。
|
||||
**方差**
|
||||
概率论中方差用来度量随机变量和其数学期望（即均值）之间的偏离程度。
|
||||
方差是一种特殊的期望。定义为： $$Var(x) = E((x-E(x))^2)$$
|
||||
|
||||
方差是一种特殊的期望。定义为：
|
||||
$$
|
||||
Var(x) = E((x-E(x))^2)
|
||||
$$
|
||||
方差性质：
|
||||
1. $Var(x) = E(x^2) -E(x)^2$
|
||||
2. 常数的方差为0;
|
||||
3. 方差不满足线性性质;
|
||||
4. 如果$X$和$Y$相互独立, $Var(ax+by)=Var(x)+Var(y)$
|
||||
|
||||
1）$Var(x) = E(x^2) -E(x)^2$
|
||||
2） 常数的方差为0;
|
||||
3）方差不满足线性性质;
|
||||
4）如果$X$和$Y$相互独立, $Var(ax+by)=Var(x)+Var(y)$
|
||||
**协方差**
|
||||
协方差是衡量两个变量线性相关性强度及变量尺度。
|
||||
两个随机变量的协方差定义为：$$Cov(x,y)=E((x-E(x))(y-E(y)))$$
|
||||
两个随机变量的协方差定义为：
|
||||
$$
|
||||
Cov(x,y)=E((x-E(x))(y-E(y)))
|
||||
$$
|
||||
方差是一种特殊的协方差。当$X=Y$时，$Cov(x,y)=Var(x)=Var(y)$。
|
||||
协方差性质：
|
||||
1) 独立变量的协方差为0。
|
||||
2) 协方差计算公式：$$Cov(\sum\_{i=1}^{m}{a\_ix\_i}, \sum\_{j=1}^{m}{b\_jy\_j}) = \sum\_{i=1}^{m} \sum\_{j=1}^{m}{a\_ib\_jCov(x\_iy\_i)}$$
|
||||
3) 特殊情况: $$Cov(a+bx, c+dy) = bdCov(x, y)$$
|
||||
2) 协方差计算公式：
|
||||
$$
|
||||
Cov(\sum_{i=1}^{m}{a_ix_i}, \sum_{j=1}^{m}{b_jy_j}) = \sum_{i=1}^{m} \sum_{j=1}^{m}{a_ib_jCov(x_iy_i)}
|
||||
$$
|
||||
3) 特殊情况:
|
||||
$$
|
||||
Cov(a+bx, c+dy) = bdCov(x, y)
|
||||
$$
|
||||
**相关系数**
|
||||
相关系数是研究变量之间线性相关程度的量。
|
||||
两个随机变量的相关系数定义为： $$Corr(x,y) = \frac{Cov(x,y)}{\sqrt{Var(x)Var(y)}}$$
|
||||
两个随机变量的相关系数定义为：
|
||||
$$
|
||||
Corr(x,y) = \frac{Cov(x,y)}{\sqrt{Var(x)Var(y)}}
|
||||
$$
|
||||
性质：
|
||||
1) 有界性。相关系数的取值范围是 ，可以看成无量纲的协方差。
|
||||
2) 值越接近1，说明两个变量正相关性（线性）越强。越接近-1，说明负相关性越强，当为0时，表示两个变量没有相关性。
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
|
|
|||
|
|
@ -0,0 +1 @@
|
|||
待提出
|
||||
|
|
@ -128,7 +128,8 @@ http://mini.eastday.com/mobile/180116023302833.html
|
|||
|
||||
|
||||
|
||||
2. 梯度爆炸；
|
||||
2. 梯度爆炸
|
||||
又称exploding gradient problem，在深度网络或循环神经网络（RNN）等网络结构中，梯度可在网络更新的过程中不断累积，变成非常大的梯度，导致网络权重值的大幅更新，使得网络不稳定；在极端情况下，权重值甚至会溢出，变为NaN值，再也无法更新。 具体可参考文献https://machinelearningmastery.com/exploding-gradients-in-neural-networks/ ；
|
||||
|
||||
3. 权重矩阵的退化导致模型的有效自由度减少。参数空间中学习的退化速度减慢，导致减少了模型的有效维数，网络的可用自由度对学习中梯度范数的贡献不均衡，随着相乘矩阵的数量（即网络深度）的增加，矩阵的乘积变得越来越退化；
|
||||
|
||||
|
|
@ -401,6 +402,11 @@ $$
|
|||
|
||||
来源：[一文弄懂神经网络中的反向传播法——BackPropagation](http://www.cnblogs.com/charlotte77/p/5629865.html)
|
||||
|
||||
### 3.2.6 了解神经网络知识的读者可能会有一个疑问，具有一个隐藏层的人工神经网络已经非常强大了，理论上来说，只要神经元足够多，构成一个很“宽”的网络，它就可以拟合任意的函数，那为什么还要更“深”呢？（贡献者：黄钦建－华南理工大学）
|
||||
|
||||
原因在于：在神经元数量相同的情况下，深层网络结构具有更大的容量，分层组合带来的是指数级的表达空间，能够组合成更多不同类型的子结构，这样可以更容易地学习和表示各种特征。并且，隐藏层增加则意味着由激活函数带来的非线性变换的嵌套层数更多，就能构造更复杂的映射关系。
|
||||
|
||||
|
||||
## 3.3 超参数
|
||||
|
||||
### 3.3.1 什么是超参数？
|
||||
|
|
@ -577,6 +583,50 @@ $$
|
|||
|
||||
softmax 直白来说就是将原来输出是 $ 3,1,-3 $ 通过 softmax 函数一作用，就映射成为 $ (0,1) $ 的值，而这些值的累和为 $ 1 $（满足概率的性质），那么我们就可以将它理解成概率，在最后选取输出结点的时候，我们就可以选取概率最大（也就是值对应最大的）结点，作为我们的预测目标！
|
||||
|
||||
### 3.4.10 交叉熵代价函数定义及其求导推导。（贡献者：黄钦建－华南理工大学）
|
||||
|
||||
|
||||
神经元的输出就是 a = σ(z)，其中$z=\sum w_{j}i_{j}+b$是输⼊的带权和。
|
||||
|
||||
$C=-\frac{1}{n}\sum[ylna+(1-y)ln(1-a)]$
|
||||
|
||||
其中 n 是训练数据的总数，求和是在所有的训练输⼊ x 上进⾏的， y 是对应的⽬标输出。
|
||||
|
||||
表达式是否解决学习缓慢的问题并不明显。实际上，甚⾄将这个定义看做是代价函数也不是显⽽易⻅的！在解决学习缓慢前，我们来看看交叉熵为何能够解释成⼀个代价函数。
|
||||
|
||||
将交叉熵看做是代价函数有两点原因。
|
||||
|
||||
第⼀，它是⾮负的， C > 0。可以看出：式子中的求和中的所有独⽴的项都是负数的，因为对数函数的定义域是 (0，1)，并且求和前⾯有⼀个负号，所以结果是非负。
|
||||
|
||||
第⼆，如果对于所有的训练输⼊ x，神经元实际的输出接近⽬标值，那么交叉熵将接近 0。
|
||||
|
||||
假设在这个例⼦中， y = 0 ⽽ a ≈ 0。这是我们想到得到的结果。我们看到公式中第⼀个项就消去了，因为 y = 0，⽽第⼆项实际上就是 − ln(1 − a) ≈ 0。反之， y = 1 ⽽ a ≈ 1。所以在实际输出和⽬标输出之间的差距越⼩，最终的交叉熵的值就越低了。（这里假设输出结果不是0，就是1，实际分类也是这样的）
|
||||
|
||||
综上所述，交叉熵是⾮负的，在神经元达到很好的正确率的时候会接近 0。这些其实就是我们想要的代价函数的特性。其实这些特性也是⼆次代价函数具备的。所以，交叉熵就是很好的选择了。但是交叉熵代价函数有⼀个⽐⼆次代价函数更好的特性就是它避免了学习速度下降的问题。为了弄清楚这个情况，我们来算算交叉熵函数关于权重的偏导数。我们将$a={\varsigma}(z)$代⼊到 公式中应⽤两次链式法则，得到：
|
||||
|
||||
$\begin{eqnarray}\frac{\partial C}{\partial w_{j}}&=&-\frac{1}{n}\sum \frac{\partial }{\partial w_{j}}[ylna+(1-y)ln(1-a)]\\&=&-\frac{1}{n}\sum \frac{\partial }{\partial a}[ylna+(1-y)ln(1-a)]*\frac{\partial a}{\partial w_{j}}\\&=&-\frac{1}{n}\sum (\frac{y}{a}-\frac{1-y}{1-a})*\frac{\partial a}{\partial w_{j}}\\&=&-\frac{1}{n}\sum (\frac{y}{\varsigma(z)}-\frac{1-y}{1-\varsigma(z)})\frac{\partial \varsigma(z)}{\partial w_{j}}\\&=&-\frac{1}{n}\sum (\frac{y}{\varsigma(z)}-\frac{1-y}{1-\varsigma(z)}){\varsigma}'(z)x_{j}\end{eqnarray}$
|
||||
|
||||
根据$\varsigma(z)=\frac{1}{1+e^{-z}}$ 的定义，和⼀些运算，我们可以得到 ${\varsigma}'(z)=\varsigma(z)(1-\varsigma(z))$。化简后可得：
|
||||
|
||||
$\frac{\partial C}{\partial w_{j}}=\frac{1}{n}\sum x_{j}({\varsigma}(z)-y)$
|
||||
|
||||
这是⼀个优美的公式。它告诉我们权重学习的速度受到$\varsigma(z)-y$，也就是输出中的误差的控制。更⼤的误差，更快的学习速度。这是我们直觉上期待的结果。特别地，这个代价函数还避免了像在⼆次代价函数中类似⽅程中${\varsigma}'(z)$导致的学习缓慢。当我们使⽤交叉熵的时候，${\varsigma}'(z)$被约掉了，所以我们不再需要关⼼它是不是变得很⼩。这种约除就是交叉熵带来的特效。实际上，这也并不是⾮常奇迹的事情。我们在后⾯可以看到，交叉熵其实只是满⾜这种特性的⼀种选择罢了。
|
||||
|
||||
根据类似的⽅法，我们可以计算出关于偏置的偏导数。我这⾥不再给出详细的过程，你可以轻易验证得到：
|
||||
|
||||
$\frac{\partial C}{\partial b}=\frac{1}{n}\sum ({\varsigma}(z)-y)$
|
||||
|
||||
|
||||
再⼀次, 这避免了⼆次代价函数中类似${\varsigma}'(z)$项导致的学习缓慢。
|
||||
|
||||
### 3.4.11 为什么Tanh收敛速度比Sigmoid快？（贡献者：黄钦建－华南理工大学）
|
||||
|
||||
`$tanh^{,}(x)=1-tanh(x)^{2}\in (0,1)$`
|
||||
|
||||
`$s^{,}(x)=s(x)*(1-s(x))\in (0,\frac{1}{4}]$`
|
||||
|
||||
由上面两个公式可知tanh(x)梯度消失的问题比sigmoid轻，所以Tanh收敛速度比Sigmoid快。
|
||||
|
||||
## 3.5 Batch_Size
|
||||
|
||||
### 3.5.1 为什么需要 Batch_Size？
|
||||
|
|
@ -789,6 +839,13 @@ Weight Normalization 和 Batch Normalization 都属于参数重写（Reparameter
|
|||
|
||||
不需要额外的存储空间来保存 mini batch 的均值和方差，同时实现 Weight Normalization 时，对深度学习网络进行正向信号传播和反向梯度计算带来的额外计算开销也很小。因此，要比采用 Batch Normalization 进行 normalization 操作时，速度快。 但是 Weight Normalization 不具备 Batch Normalization 把网络每一层的输出 Y 固定在一个变化范围的作用。因此，采用 Weight Normalization 进行 Normalization 时需要特别注意参数初始值的选择。
|
||||
|
||||
### 3.6.13 Batch Normalization在什么时候用比较合适？（贡献者：黄钦建－华南理工大学）
|
||||
|
||||
在CNN中，BN应作用在非线性映射前。在神经网络训练时遇到收敛速度很慢，或梯度爆炸等无法训练的状况时可以尝试BN来解决。另外，在一般使用情况下也可以加入BN来加快训练速度，提高模型精度。
|
||||
|
||||
BN比较适用的场景是：每个mini-batch比较大，数据分布比较接近。在进行训练之前，要做好充分的shuffle，否则效果会差很多。另外，由于BN需要在运行过程中统计每个mini-batch的一阶统计量和二阶统计量，因此不适用于动态的网络结构和RNN网络。
|
||||
|
||||
|
||||
## 3.7 预训练与微调(fine tuning)
|
||||
|
||||
### 3.7.1 为什么无监督预训练可以帮助深度学习？
|
||||
|
|
@ -1007,4 +1064,48 @@ tf.train.RMSPropOptimizer
|
|||
5. dropout 自己虽然也很牛，但是 dropout、max-normalization、large decaying learning rates and high momentum 组合起来效果更好，比如 max-norm regularization 就可以防止大的learning rate 导致的参数 blow up。
|
||||
6. 使用 pretraining 方法也可以帮助 dropout 训练参数，在使用 dropout 时，要将所有参数都乘以 $ 1/p $。
|
||||
|
||||
|
||||
## 3.13 深度学习中常用的数据增强方法（Data Augmentation）？（贡献者：黄钦建－华南理工大学）
|
||||
|
||||
- Color Jittering：对颜色的数据增强：图像亮度、饱和度、对比度变化（此处对色彩抖动的理解不知是否得当）；
|
||||
|
||||
- PCA Jittering：首先按照RGB三个颜色通道计算均值和标准差，再在整个训练集上计算协方差矩阵，进行特征分解，得到特征向量和特征值，用来做PCA Jittering；
|
||||
|
||||
- Random Scale：尺度变换；
|
||||
|
||||
- Random Crop：采用随机图像差值方式，对图像进行裁剪、缩放；包括Scale Jittering方法（VGG及ResNet模型使用）或者尺度和长宽比增强变换；
|
||||
|
||||
- Horizontal/Vertical Flip：水平/垂直翻转；
|
||||
|
||||
- Shift：平移变换；
|
||||
|
||||
- Rotation/Reflection：旋转/仿射变换；
|
||||
|
||||
- Noise：高斯噪声、模糊处理；
|
||||
|
||||
- Label Shuffle：类别不平衡数据的增广；
|
||||
|
||||
## 3.14 请解释深度学习中的 Internal Covariate Shift的意思？（贡献者：黄钦建－华南理工大学）
|
||||
|
||||
深度神经网络模型的训练为什么会很困难？其中一个重要的原因是，深度神经网络涉及到很多层的叠加，而每一层的参数更新会导致上层的输入数据分布发生变化，通过层层叠加，高层的输入分布变化会非常剧烈，这就使得高层需要不断去重新适应底层的参数更新。为了训好模型，我们需要非常谨慎地去设定学习率、初始化权重、以及尽可能细致的参数更新策略。
|
||||
|
||||
Google 将这一现象总结为 Internal Covariate Shift，简称 ICS。 什么是 ICS 呢？
|
||||
|
||||
大家都知道在统计机器学习中的一个经典假设是“源空间（source domain）和目标空间（target domain）的数据分布（distribution）是一致的”。如果不一致，那么就出现了新的机器学习问题，如 transfer learning / domain adaptation 等。而 covariate shift 就是分布不一致假设之下的一个分支问题，它是指源空间和目标空间的条件概率是一致的，但是其边缘概率不同。
|
||||
|
||||
大家细想便会发现，的确，对于神经网络的各层输出，由于它们经过了层内操作作用，其分布显然与各层对应的输入信号分布不同，而且差异会随着网络深度增大而增大，可是它们所能“指示”的样本标记（label）仍然是不变的，这便符合了covariate shift的定义。由于是对层间信号的分析，也即是“internal”的来由。
|
||||
|
||||
|
||||
**那么ICS会导致什么问题？**
|
||||
|
||||
简而言之，每个神经元的输入数据不再是“独立同分布”。
|
||||
|
||||
其一，上层参数需要不断适应新的输入数据分布，降低学习速度。
|
||||
|
||||
其二，下层输入的变化可能趋向于变大或者变小，导致上层落入饱和区，使得学习过早停止。
|
||||
|
||||
其三，每层的更新都会影响到其它层，因此每层的参数更新策略需要尽可能的谨慎。
|
||||
|
||||
## 3.27 Padding 系列问题
|
||||
|
||||
## 3.
|
||||
|
|
|
|||
|
|
@ -1,11 +1,12 @@
|
|||
#############################################################
|
||||
## 深度学习500问-Tan-08第八章 图像分割(md版本)
|
||||
#########################################################
|
||||
### 深度学习500问-第九章 图像分割(md版本）
|
||||
作者：scutan90
|
||||
编辑者：shw2018（UESTC_孙洪卫_硕）
|
||||
时间：2018.10.25
|
||||
#############################################################
|
||||
编辑者：shw2018（UESTC_孙洪卫_硕，Wechat：sunhwee）
|
||||
提交：2018.10.25
|
||||
更新：2018.10.28
|
||||
#########################################################
|
||||
|
||||
# **第八章 图像分割**
|
||||
# **第九章 图像分割**
|
||||
|
||||
## **8.1 传统的基于CNN的分割方法缺点？**
|
||||
  
|
||||
|
|
@ -219,6 +220,7 @@ learning rate：0.001。
|
|||
  
|
||||
在这篇论文，我们建立了一个更好全卷积方法。我们定义和扩展了这个方法它使用更少的训练图片但产生更精确的分割。
|
||||
<center><img src="../img/ch8/figure_8.2_1.png"></center>
|
||||
|
||||
  
|
||||
(1) 使用全卷积神经网络。(全卷积神经网络就是卷积取代了全连接层，全连接层必须固定图像大小而卷积不用，所以这个策略使得，你可以输入任意尺寸的图片，而且输出也是图片，所以这是一个端到端的网络。)
|
||||
  
|
||||
|
|
@ -230,6 +232,77 @@ learning rate：0.001。
|
|||
  
|
||||
(4) 最后再经过两次卷积，达到最后的heatmap，再用一个1X1的卷积做分类，这里是分成两类，所以用的是两个神经元做卷积，得到最后的两张heatmap,例如第一张表示的是第一类的得分（即每个像素点对应第一类都有一个得分），第二张表示第二类的得分heatmap,然后作为softmax函数的输入，算出概率比较大的softmax类，选择它作为输入给交叉熵进行反向传播训练。
|
||||
|
||||
## 下面是U-Net模型的代码实现：（贡献者：黄钦建－华南理工大学）
|
||||
|
||||
```
|
||||
def get_unet():
|
||||
inputs = Input((img_rows, img_cols, 1))
|
||||
conv1 = Conv2D(32, (3, 3), activation='relu', padding='same')(inputs)
|
||||
conv1 = Conv2D(32, (3, 3), activation='relu', padding='same')(conv1)
|
||||
pool1 = MaxPooling2D(pool_size=(2, 2))(conv1)
|
||||
# pool1 = Dropout(0.25)(pool1)
|
||||
# pool1 = BatchNormalization()(pool1)
|
||||
|
||||
conv2 = Conv2D(64, (3, 3), activation='relu', padding='same')(pool1)
|
||||
conv2 = Conv2D(64, (3, 3), activation='relu', padding='same')(conv2)
|
||||
pool2 = MaxPooling2D(pool_size=(2, 2))(conv2)
|
||||
# pool2 = Dropout(0.5)(pool2)
|
||||
# pool2 = BatchNormalization()(pool2)
|
||||
|
||||
conv3 = Conv2D(128, (3, 3), activation='relu', padding='same')(pool2)
|
||||
conv3 = Conv2D(128, (3, 3), activation='relu', padding='same')(conv3)
|
||||
pool3 = MaxPooling2D(pool_size=(2, 2))(conv3)
|
||||
# pool3 = Dropout(0.5)(pool3)
|
||||
# pool3 = BatchNormalization()(pool3)
|
||||
|
||||
conv4 = Conv2D(256, (3, 3), activation='relu', padding='same')(pool3)
|
||||
conv4 = Conv2D(256, (3, 3), activation='relu', padding='same')(conv4)
|
||||
pool4 = MaxPooling2D(pool_size=(2, 2))(conv4)
|
||||
# pool4 = Dropout(0.5)(pool4)
|
||||
# pool4 = BatchNormalization()(pool4)
|
||||
|
||||
conv5 = Conv2D(512, (3, 3), activation='relu', padding='same')(pool4)
|
||||
conv5 = Conv2D(512, (3, 3), activation='relu', padding='same')(conv5)
|
||||
|
||||
up6 = concatenate([Conv2DTranspose(256, (2, 2), strides=(
|
||||
2, 2), padding='same')(conv5), conv4], axis=3)
|
||||
# up6 = Dropout(0.5)(up6)
|
||||
# up6 = BatchNormalization()(up6)
|
||||
conv6 = Conv2D(256, (3, 3), activation='relu', padding='same')(up6)
|
||||
conv6 = Conv2D(256, (3, 3), activation='relu', padding='same')(conv6)
|
||||
|
||||
up7 = concatenate([Conv2DTranspose(128, (2, 2), strides=(
|
||||
2, 2), padding='same')(conv6), conv3], axis=3)
|
||||
# up7 = Dropout(0.5)(up7)
|
||||
# up7 = BatchNormalization()(up7)
|
||||
conv7 = Conv2D(128, (3, 3), activation='relu', padding='same')(up7)
|
||||
conv7 = Conv2D(128, (3, 3), activation='relu', padding='same')(conv7)
|
||||
|
||||
up8 = concatenate([Conv2DTranspose(64, (2, 2), strides=(
|
||||
2, 2), padding='same')(conv7), conv2], axis=3)
|
||||
# up8 = Dropout(0.5)(up8)
|
||||
# up8 = BatchNormalization()(up8)
|
||||
conv8 = Conv2D(64, (3, 3), activation='relu', padding='same')(up8)
|
||||
conv8 = Conv2D(64, (3, 3), activation='relu', padding='same')(conv8)
|
||||
|
||||
up9 = concatenate([Conv2DTranspose(32, (2, 2), strides=(
|
||||
2, 2), padding='same')(conv8), conv1], axis=3)
|
||||
# up9 = Dropout(0.5)(up9)
|
||||
# up9 = BatchNormalization()(up9)
|
||||
conv9 = Conv2D(32, (3, 3), activation='relu', padding='same')(up9)
|
||||
conv9 = Conv2D(32, (3, 3), activation='relu', padding='same')(conv9)
|
||||
|
||||
# conv9 = Dropout(0.5)(conv9)
|
||||
|
||||
conv10 = Conv2D(1, (1, 1), activation='sigmoid')(conv9)
|
||||
|
||||
model = Model(inputs=[inputs], outputs=[conv10])
|
||||
|
||||
model.compile(optimizer=Adam(lr=1e-5),
|
||||
loss=dice_coef_loss, metrics=[dice_coef])
|
||||
|
||||
return model
|
||||
```
|
||||
|
||||
## **8.3 SegNet**
|
||||
  
|
||||
|
|
@ -245,6 +318,7 @@ learning rate：0.001。
|
|||
  
|
||||
SegNet网络的结构如下图所示：
|
||||
<center><img src="../img/ch8/figure_8.3_1.jpg"></center>
|
||||
|
||||
  
|
||||
SegNet网络结构如图1所示，Input为输入图片，Output为输出分割的图像，不同颜色代表不同的分类。语义分割的重要性就在于不仅告诉你图片中某个东西是什么，而且告知你他在图片的位置。我们可以看到是一个对称网络，由中间绿色pooling层与红色upsampling层作为分割，左边是卷积提取高维特征，并通过pooling使图片变小，SegNet作者称为Encoder，右边是反卷积（在这里反卷积与卷积没有区别）与upsampling，通过反卷积使得图像分类后特征得以重现，upsampling使图像变大，SegNet作者称为Decoder，最后通过Softmax，输出不同分类的最大值。这就是大致的SegNet过程，下面对这个过程里面使用到的方法进行介绍。
|
||||
  
|
||||
|
|
@ -252,6 +326,7 @@ SegNet网络结构如图1所示，Input为输入图片，Output为输出分割
|
|||
  
|
||||
SegNet解码技术如下图所示：
|
||||
<center><img src="../img/ch8/figure_8.3_2.jpg"></center>
|
||||
|
||||
  
|
||||
解码网络使用保存的最大池化索引上采样，得到稀疏的特征图，将特征图与可训练的解码滤波器族卷积得到致密的特征图。之后进行BN。高维的特征图输入soft-max层，对每个像素进行分类，得到每个像素属于K类的概率。 图3中右边是FCN的解码技术，FCN对编码的特征图进行降维，降维后输入到解码网络，解码网络中，上采样使用反卷积实现，上采样的特征图与降维的编码图进行element-wise add得到最终的解码特征图。FCN解码模型需要存储编码特征图，在嵌入式设备中内存紧张。
|
||||
  
|
||||
|
|
@ -276,6 +351,7 @@ SegNet的Encoder过程中，卷积的作用是提取特征，SegNet使用的卷
|
|||
  
|
||||
下面看一下dilated conv原始论文[4]中的示意图
|
||||
<center><img src="../img/ch8/figure_8.3_4.jpg"></center>
|
||||
|
||||
  
|
||||
(a) 图对应3x3的1-dilated conv，和普通的卷积操作一样，(b)图对应3x3的2-dilated conv，实际的卷积kernel size还是3x3，但是空洞为1，也就是对于一个7x7的图像patch，只有9个红色的点和3x3的kernel发生卷积操作，其余的点略过。也可以理解为kernel的size为7x7，但是只有图中的9个点的权重不为0，其余都为0。 可以看到虽然kernel size只有3x3，但是这个卷积的感受野已经增大到了7x7（如果考虑到这个2-dilated conv的前一层是一个1-dilated conv的话，那么每个红点就是1-dilated的卷积输出，所以感受野为3x3，所以1-dilated和2-dilated合起来就能达到7x7的conv）,(c)图是4-dilated conv操作，同理跟在两个1-dilated和2-dilated conv的后面，能达到15x15的感受野。对比传统的conv操作，3层3x3的卷积加起来，stride为1的话，只能达到(kernel-1) * layer+1=7的感受野，也就是和层数layer成线性关系，而dilated conv的感受野是指数级的增长。
|
||||
  
|
||||
|
|
@ -291,11 +367,13 @@ RefineNet block的作用就是把不同resolution level的feature map进行融
|
|||
  
|
||||
最左边一栏就是FCN的encoder部分(文中是用的ResNet)，先把pretrained ResNet按feature map的分辨率分成四个ResNet blocks，然后向右把四个blocks分别作为4个path通过RefineNet block进行融合refine，最后得到一个refined feature map(接softmax再双线性插值输出)。
|
||||
注意除了RefineNet-4，所有的RefineNet block都是二输入的，用于融合不同level做refine，而单输入的RefineNet-4可以看作是先对ResNet的一个task adaptation。
|
||||
|
||||
  
|
||||
**RefineNet Block**
|
||||
  
|
||||
接下来仔细看一下RefineNet block，可以看到主要组成部分是Residual convolution unit, Multi-resolution fusion, Chained residual pooling, Output convolutions. 切记这个block作用是融合多个level的feature map输出单个level的feature map，但具体的实现应该是和输入个数、shape无关的。
|
||||
<center><img src="../img/ch8/figure_8.4_2.png"></center>
|
||||
|
||||
  
|
||||
Residual convolution unit就是普通的去除了BN的residual unit；
|
||||
  
|
||||
|
|
@ -316,6 +394,7 @@ Output convolutions就是输出前再加一个RCU。
|
|||
<center><img src="../img/ch8/figure_8.6_1.png"></center>
|
||||
  
|
||||
FCN认为右侧框中是汽车，但是实际上是船，如果参考上下文的先验知识，就会发现左边是一个船屋，进而推断是框中是船.FCN存在的主要问题就是不能利用好全局的场景线索。
|
||||
|
||||
  
|
||||
对于尤其复杂的场景理解，之前都是采用空间金字塔池化来做的，和之前方法不同（为什么不同，需要参考一下经典的金字塔算法），本文提出了pyramid scene parsing network(PSPNet)。
|
||||
  
|
||||
|
|
@ -382,6 +461,7 @@ DCNN 的分类不变形影响空间精度。DeepLabv2 是采样全连接的 CRF
|
|||
  
|
||||
DeepLabv3 论文比较了多种捕获多尺度信息的方式：
|
||||
<center><img src="../img/ch8/figure_8.6_4.png"></center>
|
||||
|
||||
  
|
||||
1.Image Pyramid：将输入图片放缩成不同比例，分别应用在 DCNN 上，将预测结果融合得到最终输出。
|
||||
  
|
||||
|
|
@ -410,6 +490,7 @@ deeplab V3新设计的aspp结构解决了问题1，deeplab v3+主要目的在于
|
|||
  
|
||||
解决方案：1、编解码器结构。2 Modified Aligned Xception
|
||||
<center><img src="../img/ch8/figure_8.6_5.png"></center>
|
||||
|
||||
  
|
||||
在deeplabv3 基础上 加入解码器。 A是aspp结构。 A的8*的上采样可以看做是一个naïve的解码器。 B是编解码结构。集合了高层和底层的feature。 C就是本文采取的结构。Conv2（图中红色）的提取到结果和最后提取出的feature上采样4后融合。
|
||||
  
|
||||
|
|
@ -417,17 +498,19 @@ deeplab V3新设计的aspp结构解决了问题1，deeplab v3+主要目的在于
|
|||
  
|
||||
（1）Encoder-Decoder with Atrous Convolution
|
||||
<center><img src="../img/ch8/figure_8.6_6.png"></center>
|
||||
|
||||
  
|
||||
编码器采用deeplabv3。
|
||||
  
|
||||
解码器部分：先从低层级选一个feature，将低层级的feature用1 * 1的卷积进行通道压缩（原本为256通道，或者512通道），目的在于减少低层级的比重。作者认为编码器得到的feature具有更丰富的信息，所以编码器的feature应该有更高的比重。 这样做有利于训练。
|
||||
  
|
||||
再将编码器的输出上采样，使其分辨率与低层级feature一致。 举个例子，如果采用resnet conv2 输出的feature，则这里要*4上采样。 将两种feature 连接后，再进行一次3*3的卷积（细化作用），然后再次上采样就得到了像素级的预测。 后面的实验结果表明这种结构在stride=16时既有很高的精度速度又很快。stride=8相对来说只获得了一点点精度的提升，但增加了很多的计算量。
|
||||
再将编码器的输出上采样，使其分辨率与低层级feature一致。 举个例子，如果采用resnet conv2 输出的feature，则这里要* 4上采样。 将两种feature 连接后，再进行一次3 * 3的卷积（细化作用），然后再次上采样就得到了像素级的预测。 后面的实验结果表明这种结构在 stride=16 时既有很高的精度速度又很快。stride=8相对来说只获得了一点点精度的提升，但增加了很多的计算量。
|
||||
  
|
||||
（2）Modified Aligned Xception
|
||||
  
|
||||
Xception 主要采用了deepwish seperable convolution来替换原来的卷积层。简单的说就是这种结构能在更少参数更少计算量的情况下学到同样的信息。这边则是考虑将原来的resnet-101骨架网换成xception。
|
||||
<center><img src="../img/ch8/figure_8.6_7.png"></center>
|
||||
|
||||
  
|
||||
红色部分为修改
|
||||
  
|
||||
|
|
@ -483,11 +566,11 @@ PS： 虽然 Misalignment 在分类问题上影响并不大，但在 Pixel 级
|
|||
  
|
||||
**3.技术要点3 - Loss Function**
|
||||
  
|
||||
每个 ROIAlign 对应 K * m^2 维度的输出。K 对应类别个数，即输出 K 个mask，m对应 池化分辨率（7*7）。Loss 函数定义：
|
||||
每个 ROIAlign 对应 K * m^2 维度的输出。K 对应类别个数，即输出 K 个mask，m对应 池化分辨率（7 * 7）。Loss 函数定义：
|
||||
$$
|
||||
Lmask(Cls_k)=Sigmoid(Cls_k)
|
||||
$$
|
||||
  
|
||||
  
|
||||
$Lmask(Cls_k) = Sigmoid (Cls_k)$，平均二值交叉熵 （average binary cross-entropy）Loss，通过逐像素的 Sigmoid 计算得到。
|
||||
  
|
||||
Why K个mask？通过对每个 Class 对应一个 Mask 可以有效避免类间竞争（其他 Class 不贡献 Loss ）。
|
||||
|
|
@ -548,10 +631,10 @@ UC Berkeley的Deepak Pathak 使用了一个具有图像级别标记的训练数
|
|||
  
|
||||
该方法把训练过程看作是有线性限制条件的最优化过程：
|
||||
$$
|
||||
\underset{\theta, P}{minimize} \;\;\;\;\;\;\;\;\;\;D(P(X)||Q(X|\theta))
|
||||
\underset{\theta, P}{minimize} \;\;\;\;\;\;\;\;\;\;\;D(P(X)||Q(X|\theta))
|
||||
$$
|
||||
$$
|
||||
subject \, \,to \, \, \,\, \, \, \, \, A\vec{P}\geq \vec{b,} \, \, \,\, \, \, \, \,\sum_x P\left(X \right )=1.
|
||||
subject \, \,to \, \, \,\, A\vec{P}\geq \vec{b,} \, \, \,\, \, \, \, \,\sum_x P\left(X \right )=1.
|
||||
$$
|
||||
  
|
||||
其中 是一个隐含的类别分布， 是CNN预测的类别分布。目标函数是KL-divergence最小化。其中的线性限制条件来自于训练数据上的标记，例如一幅图像中前景类别像素个数期望值的上界或者下界（物体大小）、某个类别的像素个数在某图像中为0，或者至少为1等。该目标函数可以转化为为一个loss function，然后通过SGD进行训练。
|
||||
|
|
@ -559,7 +642,6 @@ $$
|
|||
  
|
||||
实验中发现单纯使用Image tags作为限制条件得到的分割结果还比较差，在PASCAL VOC 2012 test数据集上得到的mIoU为35.6%，加上物体大小的限制条件后能达到45.1%， 如果再使用bounding box做限制，可以达到54%。FCN-8s可以达到62.2%，可见弱监督学习要取得好的结果还是比较难。
|
||||
|
||||
|
||||
**8.9.3 DeepLab+bounding box+image-level labels**
|
||||
|
||||
  
|
||||
|
|
@ -598,3 +680,30 @@ $$
|
|||
  
|
||||
小结：在弱标记的数据集上训练图像分割算法可以减少对大量全标记数据的依赖，在大多数应用中会更加贴合实际情况。弱标记可以是图像级别的标记、边框和部分像素的标记等。训练的方法一般看做是限制条件下的最优化方法。另外EM算法可以用于CNN参数和像素类别的联合求优。
|
||||
|
||||
## 8.10 DenseNet（贡献者：黄钦建－华南理工大学）
|
||||
|
||||
这篇论文是CVPR2017年的最佳论文。
|
||||
|
||||
卷积神经网络结构的设计主要朝着两个方向发展，一个是更宽的网络（代表：GoogleNet、VGG），一个是更深的网络（代表：ResNet）。但是随着层数的加深会出现一个问题——梯度消失，这将会导致网络停止训练。到目前为止解决这个问题的思路基本都是在前后层之间加一个identity connections(short path)。
|
||||
|
||||
|
||||
|
||||
由上图中可知Resnet是做值的相加（也就是add操作），通道数是不变的。而DenseNet是做通道的合并（也就是Concatenation操作），就像Inception那样。从这两个公式就可以看出这两个网络的本质不同。此外DensetNet的前面一层输出也是后面所有层的输入，这也不同于ResNet残差网络。
|
||||
|
||||
|
||||
|
||||
|
||||
DenseNet的Block结构如上图所示。
|
||||
|
||||
1*1卷积核的目的：减少输入的特征图数量，这样既能降维减少计算量，又能融合各个通道的特征。我们将使用BottleNeck Layers的DenseNet表示为DenseNet-B。(在论文的实验里，将1×1×n小卷积里的n设置为4k，k为每个H产生的特征图数量)
|
||||
|
||||
|
||||
|
||||
上图是DenseNet网络的整体网络结构示意图。其中1*1卷积核的目的是进一步压缩参数，并且在Transition Layer层有个参数Reduction（范围是0到1），表示将这些输出缩小到原来的多少倍，默认是0.5，这样传给下一个Dense Block的时候channel数量就会减少一半。当Reduction的值小于1的时候，我们就把带有这种层的网络称为DenseNet-C。
|
||||
|
||||
DenseNet网络的优点包括：
|
||||
1、减轻了梯度消失
|
||||
2、加强了feature的传递
|
||||
3、更有效地利用了feature
|
||||
4、一定程度上较少了参数数量
|
||||
5、一定程度上减轻了过拟合
|
||||
File diff suppressed because it is too large
Load Diff
|
|
@ -0,0 +1,807 @@
|
|||
# 第五章 卷积神经网络（CNN）
|
||||
|
||||
标签（空格分隔）： 深度学习
|
||||
|
||||
---
|
||||
## 5.1 卷积神经网络的组成层
|
||||
在卷积神经网络中，有3种最主要的层：
|
||||
> * 卷积运算层
|
||||
> * 池化层
|
||||
> * 全连接层
|
||||
|
||||
一个完整的神经网络就是由这三种层叠加组成的。
|
||||
|
||||
**结构示例**
|
||||
|
||||
拿CIFAR-10数据集举例，一个典型的该数据集上的卷积神经网络分类器应该有[INPUT - CONV - RELU - POOL - FC]的结构，
|
||||
|
||||
> * INPUT[32*32*3]包含原始图片数据中的全部像素，长宽都是32，有RGB 3个颜色通道。
|
||||
> * CONV卷积层中，没个神经元会和上一层的若干小区域连接，计算权重和小区域像素的内积，举个例子可能产出的结果数据是[32*32*12]的。
|
||||
> * RELU层，就是神经元激励层，主要的计算就是max(0,x)，结果数据依旧是[32*32*12]。
|
||||
> * POOLing层做的事情，可以理解成一个下采样，可能得到的结果维度就变为[16*16*12]了。
|
||||
> * 全连接层一般用于最后计算类别得分，得到的结果为[1*1*10]的，其中的10对应10个不同的类别。和名字一样，这一层的所有神经元会和上一层的所有神经元有连接。
|
||||
|
||||
这样，卷积神经网络作为一个中间的通道，就一步步把原始的图像数据转成最后的类别得分了。有一个点我们要提一下，刚才说到了有几种不同的神经网络层，其中有一些层是有待训练参数的，另外一些没有。详细一点说，卷积层和全连接层包含权重和偏移的；而RELU和POOLing层只是一个固定的函数运算，是不包含权重和偏移参数的。不过POOLing层包含了我们手动指定的超参数，这个我们之后会提到。
|
||||
|
||||
**总结一下**：
|
||||
* （1）一个卷积神经网络由多种不同类型的层(卷几层/全连接层/RELU层/POOLing层等)叠加而成。
|
||||
* （2）每一层的输入结构是3维的数据，计算完输出依旧是3维的数据。
|
||||
* （3）卷积层和全连接层包含训练参数，RELU 和 POOLing 层不包含。
|
||||
* （4）卷积层，全连接层和 POOLing 层包含超参数，RELU 层没有。
|
||||
|
||||
下图为 CIFAR-10 数据集构建的一个卷积神经网络结构示意图：
|
||||
|
||||
|
||||
|
||||
## 5.2 卷积如何检测边缘信息？
|
||||
|
||||
卷积运算是卷积神经网络最基本的组成部分，神经网络的前几层首先检测边缘，然后，后面的层有可能检测到物体的部分区域，更靠后的一些层可能检测到完整的物体。
|
||||
先介绍一个概念，过滤器：
|
||||
|
||||
|
||||
|
||||
这是一个3*3的过滤器，是一个矩阵，数值如上所示。
|
||||
|
||||
假设我们有一个6*6的灰度图像：
|
||||
|
||||
|
||||
|
||||
把这个图像与过滤器进行卷积运算，卷积运算在此处用“*”表示。
|
||||
|
||||
|
||||
|
||||
我们看一下发生了什么事，把过滤器最准图像左上方3*3的范围，逐一相乘并相加，得到-5。
|
||||
|
||||
同理，将过滤器右移进行相同操作，再下移，直到过滤器对准图像右下角最后一格。依次运算得到一个4*4的矩阵。
|
||||
|
||||
OK，了解了过滤器以及卷积运算后，让我们看看为何过滤器能检测物体边缘：
|
||||
|
||||
举一个最简单的例子：
|
||||
|
||||
|
||||
|
||||
这张图片如上所示，左半边全是白的，右半边全是灰的，过滤器还是用之前那个，把他们进行卷积：
|
||||
|
||||
|
||||
|
||||
可以看到，最终得到的结果中间是一段白色，两边为灰色，于是垂直边缘被找到了。为什么呢？因为在6*6图像中红框标出来的部分，也就是图像中的分界线所在部分，与过滤器进行卷积，结果是30。而在不是分界线的所有部分进行卷积，结果都为0.
|
||||
|
||||
在这个图中，白色的分界线很粗，那是因为6*6的图像实在太小了，若是换成1000*1000的图像，我们会发现在最终结果中，分界线不粗且很明显。
|
||||
|
||||
这就是检测物体垂直边缘的例子，水平边缘的话只需将过滤器旋转90度。
|
||||
|
||||
## 5.3 卷积的几个基本定义？
|
||||
|
||||
首先，我们需要就定义一个卷积层的几个参数达成一致。
|
||||
|
||||
### 5.3.1 卷积核大小
|
||||
|
||||
（Kernel Size）: 卷积核的大小定义了卷积的视图范围。二维的常见选择大小是3，即3×3像素。
|
||||
|
||||
### 5.3.2 卷积核的步长
|
||||
|
||||
（Stride）: Stride定义了内核的步长。虽然它的默认值通常为1，但我们可以将步长设置为2，然后对类似于MaxPooling的图像进行向下采样。
|
||||
|
||||
### 5.3.3 边缘填充
|
||||
|
||||
（Padding）: Padding用于填充输入图像的边界。一个(半)填充的卷积将使空间输出维度与输入相等，而如果卷积核大于1，则未被填充的卷积将会使一些边界消失。
|
||||
|
||||
### 5.3.4 输入和输出通道
|
||||
|
||||
一个卷积层接受一定数量的输入通道(I)，并计算一个特定数量的输出通道(O)，这一层所需的参数可以由I*O*K计算，K等于卷积核中值的数量。
|
||||
|
||||
## 5.4 卷积的网络类型分类？
|
||||
|
||||
### 5.4.1 普通卷积
|
||||
|
||||
|
||||
|
||||
### 5.4.2 扩张卷积
|
||||
|
||||
又名带洞的（atrous）卷积，扩张的卷积引入了另一个被称为扩张率（dilation rate）的卷积层。这定义了卷积核中值之间的间隔。一个3×3卷积核的扩张率为2，它的视图与5×5卷积核相同，而只使用9个参数。想象一下，取一个5×5卷积核，每两行或两列删除一行或一列。
|
||||
|
||||
这将以同样的计算代价提供更广阔的视角。扩张的卷积在实时分割领域特别受欢迎。如果需要广泛的视图，并且不能负担多个卷积或更大的卷积核，那么就使用它们。
|
||||
举例：
|
||||
|
||||
|
||||
|
||||
### 5.4.3 转置卷积
|
||||
|
||||
转置卷积也就是反卷积（deconvolution）。虽然有些人经常直接叫它反卷积，但严格意义上讲是不合适的，因为它不符合一个反卷积的概念。反卷积确实存在，但它们在深度学习领域并不常见。一个实际的反卷积会恢复卷积的过程。想象一下，将一个图像放入一个卷积层中。现在把输出传递到一个黑盒子里，然后你的原始图像会再次出来。这个黑盒子就完成了一个反卷积。这是一个卷积层的数学逆过程。
|
||||
|
||||
一个转置的卷积在某种程度上是相似的，因为它产生的相同的空间分辨率是一个假设的反卷积层。然而，在值上执行的实际数学操作是不同的。一个转置的卷积层执行一个常规的卷积，但是它会恢复它的空间变换（spatial transformation）。
|
||||
|
||||
在这一点上，你应该非常困惑，让我们来看一个具体的例子：
|
||||
5×5的图像被馈送到一个卷积层。步长设置为2，无边界填充，而卷积核是3×3。结果得到了2×2的图像。
|
||||
如果我们想要逆转这个过程，我们需要反向的数学运算，以便从我们输入的每个像素中生成9个值。然后，我们将步长设置为2来遍历输出图像。这就是一个反卷积过程。
|
||||
|
||||
|
||||
|
||||
一个转置的卷积并不会这样做。唯一的共同点是，它保证输出将是一个5×5的图像，同时仍然执行正常的卷积运算。为了实现这一点，我们需要在输入上执行一些奇特的填充。
|
||||
|
||||
正如你现在所能想象的，这一步不会逆转上面的过程。至少不考虑数值。
|
||||
|
||||
它仅仅是重新构造了之前的空间分辨率并进行了卷积运算。这可能不是数学上的逆过程，但是对于编码-解码器（Encoder-Decoder）架构来说，这仍然是非常有用的。这样我们就可以把图像的尺度上推（upscaling）和卷积结合起来，而不是做两个分离的过程。
|
||||
|
||||
如果我们想反转这个过程，我们需要反数学运算，以便从我们输入的每个像素中生成9个值。之后，我们以2步幅的设置来遍历输出图像。这将是一个反卷积。
|
||||
|
||||
|
||||
|
||||
### 5.4.4 可分离卷积
|
||||
|
||||
在一个可分离卷积中，我们可以将内核操作拆分成多个步骤。我们用y = conv（x，k）表示卷积，其中y是输出图像，x是输入图像，k是内核。这一步很简单。接下来，我们假设k可以由下面这个等式计算得出：k = k1.dot（k2）。这将使它成为一个可分离的卷积，因为我们可以通过对k1和k2做2个一维卷积来取得相同的结果，而不是用k做二维卷积。
|
||||
|
||||
|
||||
|
||||
我们以通常用于图像处理的Sobel内核为例。你可以通过乘以向量[1，0，-1]和[1,2,1] .T获得相同的内核。在执行相同的操作时，你只需要6个而不是9个参数。
|
||||
|
||||
上面的示例显示了所谓的空间可分离卷积，据我所知，这并不是在深度学习中使用的。我只是想确保在他人费劲地操作时，你不会受到如此困惑。在神经网络中，我们通常使用的是一种叫做深度可分离卷积的神经网络。
|
||||
|
||||
## 5.5 图解12种不同类型的2D卷积？
|
||||
|
||||
http://www.sohu.com/a/159591827_390227
|
||||
|
||||
## 5.6 2D卷积与3D卷积有什么区别？
|
||||
|
||||
### 5.6.1 2D卷积
|
||||
|
||||
2D卷积操作如图所示，为了解释的更清楚，分别展示了单通道和多通道的操作。且为了画图方便，假定只有1个filter，即输出图像只有一个chanel。
|
||||
|
||||
其中，针对单通道，输入图像的channel为1，卷积核尺寸为 (k_h, k_w, 1)，卷积核在输入图像上的的空间维度（即(height,width)两维）上进行进行滑窗操作，每次滑窗和 (k_h, k_w) 窗口内的values进行卷积操作（现在都用相关操作取代），得到输出图像中的一个value。针对多通道，假定输入图像的channel为3，卷积核尺寸为 (k_h, k_w, 3)， 卷积核在输入图像上的的空间维度（即(h, w)两维）上进行进行滑窗操作，每次滑窗与3个channels上的 (k_h, k_w) 窗口内的所有的values进行相关操作，得到输出图像中的一个value。
|
||||
|
||||
|
||||
|
||||
### 5.6.2 3D卷积
|
||||
|
||||
3D卷积操作如图2所示，同样分为单通道和多通道，且只使用一个filter，输出一个channel。其中，针对单通道，与2D卷积不同之处在于，输入图像多了一个 length 维度，卷积核也多了一个k_l维度，因此卷积核在输入3D图像的空间维度（height和widthw维）和length维度上均进行滑窗操作，每次滑窗与 (k_h, k_w, k_l) 窗口内的values进行相关操作，得到输出3D图像中的一个value.
|
||||
|
||||
针对多通道，则与2D卷积的操作一样，每次滑窗与3个channels上的 (k_h, k_w, k_l) 窗口内的所有values进行相关操作，得到输出3D图像中的一个value。
|
||||
|
||||
|
||||
|
||||
## 5.7 有哪些池化方法？
|
||||
|
||||
在卷积神经网络中，我们经常会碰到池化操作，而池化层往往在卷积层后面，通过池化来降低卷积层输出的特征向量，同时改善结果（不易出现过拟合）。
|
||||
|
||||
为什么可以通过降低维度呢？
|
||||
|
||||
因为图像具有一种“静态性”的属性，这也就意味着在一个图像区域有用的特征极有可能在另一个区域同样适用。因此，为了描述大的图像，一个很自然的想法就是对不同位置的特征进行聚合统计，例如，人们可以计算图像一个区域上的某个特定特征的平均值 (或最大值)来代表这个区域的特征。[1]
|
||||
|
||||
### 5.7.1 一般池化（General Pooling）
|
||||
池化作用于图像中不重合的区域（这与卷积操作不同），过程如下图。
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
我们定义池化窗口的大小为sizeX，即下图中红色正方形的边长，定义两个相邻池化窗口的水平位移/竖直位移为stride。一般池化由于每一池化窗口都是不重复的，所以sizeX=stride。
|
||||
|
||||
|
||||
|
||||
最常见的池化操作为平均池化mean pooling和最大池化max pooling：
|
||||
* 平均池化：计算图像区域的平均值作为该区域池化后的值。
|
||||
* 最大池化：选图像区域的最大值作为该区域池化后的值。
|
||||
|
||||
### 5.7.2 重叠池化（General Pooling）
|
||||
重叠池化正如其名字所说的，相邻池化窗口之间会有重叠区域，此时sizeX>stride。论文中[2]中，作者使用了重叠池化，其他的设置都不变的情况下， top-1和top-5 的错误率分别减少了0.4% 和0.3%。
|
||||
|
||||
### 5.7.3 空金字塔池化（Spatial Pyramid Pooling）
|
||||
|
||||
空间金字塔池化可以把任何尺度的图像的卷积特征转化成相同维度，这不仅可以让CNN处理任意尺度的图像，还能避免cropping和warping操作，导致一些信息的丢失，具有非常重要的意义。
|
||||
|
||||
一般的CNN都需要输入图像的大小是固定的，这是因为全连接层的输入需要固定输入维度，但在卷积操作是没有对图像尺度有限制，所有作者提出了空间金字塔池化，先让图像进行卷积操作，然后转化成维度相同的特征输入到全连接层，这个可以把CNN扩展到任意大小的图像。
|
||||
|
||||
|
||||
|
||||
空间金字塔池化的思想来自于Spatial Pyramid Model,它一个pooling变成了多个scale的pooling。用不同大小池化窗口作用于卷积特征，我们可以得到1X1,2X2,4X4的池化结果，由于conv5中共有256个过滤器，所以得到1个256维的特征，4个256个特征，以及16个256维的特征，然后把这21个256维特征链接起来输入全连接层，通过这种方式把不同大小的图像转化成相同维度的特征。
|
||||
|
||||
|
||||
|
||||
对于不同的图像要得到相同大小的pooling结果，就需要根据图像的大小动态的计算池化窗口的大小和步长。假设conv5输出的大小为a*a，需要得到n*n大小的池化结果，可以让窗口大小sizeX为[a/n]，步长为[a/n]。下图以conv5输出的大小为13*13为例。
|
||||
|
||||
|
||||
|
||||
疑问：如果conv5输出的大小为14*14，[pool1*1]的sizeX=stride=14，[pool2*2]的sizeX=stride=7，这些都没有问题，但是，[pool4*4]的sizeX=5，stride=4，最后一列和最后一行特征没有被池化操作计算在内。
|
||||
|
||||
SPP其实就是一种多个scale的pooling，可以获取图像中的多尺度信息；在CNN中加入SPP后，可以让CNN处理任意大小的输入，这让模型变得更加的flexible。
|
||||
|
||||
## 5.8 1x1卷积作用？
|
||||
|
||||
1×1的卷积大概有两个方面的作用：
|
||||
1. 实现跨通道的交互和信息整合。
|
||||
2. 进行卷积核通道数的降维和升维。
|
||||
|
||||
下面详细解释一下：
|
||||
1. 1×1的卷积层（可能）引起人们的重视是在NIN的结构中，论文中林敏师兄的想法是利用MLP代替传统的线性卷积核，从而提高网络的表达能力。文中同时利用了跨通道pooling的角度解释，认为文中提出的MLP其实等价于在传统卷积核后面接cccp层，从而实现多个feature map的线性组合，实现跨通道的信息整合。而cccp层是等价于1×1卷积的，因此细看NIN的caffe实现，就是在每个传统卷积层后面接了两个cccp层（其实就是接了两个1×1的卷积层）。
|
||||
|
||||
2. 进行降维和升维引起人们重视的（可能）是在GoogLeNet里。对于每一个Inception模块（如下图），原始模块是左图，右图中是加入了1×1卷积进行降维的。虽然左图的卷积核都比较小，但是当输入和输出的通道数很大时，乘起来也会使得卷积核参数变的很大，而右图加入1×1卷积后可以降低输入的通道数，卷积核参数、运算复杂度也就跟着降下来了。以GoogLeNet的3a模块为例，输入的feature map是28×28×192，3a模块中1×1卷积通道为64，3×3卷积通道为128,5×5卷积通道为32，如果是左图结构，那么卷积核参数为1×1×192×64+3×3×192×128+5×5×192×32，而右图对3×3和5×5卷积层前分别加入了通道数为96和16的1×1卷积层，这样卷积核参数就变成了1×1×192×64+（1×1×192×96+3×3×96×128）+（1×1×192×16+5×5×16×32），参数大约减少到原来的三分之一。同时在并行pooling层后面加入1×1卷积层后也可以降低输出的feature map数量，左图pooling后feature map是不变的，再加卷积层得到的feature map，会使输出的feature map扩大到416，如果每个模块都这样，网络的输出会越来越大。而右图在pooling后面加了通道为32的1×1卷积，使得输出的feature map数降到了256。GoogLeNet利用1×1的卷积降维后，得到了更为紧凑的网络结构，虽然总共有22层，但是参数数量却只是8层的AlexNet的十二分之一（当然也有很大一部分原因是去掉了全连接层）。
|
||||
|
||||
|
||||
|
||||
最近大热的MSRA的ResNet同样也利用了1×1卷积，并且是在3×3卷积层的前后都使用了，不仅进行了降维，还进行了升维，使得卷积层的输入和输出的通道数都减小，参数数量进一步减少，如下图的结构。（不然真不敢想象152层的网络要怎么跑起来TAT）
|
||||
|
||||
|
||||
|
||||
## 5.9 卷积层和池化层有什么区别？
|
||||
|
||||
首先可以从结构上可以看出，卷积之后输出层的维度减小，深度变深。但池化层深度不变。同时池化可以把很多数据用最大值或者平均值代替。目的是降低数据量。降低训练的参数。对于输入层，当其中像素在邻域发生微小位移时，池化层的输出是不变的，从而能提升鲁棒性。而卷积则是把数据通过一个卷积核变化成特征，便于后面的分离。
|
||||
|
||||
1:卷积
|
||||
|
||||
当从一个大尺寸图像中随机选取一小块，比如说 8x8 作为样本，并且从这个小块样本中学习到了一些特征，这时我们可以把从这个 8x8 样本中学习到的特征作为探测器，应用到这个图像的任意地方中去。特别是，我们可以用从 8x8 样本中所学习到的特征跟原本的大尺寸图像作卷积，从而对这个大尺寸图像上的任一位置获得一个不同特征的激活值。
|
||||
|
||||
下面给出一个具体的例子：假设你已经从一个 96x96 的图像中学习到了它的一个 8x8 的样本所具有的特征，假设这是由有 100 个隐含单元的自编码完成的。为了得到卷积特征，需要对 96x96 的图像的每个 8x8 的小块图像区域都进行卷积运算。也就是说，抽取 8x8 的小块区域，并且从起始坐标开始依次标记为（1，1），（1，2），...，一直到（89，89），然后对抽取的区域逐个运行训练过的稀疏自编码来得到特征的激活值。在这个例子里，显然可以得到 100 个集合，每个集合含有 89x89 个卷积特征。
|
||||
|
||||
|
||||
|
||||
2：说下池化，其实池化很容易理解，先看图：
|
||||
|
||||
转自： http://blog.csdn.net/silence1214/article/details/11809947
|
||||
|
||||
|
||||
|
||||
比如上方左侧矩阵A是20*20的矩阵要进行大小为10*10的池化，那么左侧图中的红色就是10*10的大小，对应到右侧的矩阵，右侧每个元素的值，是左侧红色矩阵每个元素的值得和再处于红色矩阵的元素个数，也就是平均值形式的池化。
|
||||
|
||||
3：上面说了下卷积和池化，再说下计算中需要注意到的。在代码中使用的是彩色图，彩色图有3个通道，那么对于每一个通道来说要单独进行卷积和池化，有一个地方尤其是进行卷积的时候要注意到，隐藏层的每一个值是对应到一幅图的3个通道穿起来的，所以分3个通道进行卷积之后要加起来，正好才能对应到一个隐藏层的神经元上，也就是一个feature上去。
|
||||
|
||||
## 5.10 卷积核一定越大越好？
|
||||
|
||||
AlexNet中用到了一些非常大的卷积核，比如11×11、5×5卷积核，之前人们的观念是，卷积核越大，receptive field（感受野）越大，看到的图片信息越多，因此获得的特征越好。虽说如此，但是大的卷积核会导致计算量的暴增，不利于模型深度的增加，计算性能也会降低。于是在VGG（最早使用）、Inception网络中，利用2个3×3卷积核的组合比1个5×5卷积核的效果更佳，同时参数量（3×3×2+1 VS 5×5×1+1） 被降低，因此后来3×3卷积核被广泛应用在各种模型中。多个小的卷积核叠加使用要远比一个大的卷积核单独使用效果要好的多，在连通性不变的情况下，大大降低了参数个数和计算复杂度。当然，卷积核也不是越小越好，对于特别稀疏的数据比如下图所示，当使用比较小的卷积核的时候可能无法表示其特征，如果采用较大的卷积核则会导致复杂度极大的增加。总而言之，我们应该选择多个相对小的卷积核来进行卷积。
|
||||
|
||||
## 5.11 每层卷积只能用一种尺寸的卷积核？
|
||||
|
||||
传统的层叠式网络，基本上都是一个个卷积层的堆叠，每层只用一个尺寸的卷积核，例如VGG结构中使用了大量的3×3卷积层。事实上，同一层feature map可以分别使用多个不同尺寸的卷积核，以获得不同尺度的特征，再把这些特征结合起来，得到的特征往往比使用单一卷积核的要好，谷歌的GoogLeNet，或者说Inception系列的网络，就使用了多个卷积核的结构：
|
||||
|
||||
|
||||
|
||||
如上图所示，一个输入的feature map 分别同时经过1×1、3×3、5×5的卷积核的处理，得出的特征再组合起来，获得更佳的特征。
|
||||
|
||||
## 5.12 怎样才能减少卷积层参数量？
|
||||
|
||||
发明GoogleNet的团队发现，如果仅仅引入多个尺寸的卷积核，会带来大量的额外的参数，受到Network In Network中1×1卷积核的启发，为了解决这个问题，他们往Inception结构中加入了一些1×1的卷积核，如图所示：
|
||||
|
||||
|
||||
|
||||
加入1×1卷积核的Inception结构
|
||||
|
||||
|
||||
|
||||
根据上图，我们来做个对比计算，假设输入feature map的维度为256维，要求输出维度也是256维。有以下两种操作：
|
||||
* （1）256维的输入直接经过一个3×3×256的卷积层，输出一个256维的feature map，那么参数量为：256×3×3×256 = 589,824
|
||||
* （2）256维的输入先经过一个1×1×64的卷积层，再经过一个3×3×64的卷积层，最后经过一个1×1×256的卷积层，输出256维，参数量为：256×1×1×64 + 64×3×3×64 + 64×1×1×256 = 69,632。足足把第一种操作的参数量降低到九分之一！
|
||||
|
||||
1×1卷积核也被认为是影响深远的操作，往后大型的网络为了降低参数量都会应用上1×1卷积核。
|
||||
|
||||
## 5.13 卷积操作时必须同时考虑通道和区域吗？
|
||||
|
||||
|
||||
|
||||
标准的卷积过程可以看上图，一个2×2的卷积核在卷积时，对应图像区域中的所有通道均被同时考虑，问题在于，为什么一定要同时考虑图像区域和通道？我们为什么不能把通道和空间区域分开考虑？
|
||||
|
||||
|
||||
|
||||
Xception网络就是基于以上的问题发明而来。我们首先对每一个通道进行各自的卷积操作，有多少个通道就有多少个过滤器。得到新的通道feature maps之后，这时再对这批新的通道feature maps进行标准的1×1跨通道卷积操作。这种操作被称为 “DepthWise convolution” ，缩写“DW”。
|
||||
|
||||
这种操作是相当有效的，在imagenet 1000类分类任务中已经超过了InceptionV3的表现，而且也同时减少了大量的参数，我们来算一算，假设输入通道数为3，要求输出通道数为256，两种做法：
|
||||
|
||||
1. 直接接一个3×3×256的卷积核，参数量为：3×3×3×256 = 6,912
|
||||
2. DW操作，分两步完成，参数量为：3×3×3 + 3×1×1×256 = 795，又把参数量降低到九分之一！
|
||||
|
||||
因此，一个depthwise操作比标准的卷积操作降低不少的参数量，同时论文中指出这个模型得到了更好的分类效果。
|
||||
|
||||
## 5.14 采用宽卷积的好处有什么？
|
||||
|
||||
### 5.14.1 窄卷积和宽卷积
|
||||
|
||||
对于窄卷积来说，是从第一个点开始做卷积，每次窗口滑动固定步幅。比如下图左部分为窄卷积。那么注意到越在边缘的位置被卷积的次数越少。于是有了宽卷积的方法，可以看作在卷积之前在边缘用0补充，常见有两种情况，一个是全补充，入下图右部分，这样输出大于输入的维度。另一种常用的方法是补充一部0值，使得输出和输入的维度一致。这里文中给了一个公式 。这里npadding在全补充里是filter-1，在输入输出相等时，就要主要奇偶性了，注意到卷积核常为奇数。
|
||||
|
||||
|
||||
|
||||
### 5.14.2 为什么采用宽卷积？
|
||||
|
||||
通过将输入边角的值纳入到滑窗中心进行计算，以便损失更少的信息。
|
||||
|
||||
## 5.15 卷积层输出的深度与哪个部件的个数相同？
|
||||
|
||||
输出深度（通道）与卷积核（过滤器）的个数相等。
|
||||
|
||||
## 5.16 如何得到卷积层输出的深度？
|
||||
|
||||
参数共享：在卷积层中使用参数共享是用来控制参数的数量。假设在第一个卷积层就有55x55x96=290,400个神经元，每个有11x11x3=364个参数和1个偏差。将这些合起来就是290400x364=105,705,600个参数。单单第一层就有这么多参数，显然这个数目是非常大的。
|
||||
|
||||
作一个合理的假设：如果一个特征在计算某个空间位置(x,y)的时候有用，那么它在计算另一个不同位置(x2,y2)的时候也有用。基于这个假设，可以显著地减少参数数量。换言之，就是将深度维度上一个单独的2维切片看做深度切片（depth slice），比如一个数据体尺寸为[55x55x96]的就有96个深度切片，每个尺寸为[55x55]。在每个深度切片上的神经元都使用同样的权重和偏差。在这样的参数共享下，例子中的第一个卷积层就只有96个不同的权重集了，一个权重集对应一个深度切片，共有96x11x11x3=34,848个不同的权重，或34,944个参数（+96个偏差）。
|
||||
|
||||
```w_conv1=weight_variable([5,5,1,32])```
|
||||
|
||||
可以看出，上面的32表示的是卷积层输出的深度，因为大家都明白width和height都可以通过公式计算得到，但是很多文献都没有告诉深度是如何得到的，下面是我的认识：
|
||||
|
||||
1. 因为这个深度是没有公式可以计算出来的，因为深度是一个经验值，如上面代码的32 ，其实是一个经验值，是通过调整参数发现32是一个最合适的值，可以得到最好的准确率，但是不同的图像的深度是不一样的。
|
||||
2. 这个深度表示用了多少个卷积核，下面这个图可以说明一下：
|
||||
|
||||
|
||||
|
||||
上图就可以很有效的说明 ：卷积层输出的深度==卷积核的个数。
|
||||
|
||||
## 5.17 激活函数通常放在卷积神经网络的那个操作之后？
|
||||
|
||||
通常放在卷积层之后。
|
||||
|
||||
## 5.18 如何理解最大池化层有几分缩小？
|
||||
|
||||
池化层：对输入的特征图进行压缩，一方面使特征图变小，简化网络计算复杂度；一方面进行特征压缩，提取主要特征。
|
||||
|
||||
池化操作一般有两种，一种是Avy Pooling,一种是max Pooling。
|
||||
|
||||
|
||||
|
||||
同样地采用一个2*2的filter,max pooling是在每一个区域中寻找最大值，这里的stride=2,最终在原特征图中提取主要特征得到右图。
|
||||
|
||||
>注1：（Avy pooling现在不怎么用了，方法是对每一个2*2的区域元素求和，再除以4，得到主要特征），而一般的filter取2*2,最大取3*3,stride取2，压缩为原来的1/4.
|
||||
>注2：这里的pooling操作是特征图缩小，有可能影响网络的准确度，因此可以通过增加特征图的深度来弥补。
|
||||
|
||||
## 5.19 理解图像卷积与反卷积
|
||||
|
||||
### 5.19.1 图像卷积
|
||||
|
||||
首先给出一个输入输出结果
|
||||
|
||||
|
||||
|
||||
那他是怎样计算的呢？
|
||||
|
||||
卷积的时候需要对卷积核进行180的旋转，同时卷积核中心与需计算的图像像素对齐，输出结构为中心对齐像素的一个新的像素值，计算例子如下：
|
||||
|
||||
|
||||
|
||||
这样计算出左上角(即第一行第一列)像素的卷积后像素值。
|
||||
|
||||
给出一个更直观的例子，从左到右看，原像素经过卷积由1变成-8。
|
||||
|
||||
|
||||
|
||||
通过滑动卷积核，就可以得到整张图片的卷积结果
|
||||
|
||||
|
||||
|
||||
### 5.19.2 图像反卷积
|
||||
|
||||
这里提到的反卷积跟1维信号处理的反卷积计算是很不一样的，FCN作者称为backwards convolution，有人称Deconvolution layer is a very unfortunate name and should rather be called a transposed convolutional layer. 我们可以知道，在CNN中有con layer与pool layer，con layer进行对图像卷积提取特征，pool layer 对图像缩小一半筛选重要特征，对于经典的图像识别CNN网络，如IMAGENET，最后输出结果是1X1X1000，1000是类别种类，1x1得到的是。FCN作者，或者后来对end to end研究的人员，就是对最终1x1的结果使用反卷积（事实上FCN作者最后的输出不是1X1，是图片大小的32分之一，但不影响反卷积的使用）。
|
||||
|
||||
这里图像的反卷积与full卷积原理是一样的，使用了这一种反卷积手段使得图像可以变大，FCN作者使用的方法是这里所说反卷积的一种变体，这样就可以获得相应的像素值，图像可以实现end to end。
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
这里说另外一种反卷积做法，假设原图是3*3，首先使用上采样让图像变成7*7，可以看到图像多了很多空白的像素点。使用一个3*3的卷积核对图像进行滑动步长为1的valid卷积，得到一个5*5的图像，我们知道的是使用上采样扩大图片，使用反卷积填充图像内容，使得图像内容变得丰富，这也是CNN输出end to end结果的一种方法。韩国作者Hyeonwoo Noh使用VGG16层CNN网络后面加上对称的16层反卷积与上采样网络实现end to end 输出，其不同层上采样与反卷积变化效果如下：
|
||||
|
||||
|
||||
|
||||
经过上面的解释与推导，对卷积有基本的了解，但是在图像上的deconvolution究竟是怎么一回事，可能还是不能够很好的理解，因此这里再对这个过程解释一下。 目前使用得最多的deconvolution有2种，上文都已经介绍。
|
||||
|
||||
* 方法1：full卷积， 完整的卷积可以使得原来的定义域变大。
|
||||
* 方法2：记录pooling index，然后扩大空间，再用卷积填充。
|
||||
|
||||
图像的deconvolution过程如下：
|
||||
|
||||
|
||||
|
||||
输入：2x2， 卷积核：4x4， 滑动步长：3， 输出：7x7
|
||||
|
||||
即输入为2x2的图片经过4x4的卷积核进行步长为3的反卷积的过程
|
||||
|
||||
1. 输入图片每个像素进行一次full卷积，根据full卷积大小计算可以知道每个像素的卷积后大小为 1+4-1=4， 即4x4大小的特征图，输入有4个像素所以4个4x4的特征图
|
||||
2. 将4个特征图进行步长为3的fusion（即相加）； 例如红色的特征图仍然是在原来输入位置（左上角），绿色还是在原来的位置（右上角），步长为3是指每隔3个像素进行fusion，重叠部分进行相加，即输出的第1行第4列是由红色特阵图的第一行第四列与绿色特征图的第一行第一列相加得到，其他如此类推。
|
||||
|
||||
可以看出翻卷积的大小是由卷积核大小与滑动步长决定， in是输入大小， k是卷积核大小， s是滑动步长， out是输出大小 得到 out = (in - 1) * s + k 上图过程就是， (2 - 1) * 3 + 4 = 7
|
||||
|
||||
## 5.20 不同卷积后图像大小计算？
|
||||
|
||||
### 5.20.1 类型划分
|
||||
|
||||
2维卷积的计算分为了3类：1.full 2.same 3. valid
|
||||
|
||||
1、**full**
|
||||
|
||||
|
||||
|
||||
蓝色为原图像，白色为对应卷积所增加的padding，通常全部为0，绿色是卷积后图片。图6的卷积的滑动是从卷积核右下角与图片左上角重叠开始进行卷积，滑动步长为1，卷积核的中心元素对应卷积后图像的像素点。可以看到卷积后的图像是4X4，比原图2X2大了，我们还记1维卷积大小是n1+n2-1，这里原图是2X2，卷积核3X3，卷积后结果是4X4，与一维完全对应起来了。其实这才是完整的卷积计算，其他比它小的卷积结果都是省去了部分像素的卷积
|
||||
|
||||
2、**same**
|
||||
|
||||
|
||||
|
||||
3、**valid**
|
||||
|
||||
|
||||
|
||||
### 5.20.2 计算公式
|
||||
|
||||
这里，我们可以总结出full，same，valid三种卷积后图像大小的计算公式：
|
||||
|
||||
1. full: 滑动步长为1，图片大小为N1xN1，卷积核大小为N2xN2，卷积后图像大小：N1+N2-1 x N1+N2-1。
|
||||
2. same: 滑动步长为1，图片大小为N1xN1，卷积核大小为N2xN2，卷积后图像大小：N1xN1。
|
||||
3. valid:滑动步长为S，图片大小为N1xN1，卷积核大小为N2xN2，卷积后图像大小：(N1-N2)/S+1 x (N1-N2)/S+1。
|
||||
|
||||
## 5.21 步长、填充大小与输入输出关系总结？
|
||||
|
||||
在设计深度学习网络的时候，需要计算输入尺寸和输出尺寸，那么就要设计卷积层的的各种参数。这里有一些设计时候的计算公式，方便得到各层的参数。
|
||||
|
||||
这里简化下，约定：
|
||||
|
||||
|
||||
|
||||
### 5.21.1 没有0填充，单位步长
|
||||
|
||||
|
||||
|
||||
### 5.21.2 零填充，单位步长
|
||||
|
||||
|
||||
|
||||
<1>半填充
|
||||
|
||||
|
||||
<2>全填充
|
||||
|
||||
|
||||
参考图如下图所示
|
||||
|
||||
|
||||
|
||||
|
||||
### 5.21.3 不填充，非单位步长
|
||||
|
||||
|
||||
|
||||
### 5.21.4 零填充，非单位步长
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
http://blog.csdn.net/u011692048/article/details/77572024
|
||||
https://arxiv.org/pdf/1603.07285.pdf
|
||||
|
||||
## 5.22 理解反卷积和棋盘效应
|
||||
|
||||
### 5.22.1 为什么出现棋盘现象？
|
||||
|
||||
图像生成网络的上采样部分通常用反卷积网络，不合理的卷积核大小和步长会使反卷积操作产生棋盘效应 (checkerboard artifacts)。
|
||||
|
||||
|
||||
|
||||
|
||||
重叠图案也在二维中形成。两个轴上的不均匀重叠相乘，产生不同亮度的棋盘状图案。
|
||||
|
||||
事实上，不均匀重叠往往在二维上更极端！因为两个模式相乘，所以它的不均匀性是原来的平方。例如，在一个维度中，一个步长为2，大小为3的反卷积的输出是其输入的两倍，但在二维中，输出是输入的4倍。
|
||||
|
||||
现在，生成图像时，神经网络通常使用多层反卷积，从一系列较低分辨率的描述中迭代建立更大的图像。虽然这些堆栈的反卷积可以消除棋盘效应，但它们经常混合，在更多尺度上产生棋盘效应。
|
||||
|
||||
直观地看，假设生成的图像中包含1只黑猫。黑猫身体部分的像素颜色应平滑过渡，或极端地说，该部分应全为黑色。实际生成的图像中该部分却有深深浅浅的近黑方块组成，很像棋盘的网格，即棋盘效应。
|
||||
|
||||
https://distill.pub/2016/deconv-checkerboard/
|
||||
http://blog.csdn.net/shadow_guo/article/details/52862161
|
||||
|
||||
### 5.22.2 有哪些方法可以避免棋盘效应？
|
||||
|
||||
（1）第一种方法是用到的反卷积核的大小可被步长整除，从而避免重叠效应。与最近成功用于图像超分辨率的技术“子像素卷积”（sub-pixel convolution）等价。
|
||||
|
||||
|
||||
|
||||
（2）另一种方法是从卷积操作中分离出对卷积后更高分辨率的特征图上采样来计算特征。例如，可以先缩放图像（最近邻插值或双线性插值），再卷积。
|
||||
|
||||
|
||||
|
||||
反卷积与不同缩放卷积方法都是线性操作，并可用矩阵去解释。对于每个输出窗口，反卷积操作的输入唯一，缩放卷积会以阻碍高频棋盘效应的方式来隐式地集中权重（weight-tying）。
|
||||
|
||||
#### 缩放卷积
|
||||
|
||||
缩放卷积为线性操作：假设原图像为A，经过插值后的图像为A+B；用卷积核C对插值缩放后的图像卷积，得到最终的图像 ，其中*为卷积操作。则可将缩放卷积分解为原图像卷积和插值增量图像卷积，或卷积的原图像和卷积的插值增量图像。
|
||||
|
||||
C为卷积操作的卷积核。此时为上采样，理解为反卷积操作中的卷积核。
|
||||
|
||||
（1）最近邻缩放卷积
|
||||
|
||||
|
||||
|
||||
发现，插值增量图像表示的矩阵为原图像表示的矩阵下移1行。可将原图像矩阵看成环形队列（队列最后1行的输出送入队列的第1行）。
|
||||
|
||||
（2）双线性缩放卷积
|
||||
|
||||
|
||||
|
||||
发现，插值增量图像可细分为原图像表示的矩阵下移1行后乘以1/2与原图像表示的矩阵上移1行后乘以1/2。
|
||||
|
||||
## 5.23 CNN主要的计算瓶颈
|
||||
|
||||
CNN的训练主要是在卷积层和子采样层的交互上，其主要的计算瓶颈是：
|
||||
* 1）前向传播过程：下采样每个卷积层的maps；
|
||||
* 2）反向传播过程：上采样高层子采样层的灵敏度map，以匹配底层的卷积层输出maps的大小；
|
||||
* 3）sigmoid的运用和求导。
|
||||
|
||||
举例：
|
||||
|
||||
对于第一和第二个问题，我们考虑的是如何用Matlab内置的图像处理函数去实现上采样和下采样的操作。对于上采样，imresize函数可以搞定，但需要很大的开销。一个比较快速的版本是使用Kronecker乘积函数kron。通过一个全一矩阵ones来和我们需要上采样的矩阵进行Kronecker乘积，就可以实现上采样的效果。对于前向传播过程中的下采样，imresize并没有提供在缩小图像的过程中还计算nxn块内像素的和的功能，所以没法用。一个比较好和快速的方法是用一个全一的卷积核来卷积图像，然后简单的通过标准的索引方法来采样最后卷积结果。例如，如果下采样的域是2x2的，那么我们可以用2x2的元素全是1的卷积核来卷积图像。然后再卷积后的图像中，我们每个2个点采集一次数据，y=x(1:2:end,1:2:end)，这样就可以得到了两倍下采样，同时执行求和的效果。
|
||||
|
||||
对于第三个问题，实际上有些人以为Matlab中对sigmoid函数进行inline的定义会更快，其实不然，Matlab与C/C++等等语言不一样，Matlab的inline反而比普通的函数定义更非时间。所以，我们可以直接在代码中使用计算sigmoid函数及其导数的真实代码。
|
||||
|
||||
## 5.24 CNN的参数经验设置
|
||||
|
||||
对于卷积神经网络的参数设置，没有很明确的方法，这只是众多学者的一些经验。
|
||||
|
||||
1、learning-rate 学习速率：学习速率越小，模型收敛花费的时间就越长，但是可以提高模型精确度。一般初始设置为0.1，然后每次除以0.2或者0.5来改进，得到最终值；
|
||||
|
||||
2、batch-size 样本批次容量：影响模型的优化程度和收敛速度，需要参考你的数据集大小来设置，具体问题具体分析；
|
||||
|
||||
3、weight-decay 权重衰减：用来在反向传播中更新权重和偏置，一般设置为0.005；
|
||||
|
||||
4、epoch-number 训练次数：包括所有训练样本的一个正向传递和一个反向传递，训练至模型收敛即可；（注：和迭代周期iteration不一样）
|
||||
|
||||
而且，也不是说训练的次数越多，测试精度就会越高，可能会因为预训练的模型太复杂，而我的数据集样本数量太少，种类太单一，而出现过拟合。
|
||||
|
||||
## 5.25 提高泛化能力的方法总结
|
||||
|
||||
http://blog.csdn.net/u010900574/article/details/51992156
|
||||
|
||||
### 5.25.1 主要方法
|
||||
|
||||
一般来说，提高泛化能力的方法主要有以下几个：
|
||||
> * 正则化
|
||||
> * 增加神经网络层数
|
||||
> * 使用正确的代价函数
|
||||
> * 使用好的权重初始化技术
|
||||
> * 人为拓展训练集
|
||||
> * 弃权技术
|
||||
|
||||
### 5.25.2 主要方法
|
||||
|
||||
下面我们通过实验结果给这些参数优化理论一个直观的结果
|
||||
|
||||
（1）普通的全连接神经网络的效果
|
||||
|
||||
我们使用一个隐藏层，包含100个隐藏神经元，输入层是784，输出层是one-hot编码的形式，最后一层是Softmax层。训练过程采用对数似然代价函数，60次迭代，学习速率η=0.1，随机梯度下降的小批量数据大小为10，没有正则化。在测试集上得到的结果是97.8%，代码如下：
|
||||
|
||||
```python
|
||||
>>> import network3
|
||||
>>> from network3 import Network
|
||||
>>> from network3 import ConvPoolLayer, FullyConnectedLayer, SoftmaxLayer
|
||||
>>> training_data, validation_data, test_data = network3.load_data_shared()
|
||||
>>> mini_batch_size = 10
|
||||
>>> net = Network([FullyConnectedLayer(n_in=784, n_out=100),
|
||||
SoftmaxLayer(n_in=100, n_out=10)], mini_batch_size)
|
||||
>>> net.SGD(training_data, 60, mini_batch_size, 0.1, validation_data, test_data)
|
||||
```
|
||||
|
||||
（2）使用卷积神经网络 — 仅一个卷积层
|
||||
|
||||
输入层是卷积层，5*5的局部感受野，也就是一个5*5的卷积核，一共20个特征映射。最大池化层选用2*2的大小。后面是100个隐藏神经元的全连接层。结构如图所示
|
||||
|
||||
|
||||
|
||||
在这个架构中，我们把卷积层和chihua层看做是学习输入训练图像中的局部感受野，而后的全连接层则是一个更抽象层次的学习，从整个图像整合全局信息。也是60次迭代，批量数据大小是10，学习率是0.1.代码如下。
|
||||
|
||||
```python
|
||||
>>> net = Network([
|
||||
ConvPoolLayer(image_shape=(mini_batch_size, 1, 28, 28),
|
||||
filter_shape=(20, 1, 5, 5),
|
||||
poolsize=(2, 2)),
|
||||
FullyConnectedLayer(n_in=20*12*12, n_out=100),
|
||||
SoftmaxLayer(n_in=100, n_out=10)], mini_batch_size)
|
||||
>>> net.SGD(training_data, 60, mini_batch_size, 0.1,
|
||||
validation_data, test_data)
|
||||
```
|
||||
|
||||
经过三次运行取平均后，准确率是98.78%，这是相当大的改善。错误率降低了1/3，。卷积神经网络开始显现威力。
|
||||
|
||||
（3）使用卷积神经网络 — 两个卷积层
|
||||
|
||||
我们接着插入第二个卷积-混合层，把它插入在之前的卷积-混合层和全连接层之间，同样的5*5的局部感受野，2*2的池化层。
|
||||
|
||||
```python
|
||||
>>> net = Network([
|
||||
ConvPoolLayer(image_shape=(mini_batch_size, 1, 28, 28),
|
||||
filter_shape=(20, 1, 5, 5),
|
||||
poolsize=(2, 2)),
|
||||
ConvPoolLayer(image_shape=(mini_batch_size, 20, 12, 12),
|
||||
filter_shape=(40, 20, 5, 5),
|
||||
poolsize=(2, 2)),
|
||||
FullyConnectedLayer(n_in=40*4*4, n_out=100),
|
||||
SoftmaxLayer(n_in=100, n_out=10)], mini_batch_size)
|
||||
>>> net.SGD(training_data, 60, mini_batch_size, 0.1, validation_data, test_data)
|
||||
```
|
||||
|
||||
这一次，我们拥有了99.06%的准确率。
|
||||
|
||||
（4）使用卷积神经网络 — 两个卷积层+线性修正单元(ReLU)+正则化
|
||||
|
||||
上面我们使用的Sigmod激活函数，现在我们换成线性修正激活函数ReLU ，f(z)=max(0,z)f(z)=max(0,z),我们选择60个迭代期，学习速率η=0.03,η=0.03, ，使用L2正则化，正则化参数λ=0.1λ=0.1,代码如下：
|
||||
|
||||
```python
|
||||
>>> from network3 import ReLU
|
||||
>>> net = Network([
|
||||
ConvPoolLayer(image_shape=(mini_batch_size, 1, 28, 28),
|
||||
filter_shape=(20, 1, 5, 5),
|
||||
poolsize=(2, 2),
|
||||
activation_fn=ReLU),
|
||||
ConvPoolLayer(image_shape=(mini_batch_size, 20, 12, 12),
|
||||
filter_shape=(40, 20, 5, 5),
|
||||
poolsize=(2, 2),
|
||||
activation_fn=ReLU),
|
||||
FullyConnectedLayer(n_in=40*4*4, n_out=100, activation_fn=ReLU),
|
||||
SoftmaxLayer(n_in=100, n_out=10)], mini_batch_size)
|
||||
>>> net.SGD(training_data, 60, mini_batch_size, 0.03,
|
||||
validation_data, test_data, lmbda=0.1)
|
||||
```
|
||||
|
||||
这一次，我们获得了99.23%的准确率，超过了S型激活函数的99.06%. ReLU的优势是max(0,z)max(0,z)中z取最大极限时不会饱和，不像是S函数，这有助于持续学习。
|
||||
|
||||
（5）使用卷积神经网络,即两个卷基层+线性修正单元(ReLU)+正则化+拓展数据集
|
||||
|
||||
拓展训练集数据的一个简单方法是将每个训练图像由一个像素来代替，无论是上一个像素，下一个像素，或者左右的像素。其他的方法也有改变亮度，改变分辨率，图片旋转，扭曲，位移等。我们把50,000幅图像人为拓展到250,000幅图像。使用第4节一样的网络，因为我们是在训练5倍的数据，所以减少了过拟合的风险。
|
||||
|
||||
```python
|
||||
>>> expanded_training_data, _, _ = network3.load_data_shared(
|
||||
"../data/mnist_expanded.pkl.gz")
|
||||
>>> net = Network([
|
||||
ConvPoolLayer(image_shape=(mini_batch_size, 1, 28, 28),
|
||||
filter_shape=(20, 1, 5, 5),
|
||||
poolsize=(2, 2),
|
||||
activation_fn=ReLU),
|
||||
ConvPoolLayer(image_shape=(mini_batch_size, 20, 12, 12),
|
||||
filter_shape=(40, 20, 5, 5),
|
||||
poolsize=(2, 2),
|
||||
activation_fn=ReLU),
|
||||
FullyConnectedLayer(n_in=40*4*4, n_out=100, activation_fn=ReLU),
|
||||
SoftmaxLayer(n_in=100, n_out=10)], mini_batch_size)
|
||||
>>> net.SGD(expanded_training_data, 60, mini_batch_size, 0.03,
|
||||
validation_data, test_data, lmbda=0.1)
|
||||
```
|
||||
|
||||
这次的到了99.37的训练正确率。
|
||||
|
||||
（6）使用卷积神经网络 — 两个卷基层+线性修正单元(ReLU)+正则化+拓展数据集+继续插入额外的全连接层
|
||||
继续上面的网络，我们拓展全连接层的规模，300个隐藏神经元和1000个神经元的额精度分别是99.46%和99.43%. 我们插入一个额外的全连接层
|
||||
|
||||
```python
|
||||
>>> net = Network([
|
||||
ConvPoolLayer(image_shape=(mini_batch_size, 1, 28, 28),
|
||||
filter_shape=(20, 1, 5, 5),
|
||||
poolsize=(2, 2),
|
||||
activation_fn=ReLU),
|
||||
ConvPoolLayer(image_shape=(mini_batch_size, 20, 12, 12),
|
||||
filter_shape=(40, 20, 5, 5),
|
||||
poolsize=(2, 2),
|
||||
activation_fn=ReLU),
|
||||
FullyConnectedLayer(n_in=40*4*4, n_out=100, activation_fn=ReLU),
|
||||
FullyConnectedLayer(n_in=100, n_out=100, activation_fn=ReLU),
|
||||
SoftmaxLayer(n_in=100, n_out=10)], mini_batch_size)
|
||||
>>> net.SGD(expanded_training_data, 60, mini_batch_size, 0.03,
|
||||
validation_data, test_data, lmbda=0.1)
|
||||
```
|
||||
|
||||
这次取得了99.43%的精度。拓展后的网络并没有帮助太多。
|
||||
|
||||
（7）使用卷积神经网络 — 两个卷基层+线性修正单元(ReLU)+拓展数据集+继续插入额外的全连接层+弃权技术
|
||||
|
||||
弃权的基本思想就是在训练网络时随机的移除单独的激活值，使得模型对单独的依据丢失更为强劲，因此不太依赖于训练数据的特质。我们尝试应用弃权技术到最终的全连接层(不是在卷基层)。这里，减少了迭代期的数量为40个，全连接层使用1000个隐藏神经元，因为弃权技术会丢弃一些神经元。Dropout是一种非常有效有提高泛化能力，降低过拟合的方法！
|
||||
|
||||
```python
|
||||
>>> net = Network([
|
||||
ConvPoolLayer(image_shape=(mini_batch_size, 1, 28, 28),
|
||||
filter_shape=(20, 1, 5, 5),
|
||||
poolsize=(2, 2),
|
||||
activation_fn=ReLU),
|
||||
ConvPoolLayer(image_shape=(mini_batch_size, 20, 12, 12),
|
||||
filter_shape=(40, 20, 5, 5),
|
||||
poolsize=(2, 2),
|
||||
activation_fn=ReLU),
|
||||
FullyConnectedLayer(
|
||||
n_in=40*4*4, n_out=1000, activation_fn=ReLU, p_dropout=0.5),
|
||||
FullyConnectedLayer(
|
||||
n_in=1000, n_out=1000, activation_fn=ReLU, p_dropout=0.5),
|
||||
SoftmaxLayer(n_in=1000, n_out=10, p_dropout=0.5)],
|
||||
mini_batch_size)
|
||||
>>> net.SGD(expanded_training_data, 40, mini_batch_size, 0.03,
|
||||
validation_data, test_data)
|
||||
```
|
||||
|
||||
使用弃权技术，的到了99.60%的准确率。
|
||||
|
||||
（8）使用卷积神经网络 — 两个卷基层+线性修正单元(ReLU)+正则化+拓展数据集+继续插入额外的全连接层+弃权技术+组合网络
|
||||
|
||||
组合网络类似于随机森林或者adaboost的集成方法，创建几个神经网络，让他们投票来决定最好的分类。我们训练了5个不同的神经网络，每个都大到了99.60%的准去率，用这5个网络来进行投票表决一个图像的分类。
|
||||
|
||||
采用这个方法，达到了99.67%的准确率。
|
||||
|
||||
## 5.26 CNN在CV与NLP领域运用的联系与区别？
|
||||
|
||||
### 5.26.1 联系
|
||||
|
||||
自然语言处理是对一维信号（词序列）做操作。
|
||||
计算机视觉是对二维（图像）或三维（视频流）信号做操作。
|
||||
|
||||
### 5.26.2 区别
|
||||
|
||||
自然语言处理的输入数据通常是离散取值（例如表示一个单词或字母通常表示为词典中的one hot向量），计算机视觉则是连续取值（比如归一化到0，1之间的灰度值）。CNN有两个主要特点，区域不变性(location invariance)和组合性(Compositionality)。
|
||||
|
||||
1. 区域不变性：滤波器在每层的输入向量(图像)上滑动，检测的是局部信息，然后通过pooling取最大值或均值。pooling这步综合了局部特征，失去了每个特征的位置信息。这很适合基于图像的任务，比如要判断一幅图里有没有猫这种生物，你可能不会去关心这只猫出现在图像的哪个区域。但是在NLP里，词语在句子或是段落里出现的位置，顺序，都是很重要的信息。
|
||||
2. 局部组合性：CNN中，每个滤波器都把较低层的局部特征组合生成较高层的更全局化的特征。这在CV里很好理解，像素组合成边缘，边缘生成形状，最后把各种形状组合起来得到复杂的物体表达。在语言里，当然也有类似的组合关系，但是远不如图像来的直接。而且在图像里，相邻像素必须是相关的，相邻的词语却未必相关。
|
||||
|
||||
## 5.27 CNN凸显共性的手段？
|
||||
|
||||
### 5.27.1 局部连接
|
||||
|
||||
感受视野：每个神经元仅与输入神经元的一块区域连接，这块局部区域称作感受野（receptive field）。
|
||||
在图像卷积操作中，即神经元在空间维度是局部连接，但在深度上是全部连接。对于二维图像本身而言，也是局部像素关联较强。这种局部连接保证了学习后的过滤器能够对于局部的输入特征有最强的响应。局部连接的思想，也是受启发于生物学里面的视觉系统结构，视觉皮层的神经元就是局部接受信息的。
|
||||
|
||||
局部连接使网络可以提取数据的局部特征；
|
||||
|
||||
下图是一个很经典的图示，左边是全连接，右边是局部连接。
|
||||
|
||||
|
||||
|
||||
对于一个1000 × 1000的输入图像而言，如果下一个隐藏层的神经元数目为10^6个，采用全连接则有1000 × 1000 × 10^6 = 10^12个权值参数，如此数目巨大的参数几乎难以训练；而采用局部连接，隐藏层的每个神经元仅与图像中10 × 10的局部图像相连接，那么此时的权值参数数量为10 × 10 × 10^6 = 10^8，将直接减少4个数量级。
|
||||
|
||||
### 5.27.2 权值共享
|
||||
|
||||
权重共享：计算同一个深度切片的神经元时采用的滤波器是共享的。例如图4中计算o[:,:,0]的每个每个神经元的滤波器均相同，都为W0，这样可以很大程度上减少参数。共享权重在一定程度上讲是有意义的，例如图片的底层边缘特征与特征在图中的具体位置无关。但是在一些场景中是无意的，比如输入的图片是人脸，眼睛和头发位于不同的位置，希望在不同的位置学到不同的特征 (参考斯坦福大学公开课)。请注意权重只是对于同一深度切片的神经元是共享的，在卷积层，通常采用多组卷积核提取不同特征，即对应不同深度切片的特征，不同深度切片的神经元权重是不共享。另外，偏重对同一深度切片的所有神经元都是共享的。
|
||||
|
||||
权值共享大大降低了网络的训练难度，一个Filter只提取一个特征，在整个图片（或者语音／文本） 中进行卷积
|
||||
|
||||
尽管减少了几个数量级，但参数数量依然较多。能不能再进一步减少呢？能！方法就是权值共享。具体做法是，在局部连接中隐藏层的每一个神经元连接的是一个10 × 10的局部图像，因此有10 × 10个权值参数，将这10 × 10个权值参数共享给剩下的神经元，也就是说隐藏层中10^6个神经元的权值参数相同，那么此时不管隐藏层神经元的数目是多少，需要训练的参数就是这 10 × 10个权值参数（也就是卷积核(也称滤波器)的大小），如下图。
|
||||
|
||||
|
||||
|
||||
这大概就是CNN的一个神奇之处，尽管只有这么少的参数，依旧有出色的性能。但是，这样仅提取了图像的一种特征，如果要多提取出一些特征，可以增加多个卷积核，不同的卷积核能够得到图像的不同映射下的特征，称之为Feature Map。如果有100个卷积核，最终的权值参数也仅为100 × 100 = 10^4个而已。另外，偏置参数也是共享的，同一种滤波器共享一个。
|
||||
|
||||
### 5.27.3 池化操作
|
||||
|
||||
池化操作与多层次结构一起，实现了数据的降维，将低层次的局部特征组合成为较高层次的特征，从而对整个图片进行表示。如下图：
|
||||
|
||||
|
||||
|
||||
### 5.28 全卷积与Local-Conv的异同点
|
||||
|
||||
如果每一个点的处理使用相同的Filter，则为全卷积，如果使用不同的Filter，则为Local-Conv。
|
||||
|
||||
### 5.29 举例理解Local-Conv的作用
|
||||
|
||||
这个问题主要针对：为什么很多做人脸的Paper会最后加入一个Local Connected Conv？总体上说，这一步的作用就是使用3D模型来将人脸对齐，从而使CNN发挥最大的效果。
|
||||
|
||||
|
||||
|
||||
经过3D对齐以后，形成的图像都是152×152的图像，输入到上述网络结构中，该结构的参数如下：
|
||||
|
||||
* Conv：32个11×11×3的卷积核max-pooling: 3×3， stride=2Conv: 16个9×9的卷积核。
|
||||
* Local-Conv: 16个9×9的卷积核，Local的意思是卷积核的参数不共享。
|
||||
* Local-Conv: 16个7×7的卷积核，参数不共享Local-Conv: 16个5×5的卷积核，参数不共享
|
||||
* Fully-connected: 4096维Softmax: 4030维。
|
||||
|
||||
前三层的目的在于提取低层次的特征，比如简单的边和纹理。其中Max-pooling层使得卷积的输出对微小的偏移情况更加鲁棒。但没有用太多的Max-pooling层，因为太多的Max-pooling层会使得网络损失图像信息。
|
||||
|
||||
后面三层都是使用参数不共享的卷积核，之所以使用参数不共享，有如下原因：
|
||||
|
||||
（1）对齐的人脸图片中，不同的区域会有不同的统计特征，卷积的局部稳定性假设并不存在，所以使用相同的卷积核会导致信息的丢失
|
||||
（2）不共享的卷积核并不增加抽取特征时的计算量，而会增加训练时的计算量
|
||||
（3）使用不共享的卷积核，需要训练的参数量大大增加，因而需要很大的数据量，然而这个条件本文刚好满足。
|
||||
|
||||
全连接层将上一层的每个单元和本层的所有单元相连，用来捕捉人脸图像不同位置的特征之间的相关性。其中，第7层（4096-d）被用来表示人脸。
|
||||
|
||||
全连接层的输出可以用于Softmax的输入，Softmax层用于分类。
|
||||
|
||||
## 5.30 简述卷积神经网络进化史
|
||||
|
||||
主要讨论CNN的发展，并且引用刘昕博士的思路，对CNN的发展作一个更加详细的介绍，将按下图的CNN发展史进行描述
|
||||
|
||||
![image](../img/ch5/img67）
|
||||
|
||||
1. 列表项
|
||||
http://mp.weixin.qq.com/s?__biz=MzI1NTE4NTUwOQ==&mid=2650324619&idx=1&sn=ca1aed9e42d8f020d0971e62148e13be&scene=1&srcid=0503De6zpYN01gagUvn0Ht8D#wechat_redirect
|
||||
CNN的演化路径可以总结为以下几个方向：
|
||||
> * 进化之路一：网络结构加深
|
||||
> * 进化之路二：加强卷积功能
|
||||
> * 进化之路三：从分类到检测
|
||||
> * 进化之路四：新增功能模块
|
||||
|
||||
|
|
@ -0,0 +1,497 @@
|
|||
# 第八章 目标检测
|
||||
|
||||
**目标检测负责人：**
|
||||
|
||||
- 稿定科技计算机视觉工程师-刘鹏
|
||||
- 哈工大博士袁笛
|
||||
- 上海大学硕士陈方杰：1609951733@qq.com
|
||||
|
||||
**TODO**
|
||||
|
||||
- [ ] 配图路径待修改
|
||||
|
||||
**目录**
|
||||
|
||||
8.1 基于候选区域的目标检测器
|
||||
|
||||
8.1.1 滑动窗口检测器
|
||||
|
||||
8.1.2 选择性搜索
|
||||
|
||||
8.1.3 R-CNN系列
|
||||
|
||||
8.1.3.1 R-CNN
|
||||
|
||||
8.1.3.2 Fast R-CNN
|
||||
|
||||
8.1.3.3 Faster R-CNN
|
||||
|
||||
8.1.3.4 R-CNN方法的性能
|
||||
|
||||
8.2 基于区域的全卷积神经网络（R-FCN）
|
||||
|
||||
8.3 单次目标检测器
|
||||
|
||||
8.3.1 SSD系列
|
||||
|
||||
8.3.1.1 SSD
|
||||
|
||||
8.3.1.2 DSSD
|
||||
|
||||
8.3.1.3 FSSD
|
||||
|
||||
8.3.2 YOLO系列
|
||||
|
||||
8.3.2.1 YOLOv1
|
||||
|
||||
8.3.2.2 YOLOv2
|
||||
|
||||
8.3.2.3 YOLO9000
|
||||
|
||||
8.3.2.4 YOLOv3
|
||||
|
||||
8.3.3 RetinaNet
|
||||
|
||||
|
||||
|
||||
## 8.1 基于候选区域的目标检测器
|
||||
|
||||
### 8.1.1 滑动窗口检测器
|
||||
|
||||
自从AlexNet获得ILSVRC 2012挑战赛的冠军之后，采用卷积神经网络（Convolutional Neural Network, CNN）进行分类任务就逐渐成为了主流研究方向。最常见的一种采用暴力方法进行目标检测的思路是在图片上从左向右、从上至下通过滑动窗口，利用分类思想进行目标识别。为了能够在不同的观察距离检测不同的目标类型，通常使用不同大小和宽高比的滑动窗口。
|
||||
|
||||
<center><img src="../img/8.1.1.png"></center>
|
||||
|
||||
图8.1.1 滑动窗口示意图（从右向左，从上至下）
|
||||
|
||||
采用滑动窗口从图像中剪切相应的图像块。由于很多分类器只能采用固定大小的图像块，因此这些图像块大多是原始图像块经过变形转换得到的。尽管如此，这样的操作并不影响分类的准确率，因为分类器可以处理变形后的图像块。
|
||||
|
||||
<center><img src="../img/8.1.2.png"></center>
|
||||
|
||||
图8.1.2 将图像转换成固定尺寸的图像
|
||||
|
||||
经过变形后的图像块被输入到CNN分类器中，用来提取出4096维特征。之后，使用SVM分类器识别该图像的类别，并且采用线性回归输出该图像的边界框。
|
||||
|
||||
<center><img src="../img/8.1.3.png"></center>
|
||||
|
||||
图8.1.3 滑动窗口检测器的系统工作流程图
|
||||
|
||||
### 8.1.2 选择性搜索
|
||||
|
||||
除了暴力检测方法之外，选择性搜索也是一种常见的目标检测方法。采用候选区域方法（region proposal method）创建目标检测的感兴趣区域（ROI）。在选择性搜索（selective search，SS）中，假设现在图像上有n个预分割的区域,表示为R={R1, R2, ..., Rn},计算每个region与它相邻region(注意是相邻的区域)的相似度,这样会得到一个n*n的相似度矩阵(同一个区域之间和一个区域与不相邻区域之间的相似度可设为NaN),从矩阵中找出最大相似度值对应的两个区域,将这两个区域合二为一,这时候图像上还剩下n-1个区域;重复上面的过程(只需要计算新的区域与它相邻区域的新相似度,其他的不用重复计算),重复一次,区域的总数目就少1,知道最后所有的区域都合并称为了同一个区域(即此过程进行了n-1次,区域总数目最后变成了1).算法的流程图如下图所示:
|
||||
<center><img src="../img/al8.1.png"></center>
|
||||
|
||||
下图第一行展示了如何使区域增长，第二行中的蓝色矩形代表合并过程中所有可能的ROI。
|
||||
<center><img src="../img/8.1.4.png"></center>
|
||||
|
||||
图8.1.4 选择性搜索
|
||||
### 8.1.3 R-CNN系列
|
||||
|
||||
#### 8.1.3.1 R-CNN
|
||||
|
||||
从2014年CNN就成为用于目标检测的极热门的工具，CNN可以很好地帮我们完成图像识别的任务，我们只需要添加一些额外的功能来完成目标的定位任务即可。使用一个高容量的卷积神经网络将region proposals自底而上的传播，用来定位目标是很好的选择，如果有标签的训练数据比较少，可以使用训练好的参数作为辅助，进行fine-tuning，能够得到非常好的定位效果提升。R-CNN利用候选区域方法创建了约2000个ROI。这些区域被转换为固定大小的图像，并分别馈送到卷积神经网络中。该网络结构后面会跟有几个全连接层，以实现目标分类并提炼出目标的边界框。
|
||||
<center><img src="../img/8.1.5.png"></center>
|
||||
|
||||
图8.1.5 使用候选区域、CNN、仿射层来定位目标
|
||||
使用RCNN进行目标检测，主要分三个部分：（1）产生不依赖与特定类别的region proposals，这些region proposals定义了一个整个检测器可以获得的候选目标；（2）一个大的卷积神经网络，对每个region产生一个固定长度的特征向量；（3）一系列特定类别的线性SVM分类器。以下是R-CNN整个系统的流程图：
|
||||
<center><img src="../img/8.1.6.png"></center>
|
||||
|
||||
图8.1.6 采用R-CNN进行目标检测的流程图
|
||||
通过使用更少且更高质量的ROI，采用R-CNN能够比采用滑动窗口方法更快速、更准确地进行目标检测。
|
||||
|
||||
##### 边界框回归器
|
||||
|
||||
采用候选区域方法进行目标检测具有非常高的计算复杂度。为了加速这个过程，通常会使用计算量较少的候选区域选择方法构建ROI，并在后面使用线性回归器（使用全连接层）进一步提炼边界框。
|
||||
<center><img src="../img/8.1.7.png"></center>
|
||||
|
||||
图8.1.7 使用回归方法将蓝色的原始边界框提炼为红色
|
||||
|
||||
#### 8.1.3.2 Fast R-CNN
|
||||
|
||||
R-CNN需要非常多的候选区域以提升目标检测的准确度，但其实有很多区域是彼此重叠的，因此使得R-CNN的训练和推断速度非常慢。如果我们有2000个候选区域，且每个候选区域都需要独立地馈送到CNN中，那么对于不同的ROI，我们需要重复提取2000次特征。此外，CNN中的特征图以一种密集的方式表征空间特征，是否能直接使用特征图代替原图来检测目标。
|
||||
<center><img src="../img/8.1.8.png"></center>
|
||||
|
||||
图8.1.8 图像特征图
|
||||
<center><img src="../img/8.1.9.png"></center>
|
||||
|
||||
图8.1.9 直接利用特征图计算ROI
|
||||
Fast R-CNN使用特征提取器（CNN）提取整个图像的特征，而不是从头开始对每个图像块提取多次。可以将创建候选区域的方法直接应用到提取到的特征图上。例如，Fast R-CNN选择VGG16中的卷积层Conv5来生成ROI，这些关注区域随后会结合对应的特征图以裁剪为特征图块，并用于目标检测任务中。我们使用ROI池化将特征图块转换为固定的大小，并馈送到全连接层进行分类和定位。因为Fast-RCNN不会重复提取特征，因此它能显著地减少处理时间。
|
||||
<center><img src="../img/8.1.10.png"></center>
|
||||
|
||||
图8.1.10
|
||||
将候选区域直接应用于特征图，并使用ROI池化将其转化为固定大小的特征图块。以下是Fast R-CNN的流程图：
|
||||
<center><img src="../img/8.1.11.png"></center>
|
||||
|
||||
图8.1.11 Fast R-CNN流程图
|
||||
Fast R-CNN最重要的一点就是包含特征提取器、分类器和边界框回归器在内的整个网络能通过多任务损失函数进行端到端的训练，这种多任务损失即结合了分类损失和定位损失的方法，大大提升了模型准确度。
|
||||
|
||||
##### ROI池化
|
||||
|
||||
因为Fast R-CNN使用全连接层，所以应用ROI池化将不同大小的ROI转换为固定大小。为简洁起见，我们先将8×8特征图转换为预定义的2×2大小。下图左上角：特征图。右上角：将ROI（蓝色区域）与特征图重叠。左下角：将ROI拆分为目标维度。例如，对于2×2目标，我们将ROI分割为4个大小相似或相等的部分。右下角：找到每个部分的最大值，得到变换后的特征图。
|
||||
<center><img src="../img/8.1.12.png"></center>
|
||||
|
||||
图7.1.12 ROI池化
|
||||
输入特征图（左上），输出特征图（右下），ROI(右上，蓝色框)。按上述步骤得到一个2×2的特征图块，可以馈送至分类器和边界框的回归器中。
|
||||
|
||||
#### 8.1.3.3 Faster R-CNN
|
||||
|
||||
Fast R-CNN依赖于外部候选区域方法，如选择性搜索。但这些算法在CPU上运行且速度很慢。在测试中，Fast R-CNN需要2.3秒来进行预测，其中2秒用于生成2000个ROI。Faster R-CNN采用与Fast R-CNN相同的设计，只是它用内部深层网络代替了候选区域方法。新的候选区域网络（RPN）在生成ROI时效率更高，并且以每幅图像10毫秒的速度运行。
|
||||
<center><img src="../img/8.1.13.png"></center>
|
||||
|
||||
图8.1.13 Faster R-CNN的流程图
|
||||
Faster R-CNN的流程图与Fast R-CNN相同，采用外部候选区域方法代替了内部深层网络。
|
||||
<center><img src="../img/8.1.14.png"></center>
|
||||
|
||||
图8.1.14
|
||||
|
||||
##### 候选区域网络
|
||||
|
||||
候选区域网络（RPN）将第一个卷积网络的输出特征图作为输入。它在特征图上滑动一个3×3的卷积核，以使用卷积网络（如下所示的ZF网络）构建与类别无关的候选区域。其他深度网络（如VGG或ResNet）可用于更全面的特征提取，但这需要以速度为代价。ZF网络最后会输出256个值，它们将馈送到两个独立的全连接层，以预测边界框和两个objectness分数，这两个objectness分数度量了边界框是否包含目标。我们其实可以使用回归器计算单个objectness分数，但为简洁起见，Faster R-CNN使用只有两个类别的分类器：即带有目标的类别和不带有目标的类别。
|
||||
<center><img src="../img/8.1.15.png"></center>
|
||||
|
||||
图8.1.15
|
||||
对于特征图中的每一个位置，RPN会做k次预测。因此，RPN将输出4×k个坐标和每个位置上2×k个得分。下图展示了8×8的特征图，且有一个3×3的卷积核执行运算，它最后输出8×8×3个ROI（其中k=3）。下图（右）展示了单个位置的3个候选区域。
|
||||
<center><img src="../img/8.1.16.png"></center>
|
||||
|
||||
图8.1.16
|
||||
假设最好涵盖不同的形状和大小。因此，Faster R-CNN不会创建随机边界框。相反，它会预测一些与左上角名为锚点的参考框相关的偏移量（如x, y）。我们限制这些偏移量的值，因此我们的猜想仍然类似于锚点。
|
||||
<center><img src="../img/8.1.17.png"></center>
|
||||
|
||||
图8.1.17
|
||||
要对每个位置进行k个预测，我们需要以每个位置为中心的k个锚点。每个预测与特定锚点相关联，但不同位置共享相同形状的锚点。
|
||||
<center><img src="../img/8.1.18.png"></center>
|
||||
|
||||
图8.1.18
|
||||
这些锚点是精心挑选的，因此它们是多样的，且覆盖具有不同比例和宽高比的现实目标。这使得我们可以用更好的猜想来指导初始训练，并允许每个预测专门用于特定的形状。该策略使早期训练更加稳定和简便。
|
||||
<center><img src="../img/8.1.19.png"></center>
|
||||
|
||||
图8.1.19
|
||||
Faster R-CNN使用更多的锚点。它部署9个锚点框：3个不同宽高比的3个不同大小的锚点框。每一个位置使用9个锚点，每个位置会生成2×9个objectness分数和4×9个坐标。
|
||||
|
||||
#### 8.1.3.4 R-CNN方法的性能
|
||||
|
||||
如下图所示，Faster R-CNN的速度要快得多。
|
||||
<center><img src="../img/8.1.20.png"></center>
|
||||
|
||||
图8.1.20性能对比
|
||||
|
||||
|
||||
|
||||
表8.1.1 性能对比
|
||||
|
||||
## 8.2 基于区域的全卷积神经网络（R-FCN）
|
||||
|
||||
假设我们只有一个特征图用来检测右眼。那么我们可以使用它定位人脸吗？应该可以。因为右眼应该在人脸图像的左上角，所以我们可以利用这一点定位整个人脸。如果我们还有其他用来检测左眼、鼻子或嘴巴的特征图，那么我们可以将检测结果结合起来，更好地定位人脸。现在我们回顾一下所有问题。在Faster R-CNN中，检测器使用了多个全连接层进行预测。如果有2000个ROI，那么成本非常高。R-FCN通过减少每个ROI所需的工作量实现加速。上面基于区域的特征图与ROI是独立的，可以在每个ROI之外单独计算。剩下的工作就比较简单了，因此R-FCN的速度比Faster R-CNN快。
|
||||
<center><img src="../img/8.2.1.png"></center>
|
||||
|
||||
图8.2.1 人脸检测
|
||||
现在我们来看一下5×5的特征图M，内部包含一个蓝色方块。我们将方块平均分成3×3个区域。现在，我们在M中创建了一个新的特征图，来检测方块的左上角（TL）。这个新的特征图如下图（右）所示。只有黄色的网格单元[2,2]处于激活状态。在左侧创建一个新的特征图，用于检测目标的左上角。
|
||||
<center><img src="../img/8.2.2.png"></center>
|
||||
|
||||
图8.2.2 检测示例
|
||||
我们将方块分成9个部分，由此创建了9个特征图，每个用来检测对应的目标区域。这些特征图叫做位置敏感得分图（position-sensitive score map），因为每个图检测目标的子区域（计算其得分）。
|
||||
<center><img src="../img/8.2.3.png"></center>
|
||||
|
||||
图8.2.3生成9个得分图
|
||||
下图中红色虚线矩形是建议的ROI。我们将其分割成3×3个区域，并询问每个区域包含目标对应部分的概率是多少。例如，左上角ROI区域包含左眼的概率。我们将结果存储成3×3 vote数组，如下图（右）所示。例如，vote_array[0][0]包含左上角区域是否包含目标对应部分的得分。
|
||||
<center><img src="../img/8.2.4.png"></center>
|
||||
|
||||
图8.2.4
|
||||
将ROI应用到特征图上，输出一个3x3数组。将得分图和ROI映射到vote数组的过程叫做位置敏感ROI池化（position-sensitive ROI-pool）。该过程与前面讨论过的ROI池化非常接近。
|
||||
<center><img src="../img/8.2.5.png"></center>
|
||||
|
||||
图8.2.5
|
||||
将ROI的一部分叠加到对应的得分图上，计算V[i][j]。在计算出位置敏感ROI池化的所有值后，类别得分是其所有元素得分的平均值。
|
||||
<center><img src="../img/8.2.6.png"></center>
|
||||
|
||||
图8.2.6 ROI池化
|
||||
假如我们有C个类别要检测。我们将其扩展为C+1个类别，这样就为背景（非目标）增加了一个新的类别。每个类别有3×3个得分图，因此一共有(C+1)×3×3个得分图。使用每个类别的得分图可以预测出该类别的类别得分。然后我们对这些得分应用 softmax 函数，计算出每个类别的概率。以下是数据流图，在本案例中，k=3。
|
||||
<center><img src="../img/8.2.7.png"></center>
|
||||
|
||||
图8.2.7
|
||||
|
||||
## 8.3 单次目标检测器
|
||||
|
||||
我们将对单次目标检测器（包括SSD、YOLO、YOLOv2、YOLOv3）进行综述。我们将分析FPN以理解多尺度特征图如何提高准确率，特别是小目标的检测，其在单次检测器中的检测效果通常很差。然后我们将分析Focal loss和RetinaNet，看看它们是如何解决训练过程中的类别不平衡问题的。
|
||||
### 8.3.1 SSD系列
|
||||
|
||||
#### 8.3.1.1 SSD
|
||||
|
||||
```
|
||||
Faster R-CNN中，在分类器之后有一个专用的候选区域网络。
|
||||
```
|
||||
|
||||
<center><img src="../img/8.3.1.png"></center>
|
||||
|
||||
```
|
||||
图8.3.1 Faster R-CNN工作流
|
||||
基于区域的检测器是很准确的，但需要付出代价。Faster R-CNN在PASCAL VOC 2007测试集上每秒处理7帧的图像（7FPS）。和R-FCN类似，研究者通过减少每个ROI的工作量来精简流程。
|
||||
作为替代，我们是否需要一个分离的候选区域步骤？我们可以直接在一个步骤内得到边界框和类别吗？
|
||||
```
|
||||
|
||||
```
|
||||
让我们再看一下滑动窗口检测器。我们可以通过在特征图上滑动窗口来检测目标。对于不同的目标类型，我们使用不同的窗口类型。以前的滑动窗口方法的致命错误在于使用窗口作为最终的边界框，这就需要非常多的形状来覆盖大部分目标。更有效的方法是将窗口当作初始猜想，这样我们就得到了从当前滑动窗口同时预测类别和边界框的检测器。
|
||||
```
|
||||
|
||||
<center><img src="../img/8.3.2.png"></center>
|
||||
|
||||
```
|
||||
图8.3.2
|
||||
基于滑动窗口进行预测这个概念和Faster R-CNN中的锚点很相似。然而，单次检测器会同时预测边界框和类别。例如，我们有一个8×8特征图，并在每个位置做出k个预测，即总共有8×8×k个预测结果。
|
||||
```
|
||||
|
||||
<center><img src="../img/8.3.3.png"></center>
|
||||
|
||||
```
|
||||
图8.3.3 64个位置
|
||||
在每个位置，我们有k个锚点（锚点是固定的初始边界框猜想），一个锚点对应一个特定位置。我们使用相同的锚点形状仔细地选择锚点和每个位置。
|
||||
```
|
||||
|
||||
<center><img src="../img/8.3.4.png"></center>
|
||||
|
||||
```
|
||||
图8.3.4 使用4个锚点在每个位置做出4个预测
|
||||
以下是4个锚点（绿色）和4个对应预测（蓝色），每个预测对应一个特定锚点。在Faster R-CNN中，我们使用卷积核来做5个参数的预测：4个参数对应某个锚点的预测边框，1个参数对应objectness置信度得分。因此3×3×D×5卷积核将特征图从8×8×D转换8×8×5。
|
||||
```
|
||||
|
||||
<center><img src="../img/8.3.5.png"></center>
|
||||
|
||||
```
|
||||
图8.3.5 4个预测，每个预测对应一个锚点
|
||||
```
|
||||
|
||||
<center><img src="../img/8.3.6.png"></center>
|
||||
|
||||
```
|
||||
图8.3.6 使用3×3卷积核计算预测
|
||||
在单次检测器中，卷积核还预测C个类别概率以执行分类（每个概率对应一个类别）。因此我们应用一个3×3×D×25卷积核将特征图从8×8×D转换为8×8×25（C=20）。
|
||||
```
|
||||
|
||||
<center><img src="../img/8.3.7.png"></center>
|
||||
|
||||
```
|
||||
图8.3.7 每个位置做出k个预测，每个预测有25个参数
|
||||
单次检测器通常需要在准确率和实时处理速度之间进行权衡。它们在检测太近距离或太小的目标时容易出现问题。
|
||||
```
|
||||
|
||||
SSD是使用VGG19网络作为特征提取器（和Faster R-CNN中使用的CNN一样）的单次检测器。我们在该网络之后添加自定义卷积层（蓝色），并使用卷积核（绿色）执行预测。
|
||||
<center><img src="../img/8.3.8.png"></center>
|
||||
|
||||
图8.3.8 同时对类别和位置执行单次预测
|
||||
然而，卷积层降低了空间维度和分辨率。因此上述模型仅可以检测较大的目标。为了解决该问题，我们从多个特征图上执行独立的目标检测。
|
||||
<center><img src="../img/8.3.9.png"></center>
|
||||
|
||||
图8.3.9 使用多尺度特征图用于检测
|
||||
#### 8.3.1.2 DSSD
|
||||
|
||||
TODO
|
||||
|
||||
#### 8.3.1.3 FSSD
|
||||
|
||||
TODO
|
||||
|
||||
### 8.3.2 YOLO系列
|
||||
|
||||
#### 8.3.2.1 YOLOv1
|
||||
YOLO之前的物体检测系统使用分类器来完成物体检测任务。为了检测一个物体，这些物体检测系统要在一张测试图的不同位置和不同尺寸的bounding box上使用该物体的分类器去评估是否有该物体。如DPM系统，要使用一个滑窗（sliding window）在整张图像上均匀滑动，用分类器评估是否有物体。
|
||||
在DPM之后提出的其他方法，如R-CNN方法使用region proposal来生成整张图像中可能包含待检测物体的potential bounding boxes，然后用分类器来评估这些boxes，接着通过post-processing来改善bounding boxes，消除重复的检测目标，并基于整个场景中的其他物体重新对boxes进行打分。整个流程执行下来很慢，而且因为这些环节都是分开训练的，检测性能很难进行优化。
|
||||
作者设计了YOLO（You Only Look Once: Unified, Real-Time Object Detection），将物体检测任务当作回归问题（regression problem）来处理，直接通过整张图片的所有像素得到bounding box的坐标、box中包含物体的置信度和class probabilities。通过YOLO，每张图像只需要看一眼就能得出图像中都有哪些物体和这些物体的位置。
|
||||
|
||||
图7.4.1
|
||||
如图所示，使用YOLO来检测物体，其流程是非常简单明了的：（1）将图像resize到448×448作为神经网络的输入；（2）运行神经网络，得到一些bounding box坐标、box中包含物体的置信度和class probabilities；（3）进行非极大值抑制，筛选Boxes。下图是各物体检测系统的检测流程对比：
|
||||
|
||||
图7.4.2
|
||||
##### （1）Unified Detection
|
||||
YOLO将输入图像划分为S×S的栅格，每个栅格负责检测中心落在该栅格中的物体,如下图所示：
|
||||
|
||||
图7.4.3
|
||||
每一个栅格预测B个bounding boxes，以及这些bounding boxes的confidence scores。这个confidence scores反映了模型对于这个栅格的预测：该栅格是否含有物体，以及这个box的坐标预测的有多准。如果这个栅格中不存在一个object，则confidence score应该为0；否则的话，confidence score则为predicted bounding box与ground truth box之间的IOU（intersection over union）。YOLO对每个bounding box有5个predictions：x, y, w, h, and confidence。坐标x,y代表了预测的bounding box的中心与栅格边界的相对值。坐标w,h代表了预测的bounding box的width、height相对于整幅图像width,height的比例。confidence就是预测的bounding box和ground truth box的IOU值。
|
||||
|
||||
图7.4.4
|
||||
|
||||
图7.4.5
|
||||
每一个栅格还要预测C个conditional class probability（条件类别概率）：Pr(Classi|Object)。即在一个栅格包含一个Object的前提下，它属于某个类的概率。只为每个栅格预测一组（C个）类概率，而不考虑框B的数量。
|
||||
|
||||
图7.4.6
|
||||
注意：conditional class probability信息是针对每个网格的。confidence信息是针对每个bounding box的。在测试阶段，将每个栅格的conditional class probabilities与每个bounding box的confidence相乘。这样既可得到每个bounding box的具体类别的confidence score。这乘积既包含了bounding box中预测的class的probability信息，也反映了bounding box是否含有Object和bounding box坐标的准确度。
|
||||
|
||||
图7.4.7
|
||||
将YOLO用于PASCAL VOC数据集时：论文使用的S=7，即将一张图像分为7×7=49个栅格每一个栅格预测B=2个boxes（每个box有x, y, w, h, confidence，5个预测值），同时C=20（PASCAL数据集中有20个类别）。因此，最后的prediction是7×7×30{即S×S×(B×5+C)}的Tensor。
|
||||
|
||||
图7.4.8
|
||||
|
||||
图7.4.9
|
||||
|
||||
图7.4.10
|
||||
|
||||
##### （2）Network Design
|
||||
YOLO检测网络包括24个卷积层和2个全连接层,如图所示：
|
||||
|
||||
图7.4.11
|
||||
|
||||
图7.4.12
|
||||
其中，卷积层用来提取图像特征，全连接层用来预测图像位置和类别概率值。YOLO网络借鉴了GoogLeNet分类网络结构。不同的是，YOLO未使用inception module，而是使用1×1卷积层（此处1x1卷积层的存在是为了跨通道信息整合）3×3卷积层进行简单替代。
|
||||
|
||||
##### （3）Training
|
||||
首先利用ImageNet 1000-class的分类任务数据集Pretrain卷积层。使用上述网络中的前20个卷积层，加上一个average-pooling layer，最后加一个全连接层，作为Pretrain的网络。训练大约一周的时间，使得在ImageNet 2012的验证数据集Top-5的精度达到88%，这个结果跟GoogleNet的效果相当。将Pretrain的结果的前20层卷积层应用到Detection中，并加入剩下的4个卷积层及2个全连接。同时为了获取更精细化的结果，将输入图像的分辨率由224×224提升到448×448。将所有的预测结果都归一化到0-1,使用Leaky RELU作为激活函数。为了防止过拟合，在第一个全连接层后面接了一个ratio=0.5的Dropout层。为了提高精度，对原始图像做数据提升。
|
||||
|
||||
##### （4）损失函数
|
||||
损失函数的设计目标就是让坐标（x,y,w,h），confidence，classification这个三个方面达到很好的平衡。简单的全部采用了sum-squared error loss来做这件事会有以下不足：（1）8维的localization error和20维的classification error同等重要显然是不合理的；（2）如果一些栅格中没有object（一幅图中这种栅格很多），那么就会将这些栅格中的bounding box的confidence置为0，相比于较少的有object的栅格，这些不包含物体的栅格对梯度更新的贡献会远大于包含物体的栅格对梯度更新的贡献，这会导致网络不稳定甚至发散。
|
||||
|
||||
图7.4.13
|
||||
解决方案如下：更重视8维的坐标预测，给这些损失前面赋予更大的loss weight,记为λcoord,在pascal VOC训练中取5（上图蓝色框）。对没有object的bbox的confidence loss，赋予小的loss weight，记为λnoobj，在pascal VOC训练中取0.5（上图橙色框）。有object的bbox的confidence loss(上图红色框)和类别的loss（上图紫色框）的loss weight正常取1。
|
||||
对不同大小的bbox预测中，相比于大bbox预测偏一点，小box预测偏相同的尺寸对IOU的影响更大。而sum-square error loss中对同样的偏移loss是一样。为了缓和这个问题，作者用了一个巧妙的办法，就是将box的width和height取平方根代替原本的height和width。在YOLO中，每个栅格预测多个bounding box，但在网络模型的训练中，希望每一个物体最后由一个bounding box predictor来负责预测。因此，当前哪一个predictor预测的bounding box与ground truth box的IOU最大，这个predictor就负责predict object。这会使得每个predictor可以专门的负责特定的物体检测。随着训练的进行，每一个predictor对特定的物体尺寸、长宽比的物体的类别的预测会越来越好。
|
||||
|
||||
|
||||
图7.4.14神经网络输出后的检测流程
|
||||
|
||||
图7.4.15
|
||||
|
||||
##### （5）非极大值抑制
|
||||
|
||||
|
||||
|
||||
图7.4.16
|
||||
|
||||
##### （6）获取Object Detect结果
|
||||
|
||||
图7.4.17
|
||||
|
||||
##### YOLOv1模型优缺点
|
||||
##### （1）YOLO检测物体非常快。
|
||||
因为没有复杂的检测流程，只需要将图像输入到神经网络就可以得到检测结果，YOLO可以非常快的完成物体检测任务。标准版本的YOLO在TitanX的GPU上能达到45FPS。更快的Fast YOLO检测速度可以达到155FPS。而且，YOLO的mAP是之前其他实时物体检测系统的两倍以上。
|
||||
|
||||
##### （2）YOLO可以很好的避免背景错误，产生false positives。
|
||||
不像其他物体检测系统使用了滑窗或region proposal，分类器只能得到图像的局部信息。YOLO在训练和测试时都能够看到一整张图像的信息，因此YOLO在检测物体时能很好的利用上下文信息，从而不容易在背景上预测出错误的物体信息。和Fast-R-CNN相比，YOLO的背景错误不到Fast-R-CNN的一半。
|
||||
##### （3）YOLO可以学到物体的泛化特征。
|
||||
当YOLO在自然图像上做训练，在艺术作品上做测试时，YOLO表现的性能比DPM、R-CNN等之前的物体检测系统要好很多。因为YOLO可以学习到高度泛化的特征，从而迁移到其他领域。
|
||||
尽管YOLO有这些优点，它也有一些缺点：（1）YOLO的物体检测精度低于其他state-of-the-art的物体检测系统；（2）YOLO容易产生物体的定位错误；（3）YOLO对小物体的检测效果不好（尤其是密集的小物体，因为一个栅格只能预测2个物体）。
|
||||
下图是各物体检测系统的检测性能对比：
|
||||
|
||||
图7.4.18
|
||||
#### 8.3.2.2 YOLOv2
|
||||
YOLOv2相比YOLOv1做了很多方面的改进，这也使得YOLOv2的mAP有显著的提升，并且YOLOv2的速度依然很快，保持着自己作为one-stage方法的优势，YOLOv2和Faster R-CNN,SSD等模型的对比如图7.4.19所示。
|
||||
|
||||
图7.4.19 YOLOv2与其它模型在VOC 2007数据集上的效果对比
|
||||
YOLOv1虽然检测速度很快，但是在检测精度上却不如R-CNN系检测方法，YOLOv1在物体定位方面（localization）不够准确，并且召回率（recall）较低。YOLOv2共提出了几种改进策略来提升YOLO模型的定位准确度和召回率，从而提高mAP，YOLOv2在改进中遵循一个原则：保持检测速度，这也是YOLO模型的一大优势。YOLOv2的改进策略如图7.4.20所示，可以看出，大部分的改进方法都可以比较显著提升模型的mAP。
|
||||
##### YOLOv2改进策略
|
||||
|
||||
图7.4.20 YOLOv2相比YOLOv1的改进策略
|
||||
##### （1）Batch Normalization
|
||||
Batch Normalization可以提升模型收敛速度，而且可以起到一定正则化效果，降低模型的过拟合。在YOLOv2中，每个卷积层后面都添加了Batch Normalization层，并且不再使用droput。使用Batch Normalization后，YOLOv2的mAP提升了2.4%。
|
||||
|
||||
##### （2）High Resolution Classifier
|
||||
目前的目标检测方法中，基本上都会使用ImageNet预训练过的模型（classifier）来提取特征，如果用的是AlexNet网络，那么输入图片会被resize到不足256×256，导致分辨率不够高，给检测带来困难。为此，新的YOLO网络把分辨率直接提升到了448×448，这也意味之原有的网络模型必须进行某种调整以适应新的分辨率输入。
|
||||
对于YOLOv2，作者首先对分类网络（自定义的darknet）进行了fine tune，分辨率改成448×448，在ImageNet数据集上训练10轮（10epochs），训练后的网络就可以适应高分辨率的输入了。然后，作者对检测网络部分（也就是后半部分）也进行fine tune。这样通过提升输入的分辨率，mAP获得了4%的提升。
|
||||
|
||||
##### （3）Convolutional With Anchor Boxes
|
||||
之前的YOLO利用全连接层的数据完成边框的预测，导致丢失较多的空间信息，定位不准。作者在这一版本中借鉴了Faster R-CNN中的anchor思想，回顾一下，anchor是RNP网络中的一个关键步骤，说的是在卷积特征图上进行滑窗操作，每一个中心可以预测9种不同大小的建议框。
|
||||
|
||||
图7.4.21
|
||||
为了引入anchor boxes来预测bounding boxes，作者在网络中果断去掉了全连接层。剩下的具体怎么操作呢？
|
||||
首先，作者去掉了后面的一个池化层以确保输出的卷积特征图有更高的分辨率。然后，通过缩减网络，让图片输入分辨率为416×416，这一步的目的是为了让后面产生的卷积特征图宽高都为奇数，这样就可以产生一个center cell。作者观察到，大物体通常占据了图像的中间位置，就可以只用中心的一个cell来预测这些物体的位置，否则就要用中间的4个cell来进行预测，这个技巧可稍稍提升效率。最后，YOLOv2使用了卷积层降采样（factor为32），使得输入卷积网络的416×416图片最终得到13×13的卷积特征图（416/32=13）。加入了anchor boxes后，可以预料到的结果是召回率上升，准确率下降。我们来计算一下，假设每个cell预测9个建议框，那么总共会预测13×13×9=1521个boxes，而之前的网络仅仅预测7×7×2=98个boxes。具体数据为：没有anchor boxes，模型recall为81%，mAP为69.5%；加入anchor boxes，模型recall为88%，mAP为69.2%。这样看来，准确率只有小幅度的下降，而召回率则提升了7%，说明可以通过进一步的工作来加强准确率，的确有改进空间。
|
||||
|
||||
##### （4）Dimension Clusters（维度聚类）
|
||||
作者在使用anchor的时候遇到了两个问题，第一个是anchor boxes的宽高维度往往是精选的先验框（hand-picked priors），虽说在训练过程中网络也会学习调整boxes的宽高维度，最终得到准确的bounding boxes。但是，如果一开始就选择了更好的、更有代表性的先验boxes维度，那么网络就更容易学到准确的预测位置。和以前的精选boxes维度不同，作者使用了K-means聚类方法类训练bounding boxes，可以自动找到更好的boxes宽高维度。传统的K-means聚类方法使用的是欧氏距离函数，也就意味着较大的boxes会比较小的boxes产生更多的error，聚类结果可能会偏离。为此，作者采用的评判标准是IOU得分（也就是boxes之间的交集除以并集），这样的话，error就和box的尺度无关了，最终的距离函数为：
|
||||
|
||||
作者通过改进的K-means对训练集中的boxes进行了聚类，判别标准是平均IOU得分，聚类结果如下图：
|
||||
|
||||
图7.4.22数据集VOC和COCO上的边界框聚类分析结果
|
||||
可以看到，平衡复杂度和IOU之后，最终得到k值为5，意味着作者选择了5种大小的box维度来进行定位预测，这与手动精选的box维度不同。结果中扁长的框较少，而瘦高的框更多（这符合行人的特征），这种结论如不通过聚类实验恐怕是发现不了的。当然，作者也做了实验来对比两种策略的优劣，如下图，使用聚类方法，仅仅5种boxes的召回率就和Faster R-CNN的9种相当。说明K-means方法的引入使得生成的boxes更具有代表性，为后面的检测任务提供了便利。
|
||||
表7.4.1
|
||||
|
||||
|
||||
##### （5）New Network：Darknet-19
|
||||
YOLOv2采用了一个新的基础模型（特征提取器），称为Darknet-19，包括19个卷积层和5个maxpooling层，如图4所示。Darknet-19与VGG16模型设计原则是一致的，主要采用3*3卷积，采用2*2的maxpooling层之后，特征图维度降低2倍，而同时将特征图的channles增加两倍。与NIN(Network in Network)类似，Darknet-19最终采用global avgpooling做预测，并且在3*3卷积之间使用1*1卷积来压缩特征图channles以降低模型计算量和参数。Darknet-19每个卷积层后面同样使用了batch norm层以加快收敛速度，降低模型过拟合。在ImageNet分类数据集上，Darknet-19的top-1准确度为72.9%，top-5准确度为91.2%，但是模型参数相对小一些。使用Darknet-19之后，YOLOv2的mAP值没有显著提升，但是计算量却可以减少约33%。
|
||||
表7.4.2
|
||||
|
||||
|
||||
##### （6）Direct location prediction
|
||||
前面讲到，YOLOv2借鉴RPN网络使用anchor boxes来预测边界框相对先验框的offsets。边界框的实际中心位置 ，需要根据预测的坐标偏移值 ，先验框的尺度 以及中心坐标 （特征图每个位置的中心点）来计算：
|
||||
|
||||
但是上面的公式是无约束的，预测的边界框很容易向任何方向偏移，如当 时边界框将向右偏移先验框的一个宽度大小，而当 时边界框将向左偏移先验框的一个宽度大小，因此每个位置预测的边界框可以落在图片任何位置，这导致模型的不稳定性，在训练时需要很长时间来预测出正确的offsets。所以，YOLOv2弃用了这种预测方式，而是沿用YOLOv1的方法，就是预测边界框中心点相对于对应cell左上角位置的相对偏移值，为了将边界框中心点约束在当前cell中，使用sigmoid函数处理偏移值，这样预测的偏移值在(0,1)范围内（每个cell的尺度看做1）。总结来看，根据边界框预测的4个offsets： ，可以按如下公式计算出边界框实际位置和大小：
|
||||
|
||||
其中为 为cell的左上角坐标，如图5所示，在计算时每个cell的尺度为1，所以当前cell的左上角坐标为(1,1)。由于sigmoid函数的处理，边界框的中心位置会约束在当前cell内部，防止偏移过多。而 和 是先验框的宽度与长度，前面说过它们的值也是相对于特征图大小的，在特征图中每个cell的长和宽均为1。这里记特征图的大小为 （在文中是(13,13))，这样我们可以将边界框相对于整张图片的位置和大小计算出来（4个值均在0和1之间）：
|
||||
|
||||
如果再将上面的4个值分别乘以图片的宽度和长度（像素点值）就可以得到边界框的最终位置和大小了。这就是YOLOv2边界框的整个解码过程。约束了边界框的位置预测值使得模型更容易稳定训练，结合聚类分析得到先验框与这种预测方法，YOLOv2的mAP值提升了约5%。
|
||||
|
||||
图7.4.23边界框位置与大小的计算示例图
|
||||
|
||||
##### （7）Fine-Grained Features
|
||||
YOLOv2的输入图片大小为416*416，经过5次maxpooling之后得到13*13大小的特征图，并以此特征图采用卷积做预测。13*13大小的特征图对检测大物体是足够了，但是对于小物体还需要更精细的特征图（Fine-Grained Features）。因此SSD使用了多尺度的特征图来分别检测不同大小的物体，前面更精细的特征图可以用来预测小物体。YOLOv2提出了一种passthrough层来利用更精细的特征图。YOLOv2所利用的Fine-Grained Features是26*26大小的特征图（最后一个maxpooling层的输入），对于Darknet-19模型来说就是大小为26*26*512的特征图。passthrough层与ResNet网络的shortcut类似，以前面更高分辨率的特征图为输入，然后将其连接到后面的低分辨率特征图上。前面的特征图维度是后面的特征图的2倍，passthrough层抽取前面层的每个2*2的局部区域，然后将其转化为channel维度，对于26*26*512的特征图，经passthrough层处理之后就变成了13*13*2048的新特征图（特征图大小降低4倍，而channles增加4倍，图6为一个实例），这样就可以与后面的13*13*1024特征图连接在一起形成13*13*3072的特征图，然后在此特征图基础上卷积做预测。在YOLO的C源码中，passthrough层称为reorg layer。
|
||||
另外，作者在后期的实现中借鉴了ResNet网络，不是直接对高分辨特征图处理，而是增加了一个中间卷积层，先采用64个1*1卷积核进行卷积，然后再进行passthrough处理，这样26*26*512的特征图得到13*13*256的特征图。这算是实现上的一个小细节。使用Fine-Grained Features之后YOLOv2的性能有1%的提升。
|
||||
|
||||
##### （8）Multi-Scale Training
|
||||
由于YOLOv2模型中只有卷积层和池化层，所以YOLOv2的输入可以不限于416*416大小的图片。为了增强模型的鲁棒性，YOLOv2采用了多尺度输入训练策略，具体来说就是在训练过程中每间隔一定的iterations之后改变模型的输入图片大小。由于YOLOv2的下采样总步长为32，输入图片大小选择一系列为32倍数的值：输入图片最小为320*320，此时对应的特征图大小为10*10（不是奇数了，确实有点尴尬），而输入图片最大为608*608,对应的特征图大小为19*19,在训练过程，每隔10个iterations随机选择一种输入图片大小，然后只需要修改对最后检测层的处理就可以重新训练。
|
||||
|
||||
图7.4.24 Multi-Scale Training
|
||||
采用Multi-Scale Training策略，YOLOv2可以适应不同大小的图片，并且预测出很好的结果。在测试时，YOLOv2可以采用不同大小的图片作为输入，在VOC 2007数据集上的效果如下图所示。可以看到采用较小分辨率时，YOLOv2的mAP值略低，但是速度更快，而采用高分辨输入时，mAP值更高，但是速度略有下降，对于544*544,mAP高达78.6%。注意，这只是测试时输入图片大小不同，而实际上用的是同一个模型（采用Multi-Scale Training训练）。
|
||||
|
||||
图7.4.25 YOLOv2在VOC 2007数据集上的性能对比
|
||||
|
||||
总结来看，虽然YOLOv2做了很多改进，但是大部分都是借鉴其它论文的一些技巧，如Faster R-CNN的anchor boxes，YOLOv2采用anchor boxes和卷积做预测，这基本上与SSD模型（单尺度特征图的SSD）非常类似了，而且SSD也是借鉴了Faster R-CNN的RPN网络。从某种意义上来说，YOLOv2和SSD这两个one-stage模型与RPN网络本质上无异，只不过RPN不做类别的预测，只是简单地区分物体与背景。在two-stage方法中，RPN起到的作用是给出region proposals，其实就是作出粗糙的检测，所以另外增加了一个stage，即采用R-CNN网络来进一步提升检测的准确度（包括给出类别预测）。而对于one-stage方法，它们想要一步到位，直接采用“RPN”网络作出精确的预测，要因此要在网络设计上做很多的tricks。YOLOv2的一大创新是采用Multi-Scale Training策略，这样同一个模型其实就可以适应多种大小的图片了。
|
||||
|
||||
##### YOLOv2的训练
|
||||
YOLOv2的训练主要包括三个阶段。
|
||||
第一阶段：先在ImageNet分类数据集上预训练Darknet-19，此时模型输入为224*224,共训练160个epochs。
|
||||
第二阶段：将网络的输入调整为448*448,继续在ImageNet数据集上finetune分类模型，训练10个epochs，此时分类模型的top-1准确度为76.5%，而top-5准确度为93.3%。
|
||||
第三个阶段：修改Darknet-19分类模型为检测模型，并在检测数据集上继续finetune网络。
|
||||
网络修改包括（网路结构可视化）：移除最后一个卷积层、global avgpooling层以及softmax层，并且新增了三个3*3*2014卷积层，同时增加了一个passthrough层，最后使用1*1卷积层输出预测结果。
|
||||
|
||||
#### 8.3.2.3 YOLO9000
|
||||
YOLO9000是在YOLOv2的基础上提出的一种可以检测超过9000个类别的模型，其主要贡献点在于提出了一种分类和检测的联合训练策略。众多周知，检测数据集的标注要比分类数据集打标签繁琐的多，所以ImageNet分类数据集比VOC等检测数据集高出几个数量级。在YOLO中，边界框的预测其实并不依赖于物体的标签，所以YOLO可以实现在分类和检测数据集上的联合训练。对于检测数据集，可以用来学习预测物体的边界框、置信度以及为物体分类，而对于分类数据集可以仅用来学习分类，但是其可以大大扩充模型所能检测的物体种类。 作者选择在COCO和ImageNet数据集上进行联合训练，但是遇到的第一问题是两者的类别并不是完全互斥的，比如"Norfolk terrier"明显属于"dog"，所以作者提出了一种层级分类方法（Hierarchical classification），主要思路是根据各个类别之间的从属关系（根据WordNet）建立一种树结构WordTree，结合COCO和ImageNet建立的WordTree如下图所示：
|
||||
|
||||
图7.4.26 基于COCO和ImageNet数据集建立的WordTree
|
||||
WordTree中的根节点为"physical object"，每个节点的子节点都属于同一子类，可以对它们进行softmax处理。在给出某个类别的预测概率时，需要找到其所在的位置，遍历这个path，然后计算path上各个节点的概率之积。
|
||||
|
||||
图7.4.27 ImageNet与WordTree预测的对比
|
||||
在训练时，如果是检测样本，按照YOLOv2的loss计算误差，而对于分类样本，只计算分类误差。在预测时，YOLOv2给出的置信度就是Pr(physicalobject)，同时会给出边界框位置以及一个树状概率图。在这个概率图中找到概率最高的路径，当达到某一个阈值时停止，就用当前节点表示预测的类别。通过联合训练策略，YOLO9000可以快速检测出超过9000个类别的物体，总体mAP值为19,7%。我觉得这是作者在这篇论文作出的最大的贡献，因为YOLOv2的改进策略亮点并不是很突出，但是YOLO9000算是开创之举。
|
||||
|
||||
#### 8.3.2.4 YOLOv3
|
||||
YOLOv3在Pascal TitanX上处理608x608图像速度达到20FPS，在COCO test-dev上mAP@0.5达到57.9%，与RetinaNet（FocalLoss论文所提出的单阶段网络）的结果相近，并且速度快4倍。YOLOv3的模型比之前的模型复杂了不少，可以通过改变模型结构的大小来权衡速度与精度。速度对比如下：
|
||||
|
||||
图7.4.28 性能对比图
|
||||
YOLOv3在实现相同准确度下要显著地比其它检测方法快。时间都是在采用M40或TitanX等相同GPU下测量的。
|
||||
简而言之，YOLOv3的先验检测（Prior detection）系统将分类器或定位器重新用于执行检测任务。他们将模型应用于图像的多个位置和尺度。而那些评分较高的区域就可以视为检测结果。此外，相对于其它目标检测方法，我们使用了完全不同的方法。我们将一个单神经网络应用于整张图像，该网络将图像划分为不同的区域，因而预测每一块区域的边界框和概率，这些边界框会通过预测的概率加权。我们的模型相比于基于分类器的系统有一些优势。它在测试时会查看整个图像，所以它的预测利用了图像中的全局信息。与需要数千张单一目标图像的R-CNN不同，它通过单一网络评估进行预测。这令YOLOv3非常快，一般它比R-CNN快1000倍、比Fast R-CNN快100倍。
|
||||
|
||||
##### YOLOv3改进
|
||||
##### （1）多尺度预测（类FPN）
|
||||
每种尺度预测3个box, anchor的设计方式仍然使用聚类,得到9个聚类中心,将其按照大小均分给3中尺度。
|
||||
尺度1:在基础网络之后添加一些卷积层再输出box信息。
|
||||
尺度2:从尺度1中的倒数第二层的卷积层上采样(x2)再与最后一个16x16大小的特征图相加,再次通过多个卷积后输出box信息.相比尺度1变大两倍。
|
||||
尺度3:与尺度2类似,使用了32x32大小的特征图。
|
||||
|
||||
##### （2）更好的基础分类网络（类ResNet）和分类器darknet-53,见下图。
|
||||
|
||||
图7.4.29 基础网络Darknet-53
|
||||
|
||||
##### （3）分类器-类别预测：
|
||||
YOLOv3不使用Softmax对每个框进行分类，主要考虑因素有两个：（1）Softmax使得每个框分配一个类别（score最大的一个），而对于Open Images这种数据集，目标可能有重叠的类别标签，因此Softmax不适用于多标签分类。（2）Softmax可被独立的多个logistic分类器替代，且准确率不会下降。分类损失采用binary cross-entropy loss。仿ResNet, 与ResNet-101或ResNet-152准确率接近,但速度更快.对比如下（准确率（top-1 误差、top-5 误差）、运算次数（/十亿）、每秒浮点数运算次数（/十亿），以及 FPS 值。）:
|
||||
表7.4.3主干架构的性能对比
|
||||
|
||||
检测结构如下：
|
||||
|
||||
图7.4.30
|
||||
|
||||
图7.4.31
|
||||
从中看出，YOLOv3表现得不错。RetinaNet需要大约3.8倍的时间来处理一张图像，YOLOv3相比SSD变体要好得多，并在AP_50指标上和当前最佳模型有得一拼。YOLOv3在mAP@0.5及小目标APs上具有不错的结果,但随着IOU的增大,性能下降,说明YOLOv3不能很好地与ground truth切合。
|
||||
边框预测：
|
||||
|
||||
图7.4.32带有维度先验和定位预测的边界框。我们边界框的宽和高以作为离聚类中心的位移，并使用Sigmoid函数预测边界框相对于滤波器应用位置的中心坐标。仍采用之前的logis其中cx,cy是网格的坐标偏移量,pw,ph是预设的anchor box的边长.最终得到的边框坐标值是b*,而网络学习目标是t*，用sigmod函数、指数转换。
|
||||
|
||||
##### YOLOv3模型优缺点
|
||||
##### （1）优点
|
||||
a) 快速,pipline简单；
|
||||
b) 背景误检率低；
|
||||
c) 通用性强。
|
||||
YOLO对于艺术类作品中的物体检测同样适用。它对非自然图像物体的检测率远远高于DPM和RCNN系列检测方法。
|
||||
|
||||
##### （2）缺点
|
||||
但相比RCNN系列物体检测方法，YOLO具有以下缺点：
|
||||
a) 识别物体位置精准性差。
|
||||
b) 召回率低。
|
||||
在每个网格中预测两个box这种约束方式减少了对同一目标的多次检测(R-CNN使用的region proposal方式重叠较多),相比R-CNN使用Selective Search产生2000个proposal（RCNN测试时每张超过40秒），yolo仅使用7x7x2个。
|
||||
|
||||
### 8.3.3 RetinaNet
|
||||
|
||||
md版本未编辑完
|
||||
|
|
@ -0,0 +1 @@
|
|||
问题待提出和整理
|
||||
|
|
@ -0,0 +1,159 @@
|
|||
# 第十五章 GPU和框架选型指南
|
||||
|
||||
## 15.1 GPU购买指南
|
||||
|
||||
深度学习训练通常需要大量的计算资源。GPU目前是深度学习最常使用的计算加速硬件。相对于CPU来说，GPU更便宜且计算更加密集。一方面，相同计算能力的GPU的价格一般是CPU价格的十分之一。另一方面，一台服务器通常可以搭载8块或者16块GPU。因此，GPU数量可以看作是衡量一台服务器的深度学习计算能力的一个标准。
|
||||
|
||||
### 15.1.1 如何选择GPU
|
||||
### 首先给出一些总体的建议
|
||||
最好的GPU整体（小幅度）：Titan Xp
|
||||
综合性价比高，但略贵：GTX 1080 Ti，GTX 1070，GTX 1080
|
||||
性价比还不错且便宜：GTX 1060（6GB）
|
||||
|
||||
当使用数据集> 250GB：GTX Titan X（Maxwell） ，NVIDIA Titan X Pascal或NVIDIA Titan Xp
|
||||
|
||||
没有足够的钱：GTX 1060（6GB）
|
||||
|
||||
几乎没有钱：GTX 1050 Ti（4GB）
|
||||
|
||||
做Kaggle比赛：GTX 1060（6GB）适用于任何“正常”比赛，或GTX 1080 Ti用于“深度学习竞赛”
|
||||
|
||||
计算机视觉研究员：NVIDIA Titan Xp；不要买现在新出的Titan X（Pascal或Maxwell）
|
||||
|
||||
一名研究员人员：GTX 1080 Ti。在某些情况下，如自然语言处理，一个GTX 1070或GTX 1080已经足够了-检查你现在模型的内存需求
|
||||
|
||||
搭建一个GPU集群：这个有点复杂，另做探讨。
|
||||
|
||||
刚开始进行深度学习研究：从GTX 1060（6GB）开始。根据你下一步兴趣（入门，Kaggle比赛，研究，应用深度学习）等等，在进行选择。目前，GTX 1060更合适。
|
||||
|
||||
想尝试下深度学习，但没有过多要求：GTX 1050 ti（4或2GB）
|
||||
|
||||
目前独立GPU主要有AMD和Nvidia两家厂商。其中Nvidia在深度学习布局较早，对深度学习框架支持更好。因此，目前大家主要会选择Nvidia的GPU。
|
||||
|
||||
Nvidia有面向个人用户（例如GTX系列）和企业用户（例如Tesla系列）的两类GPU。这两类GPU的计算能力相当。然而，面向企业用户的GPU通常使用被动散热并增加了内存校验，从而更适合数据中心，并通常要比面向个人用户的GPU贵上10倍。
|
||||
|
||||
如果你是拥有100台机器以上的大公司用户，通常可以考虑针对企业用户的Nvidia Tesla系列。如果你是拥有10到100台机器的实验室和中小公司用户，预算充足的情况下可以考虑Nvidia DGX系列，否则可以考虑购买如Supermicro之类的性价比比较高的服务器，然后再购买安装GTX系列的GPU。
|
||||
|
||||
Nvidia一般每一两年发布一次新版本的GPU，例如2017年发布的是GTX 1000系列。每个系列中会有数个不同的型号，分别对应不同的性能。
|
||||
|
||||
### 15.1.2 GPU的主要性能指标
|
||||
GPU的性能主要由以下三个参数构成：
|
||||
|
||||
1. 计算能力。通常我们关心的是32位浮点计算能力。16位浮点训练也开始流行，如果只做预测的话也可以用8位整数。
|
||||
2. 内存大小。当模型越大，或者训练时的批量越大时，所需要的GPU内存就越多。
|
||||
3. 内存带宽。只有当内存带宽足够时才能充分发挥计算能力。
|
||||
|
||||
对于大部分用户来说，只要考虑计算能力就可以了。GPU内存尽量不小于4GB。但如果GPU要同时显示图形界面，那么推荐的内存大小至少为6GB。内存带宽通常相对固定，选择空间较小。
|
||||
|
||||
下图描绘了GTX 900和1000系列里各个型号的32位浮点计算能力和价格的对比。其中价格为Wikipedia的建议价格。
|
||||
|
||||
|
||||
|
||||
我们可以从图中读出两点信息：
|
||||
|
||||
1. 在同一个系列里面，价格和性能大体上成正比。但后发布的型号性价比更高，例如980 TI和1080 TI。
|
||||
2. GTX 1000系列比900系列在性价比上高出2倍左右。
|
||||
|
||||
如果大家继续比较GTX较早的系列，也可以发现类似的规律。据此，我们推荐大家在能力范围内尽可能买较新的GPU。
|
||||
|
||||
在选择GPU时，首先要考虑的第一个GPU性能问题是什么呢：是否为cuda核心？时钟速度多大？内存大小多少？
|
||||
这些都不是，对于深度学习性能而言，最重要的特征是内存带宽（memory bandwidth）。
|
||||
简而言之：GPU针对内存带宽进行了优化，但同时牺牲了内存访问时间（延迟）。CPU的设计恰恰相反：如果涉及少量内存（例如几个数字相乘（3 * 6 * 9）），CPU可以快速计算，但是对于大量内存（如矩阵乘法（A * B * C）则很慢。由于内存带宽的限制，当涉及大量内存的问题时，GPU快速计算的优势往往会受到限制。当然，GPU和CPU之间还有更复杂的区别，关于为何GPU如此适用于处理深度学习问题，另做探讨。
|
||||
|
||||
所以如果你想购买一个快速的GPU，首先要关注的是GPU的带宽（bandwidth）。
|
||||
|
||||
|
||||
### 15.1.3 整机配置
|
||||
|
||||
通常，我们主要用GPU做深度学习训练。因此，不需要购买高端的CPU。至于整机配置，尽量参考网上推荐的中高档的配置就好。不过，考虑到GPU的功耗、散热和体积，我们在整机配置上也需要考虑以下三个额外因素。
|
||||
|
||||
1. 机箱体积。GPU尺寸较大，通常考虑较大且自带风扇的机箱。
|
||||
2. 电源。购买GPU时需要查一下GPU的功耗，例如50W到300W不等。购买电源要确保功率足够，且不会过载机房的供电。
|
||||
3. 主板的PCIe卡槽。推荐使用PCIe 3.0 16x来保证充足的GPU到主内存的带宽。如果搭载多块GPU，要仔细阅读主板说明，以确保多块GPU一起使用时仍然是16x带宽。注意，有些主板搭载4块GPU时会降到8x甚至4x带宽。
|
||||
|
||||
|
||||
### 15.1.4 小结
|
||||
|
||||
* 在预算范围之内，尽可能买较新的GPU。
|
||||
* 整机配置需要考虑到GPU的功耗、散热和体积。
|
||||
一般来说，我会推荐GTX 1080 Ti，GTX 1080或GTX 1070.他们都是优秀的显卡，如果你有钱，应该购买GTX 1080 Ti。GTX 1070比普通的GTX Titan X（Maxwell）便宜一些。GTX 1080的性价比比GTX 1070低一些，但是自GTX 1080 Ti推出以来，价格大幅下滑，现在GTX 1080的性价比已经能够与GTX 1070比拟。所有这三款显卡应该比GTX 980 Ti要好，因为它们具有11GB和8GB（而不是6GB）的内存。
|
||||
|
||||
8GB的内存可能看起来有点小，但是对于许多任务来说这已经足够了。例如对于Kaggle比赛，大多数图像数据，deep style和自然语言理解任务，这些你可能会遇到几个问题。
|
||||
|
||||
对于入门级的人来或是偶尔想用GPU来参加类似Kaggle比赛的人，GTX 1060是一个不错的选择。我不推荐内存只有3GB的GTX 1060 variant产品，因为6G的内存就已经很有限了。但是，对于许多应用来说，6GB就足够了。GTX 1060比普通的Titan X慢，但与GTX 980具有可比的性价比。
|
||||
|
||||
就综合性价比而言，10系列设计得非常好。GTX 1050 Ti，GTX 1060，GTX 1070，GTX 1080和GTX 1080 Ti都非常出色。GTX 1060和GTX 1050 Ti适用于初学者，GTX 1070和GTX 1080是适合于初创公司，部分研究和工业部门，而性能突出的GTX 1080 Ti，对于以上应用都合适。
|
||||
|
||||
不推荐NVIDIA Titan Xp，因为它的性价比太昂贵了。可以用GTX 1080 Ti代替。然而，NVIDIA Titan Xp在计算机视觉研究领域中仍然有一定的使用，用于处理大数据集或视频数据。在这些领域中，按照每GB的内存数量计算，NVIDIA Titan Xp只比GTX 1080 Ti多1GB，但在这种情况下也具有一定的优势。不推荐NVIDIA Titan X（Pascal），因为NVIDIA Titan Xp速度更快，但价格几乎相同。但由于市场上这些GPU的稀缺性，如果你找不到NVIDIA Titan Xp，也可以购买Titan X（Pascal）。
|
||||
|
||||
如果你已经有了GTX Titan X（Maxwell）GPU，那么升级到NVIDIA Titan X（Pascal）或NVIDIA Titan Xp就没有必要了。
|
||||
|
||||
如果你缺钱，但是你需要12GB内存来开展你的研究，那么GTX Titan X（Maxwell）也是一个很好的选择。
|
||||
|
||||
对于大多数研究人员来说，GTX 1080 Ti已经完全够用了。大多数研究和大多数应用，GTX 1080 Ti的内存完全够用。
|
||||
|
||||
在NLP中，内存限制并不像计算机视觉领域那么严格，所以GTX 1070 / GTX 1080也是不错的选择。通常是，需要解决什么样的任务以及如何进行试验，决定了需要选择哪一款GPU，无论是GTX 1070还是GTX 1080。当你选择GPU时，应该按照类似的方式推理。考虑一下你在做什么任务，如何运行你的实验，然后尝试找到适合这些要求的GPU。
|
||||
|
||||
对于预算有限的人来说，选择条件则更加有限。亚马逊网络服务上的GPU相当昂贵和缓慢，如果只有少量的资金，也是一个不错的选择。我不推荐GTX 970，因为它很慢，即使在某些限制条件下也是相当昂贵的（在eBay上150美元），并且存在与卡启动相关的内存问题。相反，建议花更多一点的钱购买更快，有更大的内存，没有内存问题的GTX 1060。如果实在买不起GTX 1060，我建议选择配备4GB内存的GTX 1050 Ti。4GB内存可能有限，但至少可以开展进行你的研究，只是需要你对模型进行一些调整，也可以得到良好的性能。
|
||||
|
||||
GTX 1050 Ti一般来说也是一个不错的选择，如果你只是想尝试一下深度学习，而没有其他更多的需求。
|
||||
|
||||
结论
|
||||
|
||||
有了这篇文章中提供的所有信息，你应该能够考虑选择哪一种合适的GPU，综合考虑所需的内存大小，带宽（GB/s）大小和GPU的价格，这一思路在未来很久也适用。最后，如果有足够的资金，建议购买GTX 1080 Ti，GTX 1070或者GTX 1080。如果刚刚开始研究深度学习，或者资金有限，可以购买GTX 1060。如果资金实在有限，可以购买GTX 1050 ti；如果想要从事计算机视觉研究，可以购买Titan Xp。
|
||||
|
||||
|
||||
|
||||
## 15.2 框架选型
|
||||
|
||||
目前常用的框架有tensorflow,keras,pytorch,mxnet等等，各个框架的优缺点在此简单介绍：
|
||||
|
||||
### 15.2.1 常用框架简介
|
||||
|
||||
1，tensorflow：
|
||||
tensorflow由于有google的强大背书，加上其优秀的分布式设计，丰富的教程资源和论坛，工业部署方便，基本很多人都是从tensorflow入门的
|
||||
优点：google的强大背书，分布式训练，教程资源丰富，常见问题基本都可以在互联网中找到解决办法，工业部署方便
|
||||
缺点: 接口混乱，官方文档不够简洁，清晰，
|
||||
|
||||
2，keras:
|
||||
keras是一种高层编程接口，其可以选择不同的后端，比如tensorflow，therao等等
|
||||
优点： 接口简洁，上手快，文档好，资源多
|
||||
缺点: 封装的太好了导致不理解其技术细节
|
||||
|
||||
3,pytorch:
|
||||
pytorch是Facebook于2017年才推出的深度学习框架，相对于其它框架，算是比较晚的了，但是这个同时也是优势，在设计的时候就会避免很多之前框架的问题，所以一经推出，就收到大家极大的欢迎
|
||||
优点：接口简洁且规范，和python无缝结合，代码设计优秀且易懂，社区非常活跃，官方修复bug及时
|
||||
缺点: 目前模型在工业界部署相对其它框架稍有劣势，不过后续的pytorch1.0版本应该会有很大改善，和caffe2合并后，caffe2的优秀的模型部署能力可以弥补这个不足
|
||||
|
||||
4,caffe2:
|
||||
caffe2是在caffe之后的第二代版本，同属于Facebook。。。
|
||||
优点：支持模型的全平台部署，。。。。
|
||||
缺点:使用人数相对较少，资源较少，和pytorch合并后应该会更受欢迎
|
||||
|
||||
5,mxnet
|
||||
mxnet是dmlc社区推出的深度学习框架，在2017年被亚马逊指定为官方框架
|
||||
优点：支持多种语言，代码设计优秀，省显存，华人团队开发，中文社区活跃，官方复现经典论文推出gluoncv和gluonNLP模块，非常方便，拿来就可以用。
|
||||
缺点: 现在mxnet官方社区主要在推gluon接口，接口稍有混乱，坑较多，入手门槛稍高
|
||||
|
||||
6，caffe：
|
||||
目前很多做深度学习比较早的大厂基本都是在用caffe，因为在2013-2015年基本就是caffe的天下，并且caffe的代码设计很优秀，基本所有代码都被翻了很多遍了，被各种分析，大厂基本都是魔改caffe，基于caffe来进行二次开发，所在目前在很多大厂还是在使用caffe
|
||||
优点：资源丰富，代码容易理解，部署方便
|
||||
缺点：入门门槛高，文档较少
|
||||
|
||||
### 15.2.1 框架选型总结
|
||||
1，新手入门，首推pytorch，上手快，资源丰富,官方文档写的非常好(https://pytorch.org/tutorials/)
|
||||
2，目前工业部署，tensorflow是首选,资源丰富，并且在分布式训练这一块基本一家独大
|
||||
3，mxnet的gluon接口有比较丰富的中文资源（教程：zh.gluon.ai，论坛：discuss.gluon.ai）,gluoncv模块（https://gluon-cv.mxnet.io）,gluonNLP模块（https://gluon-nlp.mxnet.io）
|
||||
|
||||
|
||||
## 15.3 模型部署
|
||||
我们一般都是通过python或者其他语言来编码训练模型，然后基于后端来进行部署
|
||||
一般的框架都有自身的部署框架，比如tensorflow，pytorch，caffe2，mxnet等等
|
||||
有一些框架是专门做推理部署使用的，比如
|
||||
（1）tensorRT
|
||||
|
||||
(2)TVM
|
||||
|
||||
(3)ONNX
|
||||
|
||||
|
||||
|
|
@ -0,0 +1,24 @@
|
|||
# 第六章 自然语言处理 (NLP)
|
||||
|
||||
Markdown Revision 1;
|
||||
Date: 2018/10/29
|
||||
Editor: 盛泳潘-电子科技大学
|
||||
Contact: shengyp2011@163.com
|
||||
|
||||
|
||||
## 概述篇
|
||||
|
||||
不同于传问题。**定向循环结构如下图所示**：
|
||||
|
||||
|
||||
### 6.2 RNNs典型特点？
|
||||
|
||||
|
||||
### 6.3 Recurrent Neural Network 与Recusive Neural Network的区别？
|
||||
|
||||
|
||||
### 6.2 Self-Attention相对传统RNN、CNN具有什么优势？
|
||||
|
||||
## 技术篇
|
||||
|
||||
|
||||
|
|
@ -4,20 +4,30 @@
|
|||
> Date: 2018/10/25
|
||||
> Editor: 乔成磊-同济大学
|
||||
> Contact: qchl0318@163.com
|
||||
> Updater: [sjsdfg](https://github.com/sjsdfg)
|
||||
|
||||
## 14.1 调试处理
|
||||
关于训练深度最难的事情之一是你要处理的参数的数量，从学习速率到Momentum（动量梯度下降法）的参数。如果使用Momentum或Adam优化算法的参数，也许你还得选择层数，也许你还得选择不同层中隐藏单元的数量，也许你还想使用学习率衰减。所以，你使用的不是单一的学习率。接着，当然你可能还需要选择mini-batch的大小。
|
||||
结果证实一些超参数比其它的更为重要，我认为，最为广泛的学习应用是，学习速率是需要调试的最重要的超参数。
|
||||
除了，还有一些参数需要调试，例如Momentum参数，0.9就是个很好的默认值。我还会调试mini-batch的大小，以确保最优算法运行有效。我还会经常调试隐藏单元，我用橙色圈住的这些，这三个是我觉得其次比较重要的，相对于而言。重要性排第三位的是其他因素，层数有时会产生很大的影响，学习率衰减也是如此。当应用Adam算法时，事实上，我从不调试，和，我总是选定其分别为0.9，0.999和，如果你想的话也可以调试它们。
|
||||
但希望你粗略了解到哪些超参数较为重要，无疑是最重要的，接下来是我用橙色圈住的那些，然后是我用紫色圈住的那些，但这不是严格且快速的标准，我认为，其它深度学习的研究者可能会很不同意我的观点或有着不同的直觉。
|
||||
关于训练深度最难的事情之一是你要处理的参数的数量，从学习速率到 Momentum（动量梯度下降法）的参数。如果使用 Momentum 或 Adam 优化算法的参数，也许你还得选择层数，也许你还得选择不同层中隐藏单元的数量，也许你还想使用学习率衰减。所以，你使用的不是单一的学习率。接着，当然你可能还需要选择 mini-batch 的大小。
|
||||
|
||||
结果证实一些超参数比其它的更为重要，我认为，最为广泛的学习应用是，学习速率是需要调试的最重要的超参数。
|
||||
|
||||
除了，还有一些参数需要调试，例如 Momentum 参数，0.9 就是个很好的默认值。我还会调试 mini-batch 的大小，以确保最优算法运行有效。我还会经常调试隐藏单元，我用橙色圈住的这些，这三个是我觉得其次比较重要的，相对于而言。重要性排第三位的是其他因素，层数有时会产生很大的影响，学习率衰减也是如此。当应用 Adam 算法时，事实上，我从不调试，和，我总是选定其分别为 0.9，0.999 和，如果你想的话也可以调试它们。
|
||||
|
||||
但希望你粗略了解到哪些超参数较为重要，无疑是最重要的，接下来是我用橙色圈住的那些，然后是我用紫色圈住的那些，但这不是严格且快速的标准，我认为，其它深度学习的研究者可能会很不同意我的观点或有着不同的直觉。
|
||||
|
||||
## 14.2 有哪些超参数
|
||||
每个步骤中的超参数整理
|
||||
学习率（learning rate）、batch_size、optimizer、 激活函数、正则化
|
||||
|
||||
## 14.3 如何选择调试值?
|
||||
## 14.4 为超参数选择合适的范围
|
||||
## 14.5 如何搜索超参数？
|
||||
最后，关于如何搜索超参数的问题，我见过大概两种重要的思想流派或人们通常采用的两种重要但不同的方式。
|
||||
一种是你照看一个模型，通常是有庞大的数据组，但没有许多计算资源或足够的CPU和GPU的前提下，基本而言，你只可以一次负担起试验一个模型或一小批模型，在这种情况下，即使当它在试验时，你也可以逐渐改良。比如，第0天，你将随机参数初始化，然后开始试验，然后你逐渐观察自己的学习曲线，也许是损失函数J，或者数据设置误差或其它的东西，在第1天内逐渐减少，那这一天末的时候，你可能会说，看，它学习得真不错。我试着增加一点学习速率，看看它会怎样，也许结果证明它做得更好，那是你第二天的表现。两天后，你会说，它依旧做得不错，也许我现在可以填充下Momentum或减少变量。然后进入第三天，每天，你都会观察它，不断调整你的参数。也许有一天，你会发现你的学习率太大了，所以你可能又回归之前的模型，像这样，但你可以说是在每天花时间照看此模型，即使是它在许多天或许多星期的试验过程中。所以这是一个人们照料一个模型的方法，观察它的表现，耐心地调试学习率，但那通常是因为你没有足够的计算能力，不能在同一时间试验大量模型时才采取的办法。
|
||||
另一种方法则是同时试验多种模型，你设置了一些超参数，尽管让它自己运行，或者是一天甚至多天，然后你会获得像这样的学习曲线，这可以是损失函数J或实验误差或损失或数据误差的损失，但都是你曲线轨迹的度量。同时你可以开始一个有着不同超参数设定的不同模型，所以，你的第二个模型会生成一个不同的学习曲线，也许是像这样的一条（紫色曲线），我会说这条看起来更好些。与此同时，你可以试验第三种模型，其可能产生一条像这样的学习曲线（红色曲线），还有另一条（绿色曲线），也许这条有所偏离，像这样，等等。或者你可以同时平行试验许多不同的模型，橙色的线就是不同的模型。用这种方式你可以试验许多不同的参数设定，然后只是最后快速选择工作效果最好的那个。在这个例子中，也许这条看起来是最好的（下方绿色曲线）。
|
||||
所以这两种方式的选择，是由你拥有的计算资源决定的，如果你拥有足够的计算机去平行试验许多模型，那绝对采用鱼子酱方式，尝试许多不同的超参数，看效果怎么样。但在一些应用领域，比如在线广告设置和计算机视觉应用领域，那里的数据太多了，你需要试验大量的模型，所以同时试验大量的模型是很困难的，它的确是依赖于应用的过程。但我看到那些应用熊猫方式多一些的组织，那里，你会像对婴儿一样照看一个模型，调试参数，试着让它工作运转。尽管，当然，甚至是在熊猫方式中，试验一个模型，观察它工作与否，也许第二或第三个星期后，也许我应该建立一个不同的模型（绿色曲线），像熊猫那样照料它，我猜，这样一生中可以培育几个孩子，即使它们一次只有一个孩子或孩子的数量很少。
|
||||
|
||||
最后，关于如何搜索超参数的问题，我见过大概两种重要的思想流派或人们通常采用的两种重要但不同的方式。
|
||||
|
||||
一种是你照看一个模型，通常是有庞大的数据组，但没有许多计算资源或足够的 CPU 和 GPU 的前提下，基本而言，你只可以一次负担起试验一个模型或一小批模型，在这种情况下，即使当它在试验时，你也可以逐渐改良。比如，第 0 天，你将随机参数初始化，然后开始试验，然后你逐渐观察自己的学习曲线，也许是损失函数 J，或者数据设置误差或其它的东西，在第 1 天内逐渐减少，那这一天末的时候，你可能会说，看，它学习得真不错。我试着增加一点学习速率，看看它会怎样，也许结果证明它做得更好，那是你第二天的表现。两天后，你会说，它依旧做得不错，也许我现在可以填充下 Momentum 或减少变量。然后进入第三天，每天，你都会观察它，不断调整你的参数。也许有一天，你会发现你的学习率太大了，所以你可能又回归之前的模型，像这样，但你可以说是在每天花时间照看此模型，即使是它在许多天或许多星期的试验过程中。所以这是一个人们照料一个模型的方法，观察它的表现，耐心地调试学习率，但那通常是因为你没有足够的计算能力，不能在同一时间试验大量模型时才采取的办法。
|
||||
|
||||
另一种方法则是同时试验多种模型，你设置了一些超参数，尽管让它自己运行，或者是一天甚至多天，然后你会获得像这样的学习曲线，这可以是损失函数 J 或实验误差或损失或数据误差的损失，但都是你曲线轨迹的度量。同时你可以开始一个有着不同超参数设定的不同模型，所以，你的第二个模型会生成一个不同的学习曲线，也许是像这样的一条（紫色曲线），我会说这条看起来更好些。与此同时，你可以试验第三种模型，其可能产生一条像这样的学习曲线（红色曲线），还有另一条（绿色曲线），也许这条有所偏离，像这样，等等。或者你可以同时平行试验许多不同的模型，橙色的线就是不同的模型。用这种方式你可以试验许多不同的参数设定，然后只是最后快速选择工作效果最好的那个。在这个例子中，也许这条看起来是最好的（下方绿色曲线）。
|
||||
|
||||
所以这两种方式的选择，是由你拥有的计算资源决定的，如果你拥有足够的计算机去平行试验许多模型，那绝对采用鱼子酱方式，尝试许多不同的超参数，看效果怎么样。但在一些应用领域，比如在线广告设置和计算机视觉应用领域，那里的数据太多了，你需要试验大量的模型，所以同时试验大量的模型是很困难的，它的确是依赖于应用的过程。但我看到那些应用熊猫方式多一些的组织，那里，你会像对婴儿一样照看一个模型，调试参数，试着让它工作运转。尽管，当然，甚至是在熊猫方式中，试验一个模型，观察它工作与否，也许第二或第三个星期后，也许我应该建立一个不同的模型（绿色曲线），像熊猫那样照料它，我猜，这样一生中可以培育几个孩子，即使它们一次只有一个孩子或孩子的数量很少。
|
||||
|
||||
|
||||
|
|
|
|||
|
|
@ -0,0 +1,114 @@
|
|||
# 第九章 强化学习
|
||||
## 9.1强化学习的主要特点？
|
||||
其他许多机器学习算法中学习器都是学得怎样做，而RL是在尝试的过程中学习到在特定的情境下选择哪种行动可以得到最大的回报。在很多场景中，当前的行动不仅会影响当前的rewards，还会影响之后的状态和一系列的rewards。RL最重要的3个特定在于：
|
||||
(1) 基本是以一种闭环的形式；
|
||||
(2) 不会直接指示选择哪种行动（actions）；
|
||||
(3) 一系列的actions和奖励信号（reward signals）都会影响之后较长的时间。
|
||||
|
||||
### 1. 定义
|
||||
强化学习是机器学习的一个重要分支，是多学科多领域交叉的一个产物，它的本质是解决 decision making 问题，即自动进行决策，并且可以做连续决策。
|
||||
它主要包含四个元素，agent，环境状态，行动，奖励, 强化学习的目标就是获得最多的累计奖励。
|
||||
我们列举几个形象的例子：
|
||||
小孩想要走路，但在这之前，他需要先站起来，站起来之后还要保持平衡，接下来还要先迈出一条腿，是左腿还是右腿，迈出一步后还要迈出下一步。
|
||||
小孩就是 agent，他试图通过采取行动（即行走）来操纵环境（行走的表面），并且从一个状态转变到另一个状态（即他走的每一步），当他完成任务的子任务（即走了几步）时，孩子得到奖励（给巧克力吃），并且当他不能走路时，就不会给巧克力。
|
||||
|
||||
|
||||
|
||||
上图中agent代表自身，如果是自动驾驶，agent就是车；如果你玩游戏它就是你当前控制的游戏角色，如马里奥，马里奥往前走时环境就一直在发生变化，有小怪物或者障碍物出现，它需要通过跳跃来进行躲避，就是要做action（如向前走和跳起的动作）；无人驾驶的action就是车左转、右转或刹车等等，它无时无刻都在与环境产生交互，action会反馈给环境，进而改变环境，如果自动驾驶的车行驶目标是100米，它向前开了10米，那环境就发生了变化，所以每次产生action都会导致环境改变，环境的改变会反馈给自身（agent），就是这样的一个循环；反馈又两种方式：1、做的好（reward）即正反馈，2、做得不好（punishment惩罚）即负反馈。Agent可能做得好，也可能做的不好，环境始终都会给它反馈，agent会尽量去做对自身有利的决策，通过反反复复这样的一个循环，agent会越来越做的好，就像孩子在成长过程中会逐渐明辨是非，这就是强化学习。
|
||||
## 9.2强化学习应用实例
|
||||
（1）Manufacturing
|
||||
|
||||
例如一家日本公司 Fanuc，工厂机器人在拿起一个物体时，会捕捉这个过程的视频，记住它每次操作的行动，操作成功还是失败了，积累经验，下一次可以更快更准地采取行动。
|
||||
|
||||
|
||||
（2）Inventory Management
|
||||
|
||||
在库存管理中，因为库存量大，库存需求波动较大，库存补货速度缓慢等阻碍使得管理是个比较难的问题，可以通过建立强化学习算法来减少库存周转时间，提高空间利用率。
|
||||
|
||||
（3）Dynamic pricing
|
||||
|
||||
强化学习中的 Q-learning 可以用来处理动态定价问题。
|
||||
|
||||
（4）Customer Delivery
|
||||
|
||||
制造商在向各个客户运输时，想要在满足客户的所有需求的同时降低车队总成本。通过 multi-agents 系统和 Q-learning，可以降低时间，减少车辆数量。
|
||||
|
||||
（5）ECommerce Personalization
|
||||
|
||||
在电商中，也可以用强化学习算法来学习和分析顾客行为，定制产品和服务以满足客户的个性化需求。
|
||||
（6）Ad Serving
|
||||
|
||||
例如算法 LinUCB （属于强化学习算法 bandit 的一种算法），会尝试投放更广范围的广告，尽管过去还没有被浏览很多，能够更好地估计真实的点击率。
|
||||
再如双 11 推荐场景中，阿里巴巴使用了深度强化学习与自适应在线学习，通过持续机器学习和模型优化建立决策引擎，对海量用户行为以及百亿级商品特征进行实时分析，帮助每一个用户迅速发现宝贝，提高人和商品的配对效率。还有，利用强化学习将手机用户点击率提升了 10-20%。
|
||||
|
||||
（7）Financial Investment Decisions
|
||||
|
||||
例如这家公司 Pit.ai，应用强化学习来评价交易策略，可以帮助用户建立交易策略，并帮助他们实现其投资目标。
|
||||
|
||||
（8）Medical Industry
|
||||
|
||||
动态治疗方案（DTR）是医学研究的一个主题，是为了给患者找到有效的治疗方法。 例如癌症这种需要长期施药的治疗，强化学习算法可以将患者的各种临床指标作为输入 来制定治疗策略。
|
||||
## 9.3强化学习和监督式学习、非监督式学习的区别
|
||||
在机器学习中，我们比较熟知的是监督式学习，非监督学习，此外还有一个大类就是强化学习：
|
||||
当前的机器学习算法可以分为3种：有监督的学习（Supervised Learning）、无监督的学习（Unsupervised Learning）和强化学习（Reinforcement Learning），结构图如下所示：
|
||||
|
||||
|
||||
### 强化学习和监督式学习的区别：
|
||||
监督式学习就好比你在学习的时候，有一个导师在旁边指点，他知道怎么是对的怎么是错的，但在很多实际问题中，例如 chess，go，这种有成千上万种组合方式的情况，不可能有一个导师知道所有可能的结果。
|
||||
|
||||
而这时，强化学习会在没有任何标签的情况下，通过先尝试做出一些行为得到一个结果，通过这个结果是对还是错的反馈，调整之前的行为，就这样不断的调整，算法能够学习到在什么样的情况下选择什么样的行为可以得到最好的结果。
|
||||
|
||||
就好比你有一只还没有训练好的小狗，每当它把屋子弄乱后，就减少美味食物的数量（惩罚），每次表现不错时，就加倍美味食物的数量（奖励），那么小狗最终会学到一个知识，就是把客厅弄乱是不好的行为。
|
||||
|
||||
两种学习方式都会学习出输入到输出的一个映射，监督式学习出的是之间的关系，可以告诉算法什么样的输入对应着什么样的输出，强化学习出的是给机器的反馈 reward function，即用来判断这个行为是好是坏。
|
||||
另外强化学习的结果反馈有延时，有时候可能需要走了很多步以后才知道以前的某一步的选择是好还是坏，而监督学习做了比较坏的选择会立刻反馈给算法。
|
||||
|
||||
而且强化学习面对的输入总是在变化，每当算法做出一个行为，它影响下一次决策的输入，而监督学习的输入是独立同分布的。
|
||||
|
||||
通过强化学习，一个 agent 可以在探索和开发（exploration and exploitation）之间做权衡，并且选择一个最大的回报。
|
||||
|
||||
exploration 会尝试很多不同的事情，看它们是否比以前尝试过的更好。
|
||||
|
||||
exploitation 会尝试过去经验中最有效的行为。
|
||||
|
||||
一般的监督学习算法不考虑这种平衡，就只是是 exploitative。
|
||||
|
||||
### 强化学习和非监督式学习的区别：
|
||||
|
||||
非监督式不是学习输入到输出的映射，而是模式。例如在向用户推荐新闻文章的任务中，非监督式会找到用户先前已经阅读过类似的文章并向他们推荐其一，而强化学习将通过向用户先推荐少量的新闻，并不断获得来自用户的反馈，最后构建用户可能会喜欢的文章的“知识图”。
|
||||
|
||||
对非监督学习来说，它通过对没有概念标记的训练例进行学习，以发现训练例中隐藏的结构性知识。这里的训练例的概念标记是不知道的，因此训练样本的歧义性最高。对强化学习来说，它通过对没有概念标记、但与一个延迟奖赏或效用（可视为延迟的概念标记）相关联的训练例进行学习，以获得某种从状态到行动的映射。这里本来没有概念标记的概
|
||||
念，但延迟奖赏可被视为一种延迟概念标记，因此其训练样本的歧义性介于监督学习和非监督学习之间。
|
||||
|
||||
需要注意的是，监督学习和非监督学习从一开始就是相对的，而强化学习在提出时并没有从训练样本歧义性的角度考虑其与监督学习和非监督学习的区别，因此，一些早期的研究中把强化学习视为一种特殊的非监督学习。事实上，对强化学习的定位到目前仍然是有争议的，有的学者甚至认为它是与“从例子中学习”同一级别的概念。
|
||||
|
||||
从训练样本歧义性角度进行的分类体系，在近几年可望有一些扩展，例如多示例学习（multi-instancelearning）等从训练样本歧义性方面来看很特殊的新的学习框架有可能会进入该体系。但到目前为止，没有任何新的框架得到了公认的地位。另外，半监督学习（semi-supervisedlearning）也有一定希望，它的障碍是半监督学习中的歧义性并不是与生俱来的，而是人为的，即用户期望用未标记的样本来辅助对已标记样本的学习。这与监督学习、非监督学习、强化学习等天生的歧义性完全不同。半监督学习中人为的歧义性在解决工程问题上是需要的、有用的（对大量样本进行标记的代价可能是极为昂贵的），但可能不太会导致方法学或对学习问题视点的大的改变。
|
||||
|
||||
**强化学习和前二者的本质区别**:没有前两者具有的明确数据概念，它不知道结果，只有目标。数据概念就是大量的数据，有监督学习、无监督学习需要大量数据去训练优化你建立的模型，就像猫狗识别，用n多张猫狗图片去训练模型，经过训练优化后，你用一张崭新的猫狗图片让模型作出判断，这个模型就知道是猫还是狗。
|
||||
## 9.4 强化学习主要有哪些算法？
|
||||
强化学习不需要监督信号,可以在模型未知的环境中平衡探索和利用, 其主要算法有蒙特卡罗强化学习, 时间差分(temporal difference: TD)学习, 策略梯度等。典型的深度强化学习算法特点及性能比较如下图所示：
|
||||
|
||||
|
||||
除了上述深度强化学习算法，还有深度迁移强化学习、分层深度强化学习、深度记忆强化学习以及多智能体强化学习等算法。
|
||||
## 9.5深度迁移强化学习算法
|
||||
传统深度强化学习算法每次只能解决一种游戏任务, 无法在一次训练中完成多种任务. 迁移学习和强化学习的结合也是深度强化学习的一种主要思路。
|
||||
|
||||
Parisotto等提出了一种基于行为模拟的深度迁移强化学习算法. 该算法通过监督信号的指导, 使得单一的策略网络学习各自的策略, 并将知识迁移到新任务中. Rusa等提出策略蒸馏(policy distillation)深度迁移强化学习算法. 策略蒸馏算法中分为学习网络和指导网络, 通过这两个网络Q值的偏差来确定目标函数,引导学习网络逼近指导网络的值函数空间. 此后,Rusa等又提出了一种基于渐进神经网络(progressive neural networks, PNN)的深度迁移强化学习算法.PNN是一种把神经网络和神经网络连起来的算法. 它在一系列序列任务中, 通过渐进的方式来存储知识和提取特征, 完成了对知识的迁移. PNN最终实现多个独立任务的训练, 通过迁移加速学习过程, 避免灾难性遗忘. Fernando 等提出了路径网络(PathNet)[45].PathNet可以说是PNN的进阶版. PathNet把网络中每一层都看作一个模块, 把构建一个网络看成搭积木,也就是复用积木. 它跟PNN非常类似, 只是这里不再有列, 而是不同的路径. PathNet将智能体嵌入到神经网络中, 其中智能体的任务是为新任务发现网络中可以复用的部分. 智能体是网络之中的路径, 其决定了反向传播过程中被使用和更新的参数范围. 在一系列的Atari强化学习任务上, PathNet都实现了正迁移, 这表明PathNet在训练神经网络上具有通用性应用能力.PathNet也可以显著提高A3C算法超参数选择的鲁棒性. Schaul等提出了一种通用值函数逼近器(universalvalue function approximators, UVFAs)来泛化状态和目标空间．UVFAs可以将学习到的知识迁移到环境动态特性相同但目标不同的新任务中.
|
||||
## 9.6分层深度强化学习算法
|
||||
分层强化学习可以将最终目标分解为多个子任务来学习层次化的策略, 并通过组合多个子任务的策略形成有效的全局策略. Kulkarni等提出了分层DQN(hierarchical deep Q-network, h--DQN) 算法. h--DQN基于时空抽象和内在激励分层, 通过在不同的时空尺度上设置子目标对值函数进行层次化处理. 顶层的值函数用于确定宏观决策, 底层的值函数用于确定具体行动．Krishnamurthy等在h--DQN的基础上提出了基于内部选择的分层深度强化学习算法. 该模型结合时空抽象和深度神经网络, 自动地完成子目标的学习, 避免了特定的内在激励和人工设定中间目标,加速了智能体的学习进程, 同时也增强了模型的泛化能力. Kulkarni等基于后续状态表示法提出了深度后续强化学习(deep successor reinforcement learning,DSRL)．DSRL通过阶段性地分解子目标和学习子目标策略, 增强了对未知状态空间的探索, 使得智能体更加适应那些存在延迟反馈的任务．Vezhnevets等受封建(feudal)强化学习算法的启发, 提出一种分层深度强化学习的架构FeUdal网络(FuNs)[49]. FuNs框架使用一个管理员模块和一个工人模块. 管理员模块在较低的时间分辨率下工作, 设置抽象目标并传递给工人模块去执行. FuNs框架创造了一个稳定的自然层次结构, 并且允许两个模块以互补的方式学习. 实验证明, FuNs有助于处理长期信用分配和记忆任务,在Atari视频游戏和迷宫游戏中都取得了不错的效果。
|
||||
## 9.7深度记忆强化学习算法
|
||||
传统的深度强化学习模型不具备记忆、认知、推理等高层次的能力, 尤其是在面对状态部分可观察和延迟奖赏的情形时. Junhyuk等通过在传统的深度强化学习模型中加入外部的记忆网络部件和反馈控制机制, 提出反馈递归记忆Q网络(feedback recurrent memory Q-network, FRMQN)). FRMQN模型具备了一定的记忆与推理功能, 通过反馈控制机制,FRMQN整合过去存储的有价值的记忆和当前时刻的上下文状态, 评估动作值函数并做出决策. FRMQN初步模拟了人类的主动认知与推理能力, 并完成了一些高层次的认知任务. 在一些未经过训练的任务中,FRMQN模型表现出了很强的泛化能力．Blundell等设计出一种模型无关的情节控制算法(model-free episode control, MFEC). MFEC可以快速存储和回放状态转移序列, 并将回放的序列整合到结构化知识系统中, 使得智能体在面对一些复杂的决策任务时, 能快速达到人类玩家的水平．MFEC通过反向经验回放, 使智能体拥有初步的情节记忆. 实验表明, 基于MFEC算法的深度强化学习不仅可以在Atari游戏中学习到有效策略, 还可以处理一些三维场景的复杂任务. Pritzel等在MFEC的基础上进一步提出了神经情节控制(neural episodic control, NEC),有效提高了深度强化学习智能体的记忆能力和学习效率[53]. NEC能快速吸收新经验并依据新经验来采取行动. 价值函数包括价值函数渐变状态表示和价值函数快速更新估计两部分. 大量场景下的研究表明,NEC的学习速度明显快于目前最先进的通用深度强化学习智能体.
|
||||
## 9.8 多智能体深度强化学习算法
|
||||
在一些复杂场景中, 涉及到多智能体的感知决策问题, 这时需要将单一模型扩展为多个智能体之间相互合作、通信及竞争的多智能体深度强化学习系统.Foerster等提出了一种称为分布式深度递归Q网络(deep distributed recurrent Q-networks, DDRQN) 的模型, 解决了状态部分可观测状态下的多智能体通信与合作的挑战性难题[54]. 实验表明, 经过训练的DDRQN模型最终在多智能体之间达成了一致的通信协1536 控制理论与应用第34 卷议, 成功解决了经典的红蓝帽子问题.让智能体学会合作与竞争一直以来都是人工智能领域内的一项重要研究课题, 也是实现通用人工智能的必要条件. Lowe等提出了一种用于合作–竞争混合环境的多智能体actor-critic 算法(multi-agent deepdeterministic policy gradient, MADDPG)[55]. MADDPG对DDPG强化学习算法进行了延伸, 可实现多智能体的集中式学习和分布式执行, 让智能体学习彼此合作和竞争. 在多项测试任务中, MADDPG的表现都优于DDPG.
|
||||
## 9.9强化学习开源框架
|
||||
谷歌TensorFlow Agents ---TensorFlow的加强版,它提供许多工具，通过强化学习可以实现各类智能应用程序的构建与训练。这个框架能够将OpoenAI Gym接口扩展至多个并行环境，并允许各代理立足TensorFlow之内实现以执行批量计算。其面向OpoenAI Gy环境的批量化接口可与TensorFlow实现全面集成，从而高效执行各类算法。该框架还结合有BatchPPO，一套经过优化的近端策略优化算法实现方案。其核心组件包括一个环境打包器，用于在外部过程中构建OpenAI Gym环境; 一套批量集成，用于实现TensorFlow图步并以强化学习运算的方式重置函数; 外加用于将TensorFlow图形批处理流程与强化学习算法纳入训练特内单一却步的组件。
|
||||
|
||||
Roboschool：Roboschool 提供开源软件以通过强化学习构建并训练机器人模拟。其有助于在同一环境当中对多个代理进行强化学习训练。通过多方训练机制，您可以训练同一代理分别作为两方玩家（因此能够自我对抗）、使用相同算法训练两套代理，或者设置两种算法进行彼此对抗。Roboschool由OpenAI开发完成，这一非营利性组织的背后赞助者包括Elon Musk、Sam Altman、Reid Hoffman以及Peter Thiel。其与OpenAI Gym相集成，后者是一套用于开发及评估强化学习算法的开源工具集。OpenAI Gym与TensorFlow、Theano以及其它多种深度学习库相兼容。OpenAI Gym当中包含用于数值计算、游戏以及物理引擎的相关代码。Roboschool基于Bullet物理引擎，这是一套开源许可物理库，并被其它多种仿真软件——例如Gazebo与Virtual Robot Experimentation Platform（简称V-REP）所广泛使用。其中包含多种强化学习算法，具体以怨报德 异步深度强化学习方法、Actor-Critic with Experience Replay、Actor- Critic using Kronecker-Factored Trust Region、深度确定性策略梯度、近端策略优化以及信任域策略优化等等。
|
||||
|
||||
Coach：英特尔公司的开源强化学习框架，可以对游戏、机器人以及其它基于代理的智能应用进行智能代理的建模、训练与评估。Coach 提供一套模块化沙箱、可复用组件以及用于组合新强化学习算法并在多种应用领域内训练新智能应用的Python API。该框架利用OpenAI Gym作为主工具，负责与不同强化学习环境进行交换。其还支持其它外部扩展，具体包括Roboschool、gym-extensions、PyBullet以及ViZDoom。Coach的环境打包器允许用户向其中添加自定义强化学习环境，从而解决其它学习问题。该框架能够在桌面计算机上高效训练强化学习代理，并利用多核CPU处理相关任务。其能够为一部分强化学习算法提供单线程与多线程实现能力，包括异步优势Actor-Critic、深度确定性策略梯度、近端策略优化、直接未来预测以及规范化优势函数。所有算法皆利用面向英特尔系统作出优化的TensorFLow完成，其中部分算法亦适用于英特尔的Neon深度学习框架。Coach 当中包含多种强化学习代理实现方案，具体包括从单线程实现到多线程实现的转换。其能够开发出支持单与多工作程序（同步或异步）强化学习实现方法的新代理。此外，其还支持连续与离散操作空间，以及视觉观察空间或仅包含原始测量指标的观察空间。
|
||||
## 9.10深度强化学习算法小结
|
||||
基于值函数概念的DQN及其相应的扩展算法在离散状态、离散动作的控制任务中已经表现了卓越的性能, 但是受限于值函数离散型输出的影响, 在连续型控制任务上显得捉襟见肘. 基于策略梯度概念的,以DDPG, TRPO等为代表的策略型深度强化学习算法则更适用于处理基于连续状态空间的连续动作的控制输出任务, 并且算法在稳定性和可靠性上具有一定的理论保证, 理论完备性较强. 采用actor-critic架构的A3C算法及其扩展算法, 相比于传统DQN算法, 这类算法的数据利用效率更高, 学习速率更快, 通用性、可扩展应用性更强, 达到的表现性能更优, 但算法的稳定性无法得到保证. 而其他的如深度迁移强化学习、分层深度强化学习、深度记忆强化学习和多智能体深度强化学习等算法都是现在的研究热点, 通过这些算法能应对更为复杂的场景问题、系统环境及控制任务, 是目前深度强化学习算法研究的前沿领域.
|
||||
|
||||
展望未来，人工智能开发者们需要尽可能掌握上述框架以及其中所使用的各类强化学习算法。此外，还需要强化自身对于多代理强化学习架构的理解，因为其中多种框架都大量利用前沿博弈论研究成果。最后，还需要熟悉深度强化学习知识。
|
||||
|
||||
|
||||
Binary file not shown.
544
README.md
544
README.md
|
|
@ -1,47 +1,57 @@
|
|||
## Welcome to GitHub Pages
|
||||
|
||||
You can use the [editor on GitHub](https://github.com/scutan90/DeepLearning-500-questions/edit/master/README.md) to maintain and preview the content for your website in Markdown files.
|
||||
|
||||
##############################################################
|
||||
|
||||
请尊重作者的知识产权，版权所有，翻版必究。 2018.6.27 Tan
|
||||
|
||||
scutjy2015@163.com (唯一官方邮箱)；现出现不法分子冒充发起人，请广大伙伴儿知悉！
|
||||
##############################################################
|
||||
|
||||
|
||||
# 接下来，将提供MD版本，大家一起编辑完善，敬请期待！
|
||||
# 希望踊跃提建议，补充修改内容！
|
||||
# 希望踊跃提建议，在已提交MD版本补充修改内容！
|
||||
## 为了让内容更充实完善，集思广益，请在修改MD文件的同时（或直接留言）备注自己的姓名－单位（大佬－斯坦福大学），一经采纳，会在原文中显示贡献者的信息，如有收益，会进一步分红，谢谢！
|
||||
## 接下来，将提供MD版本，大家一起编辑完善，敬请期待！
|
||||
## 希望踊跃提建议，补充修改内容！
|
||||
## 希望踊跃提建议，在已提交MD版本补充修改内容！
|
||||
为了让内容更充实完善，集思广益，请在修改MD文件的同时（或直接留言）备注自己的姓名－单位（大佬－斯坦福大学），一经采纳，会在原文中显示贡献者的信息，如有收益，会进一步分红，谢谢！
|
||||
例：
|
||||
### 3.3.2 如何寻找超参数的最优值？（贡献者：大佬－斯坦福大学）
|
||||
|
||||
在使用机器学习算法时，总有一些难搞的超参数。例如权重衰减大小，高斯核宽度等等。算法不会设置这些参数，而是需要你去设置它们的值。设置的值对结果产生较大影响。常见设置超参数的做法有：
|
||||
|
||||
1. 猜测和检查：根据经验或直觉，选择参数，一直迭代。
|
||||
2. 网格搜索：让计算机尝试在一定范围内均匀分布的一组值。
|
||||
3. 随机搜索：让计算机随机挑选一组值。
|
||||
4. 贝叶斯优化：使用贝叶斯优化超参数，会遇到贝叶斯优化算法本身就需要很多的参数的困难。
|
||||
5. 在良好初始猜测的前提下进行局部优化：这就是 MITIE 的方法，它使用 BOBYQA 算法，并有一个精心选择的起始点。由于 BOBYQA 只寻找最近的局部最优解，所以这个方法是否成功很大程度上取决于是否有一个好的起点。在 MITIE 的情况下，我们知道一个好的起点，但这不是一个普遍的解决方案，因为通常你不会知道好的起点在哪里。从好的方面来说，这种方法非常适合寻找局部最优解。稍后我会再讨论这一点。
|
||||
6. 最新提出的 LIPO 的全局优化方法。这个方法没有参数，而且经验证比随机搜索方法好。
|
||||
1. 猜测和检查：根据经验或直觉，选择参数，一直迭代。
|
||||
2. 网格搜索：让计算机尝试在一定范围内均匀分布的一组值。
|
||||
3. 随机搜索：让计算机随机挑选一组值。
|
||||
4. 贝叶斯优化：使用贝叶斯优化超参数，会遇到贝叶斯优化算法本身就需要很多的参数的困难。
|
||||
5. 在良好初始猜测的前提下进行局部优化：这就是 MITIE 的方法，它使用 BOBYQA 算法，并有一个精心选择的起始点。由于 BOBYQA 只寻找最近的局部最优解，所以这个方法是否成功很大程度上取决于是否有一个好的起点。在 MITIE 的情况下，我们知道一个好的起点，但这不是一个普遍的解决方案，因为通常你不会知道好的起点在哪里。从好的方面来说，这种方法非常适合寻找局部最优解。稍后我会再讨论这一点。
|
||||
6. 最新提出的 LIPO 的全局优化方法。这个方法没有参数，而且经验证比随机搜索方法好。
|
||||
|
||||
### 已提交MD版本章节：请查看MarkDown（排名不分先后）
|
||||
待定：表示该章节还未匹配到合适的负责人（统筹该章节的内容修改、审核、原创性陈述）
|
||||
可加：表示该章节，如果有其他合适的，可以开放权限加到负责人身份
|
||||
|
||||
第一章 数学基础 负责人：哈工大博士-袁笛
|
||||
第二章 机器学习基础 负责人：稿定科技计算机视觉工程师-刘鹏；（待定）
|
||||
第三章 深度学习基础 负责人：同济大学研究生-乔成磊；稿定科技计算机视觉工程师-刘鹏；（可加）
|
||||
第四章 经典网络 负责人：（待定）
|
||||
第五章 卷积神经网络CNN 负责人：杜克大学硕士、data scientist李骁丹；重庆大学研究生-刘畅；
|
||||
------------------------------铪星创新科技联合创始人-杨文英；（可加）
|
||||
第六章 循环神经网络RNN 负责人：杜克大学硕士、data scientist李骁丹;（可加）
|
||||
第七章 生成对抗网络GAN 负责人：牛津大学博士泽华；中科院硕士、爱奇艺算法工程师-郭晓锋
|
||||
第八章 目标检测 负责人：稿定科技计算机视觉工程师-刘鹏；哈工大博士袁笛；上海大学研究生-陈方杰
|
||||
第九章 图像分割 负责人：华南理工研究生-黄钦建；电子科大研究生-孙洪卫、张越；中国农业科学院-杨国峰
|
||||
第十章 强化学习 负责人：复旦大学研究生明杰，（可加）
|
||||
第十一章 迁移学习 负责人：（待定）
|
||||
第十二章 网络搭建及训练 负责人：（待定）
|
||||
第十三章 优化算法 负责人：（待定）
|
||||
第十四章 超参数调整 负责人：（待定）
|
||||
第十五章 GPU和框架选型 负责人：平安科技算法工程师-崔永明、（可加）
|
||||
第十六章 NLP 负责人：电子科技大学博士-盛泳潘；深圳乌灵图明科技有限公司CTO-何建宏；
|
||||
------------------------------DaoCloud研发工程师-张善干；
|
||||
|
||||
|
||||
### 已提交MD版本章节：
|
||||
#### 第一章 数学基础
|
||||
#### 第三章 深度学习基础
|
||||
#### 第四章 经典网络
|
||||
#### 第八章 图像分割
|
||||
#### 第十章 迁移学习
|
||||
#### 第十三章 优化算法
|
||||
#### 第十四章 超参数
|
||||
#### 第十五章 正则化
|
||||
### 感谢以上贡献者1
|
||||
|
||||
寻求有愿意继续完善的朋友、编辑、写手；如有意合作，完善出书（成为共同作者）
|
||||
所有提交内容的贡献者，将会在文中体现贡献者个人信息（大佬-西湖大学）
|
||||
|
||||
##############################################################
|
||||
|
||||
请联系scutjy2015@163.com ； 加微信Tan： tan_weixin88
|
||||
请联系scutjy2015@163.com (唯一官方邮箱)； 加微信Tan： tan_weixin88
|
||||
|
||||
### 进群先在MD版本增加、改善、提交内容后，更容易进群。
|
||||
|
||||
进群请加微信 委托人１：HQJ199508212176 委托人２：Xuwumin1203 委托人３：tianyuzy
|
||||
|
||||
|
|
@ -51,878 +61,454 @@ You can use the [editor on GitHub](https://github.com/scutan90/DeepLearning-500-
|
|||
|
||||
##############################################################
|
||||
|
||||
# 目录 2
|
||||
## 第一章 数学基础 1
|
||||
|
||||
1.1标量、向量、张量之间的联系 1
|
||||
1.2张量与矩阵的区别？ 1
|
||||
1.3矩阵和向量相乘结果 1
|
||||
1.4向量和矩阵的范数归纳 1
|
||||
1.5如何判断一个矩阵为正定？ 2
|
||||
1.6导数偏导计算 3
|
||||
1.7导数和偏导数有什么区别？ 3
|
||||
1.8特征值分解与特征向量 3
|
||||
1.9奇异值与特征值有什么关系？ 4
|
||||
1.10机器学习为什么要使用概率？ 4
|
||||
1.11变量与随机变量有什么区别？ 4
|
||||
1.12常见概率分布？ 5
|
||||
1.13举例理解条件概率 9
|
||||
1.14联合概率与边缘概率联系区别？ 10
|
||||
1.15条件概率的链式法则 10
|
||||
1.16独立性和条件独立性 11
|
||||
1.17期望、方差、协方差、相关系数总结 11
|
||||
## 第二章 机器学习基础 14
|
||||
|
||||
2.1 各种常见算法图示 14
|
||||
|
||||
2.2 监督学习、非监督学习、半监督学习、弱监督学习？ 15
|
||||
|
||||
2.2监督学习、非监督学习、半监督学习、弱监督学习？ 15
|
||||
2.3 监督学习有哪些步骤 16
|
||||
|
||||
2.4 多实例学习？ 17
|
||||
|
||||
2.5 分类网络和回归的区别？ 17
|
||||
|
||||
2.6 什么是神经网络？ 17
|
||||
|
||||
2.7 常用分类算法的优缺点？ 18
|
||||
|
||||
2.8 正确率能很好的评估分类算法吗？ 20
|
||||
|
||||
2.9 分类算法的评估方法？ 20
|
||||
|
||||
2.10 什么样的分类器是最好的？ 22
|
||||
|
||||
2.11大数据与深度学习的关系 22
|
||||
|
||||
2.12 理解局部最优与全局最优 23
|
||||
|
||||
2.13 理解逻辑回归 24
|
||||
|
||||
2.14 逻辑回归与朴素贝叶斯有什么区别？ 24
|
||||
|
||||
2.15 为什么需要代价函数？ 25
|
||||
|
||||
2.16 代价函数作用原理 25
|
||||
|
||||
2.17 为什么代价函数要非负？ 26
|
||||
|
||||
2.18 常见代价函数？ 26
|
||||
|
||||
2.19为什么用交叉熵代替二次代价函数 28
|
||||
|
||||
2.20 什么是损失函数？ 28
|
||||
|
||||
2.21 常见的损失函数 28
|
||||
|
||||
2.22 逻辑回归为什么使用对数损失函数？ 30
|
||||
|
||||
0.00 对数损失函数是如何度量损失的？ 31
|
||||
|
||||
2.23 机器学习中为什么需要梯度下降？ 32
|
||||
|
||||
2.24 梯度下降法缺点？ 32
|
||||
|
||||
2.25 梯度下降法直观理解？ 32
|
||||
|
||||
2.23 梯度下降法算法描述？ 33
|
||||
|
||||
2.24 如何对梯度下降法进行调优？ 35
|
||||
|
||||
2.25 随机梯度和批量梯度区别？ 35
|
||||
|
||||
2.26 各种梯度下降法性能比较 37
|
||||
|
||||
2.27计算图的导数计算图解？ 37
|
||||
|
||||
2.28 线性判别分析（LDA）思想总结 39
|
||||
|
||||
2.29 图解LDA核心思想 39
|
||||
|
||||
2.30 二类LDA算法原理？ 40
|
||||
|
||||
2.30 LDA算法流程总结？ 41
|
||||
|
||||
2.31 LDA和PCA区别？ 41
|
||||
|
||||
2.32 LDA优缺点？ 41
|
||||
|
||||
2.33 主成分分析（PCA）思想总结 42
|
||||
|
||||
2.34 图解PCA核心思想 42
|
||||
|
||||
2.35 PCA算法推理 43
|
||||
|
||||
2.36 PCA算法流程总结 44
|
||||
|
||||
2.37 PCA算法主要优缺点 45
|
||||
|
||||
2.38 降维的必要性及目的 45
|
||||
|
||||
2.39 KPCA与PCA的区别？ 46
|
||||
|
||||
2.40 模型评估 47
|
||||
|
||||
2.40模型评估 47
|
||||
2.40.1模型评估常用方法？ 47
|
||||
|
||||
2.40.2 经验误差与泛化误差 47
|
||||
|
||||
2.40.3 图解欠拟合、过拟合 48
|
||||
|
||||
2.40.4 如何解决过拟合与欠拟合？ 49
|
||||
|
||||
2.40.5 交叉验证的主要作用？ 50
|
||||
|
||||
2.40.6 k折交叉验证？ 50
|
||||
|
||||
2.40.7 混淆矩阵 50
|
||||
|
||||
2.40.8 错误率及精度 51
|
||||
|
||||
2.40.9 查准率与查全率 51
|
||||
|
||||
2.40.10 ROC与AUC 52
|
||||
|
||||
2.40.11如何画ROC曲线？ 53
|
||||
|
||||
2.40.12如何计算TPR，FPR？ 54
|
||||
|
||||
2.40.13如何计算Auc？ 56
|
||||
|
||||
2.40.14为什么使用Roc和Auc评价分类器？ 56
|
||||
|
||||
2.40.15 直观理解AUC 56
|
||||
|
||||
2.40.16 代价敏感错误率与代价曲线 57
|
||||
|
||||
2.40.17 模型有哪些比较检验方法 59
|
||||
|
||||
2.40.18 偏差与方差 59
|
||||
|
||||
2.40.19为什么使用标准差？ 60
|
||||
|
||||
2.40.20 点估计思想 61
|
||||
|
||||
2.40.21 点估计优良性原则？ 61
|
||||
|
||||
2.40.22点估计、区间估计、中心极限定理之间的联系？ 62
|
||||
|
||||
2.40.23 类别不平衡产生原因？ 62
|
||||
|
||||
2.40.24 常见的类别不平衡问题解决方法 62
|
||||
|
||||
2.41 决策树 64
|
||||
|
||||
2.41.1 决策树的基本原理 64
|
||||
|
||||
2.41.2 决策树的三要素？ 64
|
||||
|
||||
2.41.3 决策树学习基本算法 65
|
||||
|
||||
2.41.4 决策树算法优缺点 65
|
||||
|
||||
2.40.5 熵的概念以及理解 66
|
||||
|
||||
2.40.5熵的概念以及理解 66
|
||||
2.40.6 信息增益的理解 66
|
||||
|
||||
2.40.7 剪枝处理的作用及策略？ 67
|
||||
|
||||
2.41 支持向量机 67
|
||||
|
||||
2.41.1 什么是支持向量机 67
|
||||
|
||||
2.25.2 支持向量机解决的问题？ 68
|
||||
|
||||
2.25.2 核函数作用？ 69
|
||||
|
||||
2.25.3 对偶问题 69
|
||||
|
||||
2.25.4 理解支持向量回归 69
|
||||
|
||||
2.25.5 理解SVM（核函数） 69
|
||||
|
||||
2.25.6 常见的核函数有哪些？ 69
|
||||
|
||||
2.25.6 软间隔与正则化 73
|
||||
|
||||
2.25.7 SVM主要特点及缺点？ 73
|
||||
|
||||
2.26 贝叶斯 74
|
||||
|
||||
2.26.1 图解极大似然估计 74
|
||||
|
||||
2.26.2 朴素贝叶斯分类器和一般的贝叶斯分类器有什么区别？ 76
|
||||
|
||||
2.26.4 朴素与半朴素贝叶斯分类器 76
|
||||
|
||||
2.26.5 贝叶斯网三种典型结构 76
|
||||
|
||||
2.26.6 什么是贝叶斯错误率 76
|
||||
|
||||
2.26.7 什么是贝叶斯最优错误率 76
|
||||
|
||||
2.27 EM算法解决问题及实现流程 76
|
||||
|
||||
2.28 为什么会产生维数灾难？ 78
|
||||
|
||||
2.29怎样避免维数灾难 82
|
||||
|
||||
2.30聚类和降维有什么区别与联系？ 82
|
||||
|
||||
2.31 GBDT和随机森林的区别 83
|
||||
|
||||
2.32 四种聚类方法之比较 84
|
||||
|
||||
|
||||
## 第三章 深度学习基础 88
|
||||
3.1基本概念 88
|
||||
|
||||
3.1.1神经网络组成？ 88
|
||||
|
||||
3.1.2神经网络有哪些常用模型结构？ 90
|
||||
|
||||
3.1.3如何选择深度学习开发平台？ 92
|
||||
|
||||
3.1.4为什么使用深层表示 92
|
||||
|
||||
3.1.5为什么深层神经网络难以训练？ 93
|
||||
|
||||
3.1.6深度学习和机器学习有什么不同 94
|
||||
|
||||
3.2 网络操作与计算 95
|
||||
|
||||
3.2.1前向传播与反向传播？ 95
|
||||
|
||||
3.2.2如何计算神经网络的输出？ 97
|
||||
|
||||
3.2.3如何计算卷积神经网络输出值？ 98
|
||||
|
||||
3.2.4如何计算Pooling层输出值输出值？ 101
|
||||
|
||||
3.2.5实例理解反向传播 102
|
||||
|
||||
3.3 超参数 105
|
||||
|
||||
3.3超参数 105
|
||||
3.3.1什么是超参数？ 105
|
||||
|
||||
3.3.2如何寻找超参数的最优值？ 105
|
||||
|
||||
3.3.3超参数搜索一般过程？ 106
|
||||
|
||||
3.4 激活函数 106
|
||||
|
||||
3.4激活函数 106
|
||||
3.4.1为什么需要非线性激活函数？ 106
|
||||
|
||||
3.4.2常见的激活函数及图像 107
|
||||
|
||||
3.4.3 常见激活函数的导数计算？ 109
|
||||
|
||||
3.4.4激活函数有哪些性质？ 110
|
||||
|
||||
3.4.5 如何选择激活函数？ 110
|
||||
|
||||
3.4.6使用ReLu激活函数的优点？ 111
|
||||
|
||||
3.4.7什么时候可以用线性激活函数？ 111
|
||||
|
||||
3.4.8怎样理解Relu（<0时）是非线性激活函数？ 111
|
||||
|
||||
3.4.8怎样理解Relu（<0时）是非线性激活函数？ 111
|
||||
3.4.9 Softmax函数如何应用于多分类？ 112
|
||||
|
||||
3.5 Batch_Size 113
|
||||
|
||||
3.5.1为什么需要Batch_Size？ 113
|
||||
|
||||
3.5.2 Batch_Size值的选择 114
|
||||
|
||||
3.5.3在合理范围内，增大 Batch_Size 有何好处？ 114
|
||||
|
||||
3.5.4盲目增大 Batch_Size 有何坏处？ 114
|
||||
|
||||
3.5.5调节 Batch_Size 对训练效果影响到底如何？ 114
|
||||
|
||||
3.6 归一化 115
|
||||
|
||||
3.6.1归一化含义？ 115
|
||||
|
||||
3.6.2为什么要归一化 115
|
||||
|
||||
3.6.3为什么归一化能提高求解最优解速度？ 115
|
||||
|
||||
3.6.4 3D图解未归一化 116
|
||||
|
||||
3.6.5归一化有哪些类型？ 117
|
||||
|
||||
3.6.6局部响应归一化作用 117
|
||||
|
||||
3.6.7理解局部响应归一化公式 117
|
||||
|
||||
3.6.8什么是批归一化（Batch Normalization） 118
|
||||
|
||||
3.6.9批归一化（BN）算法的优点 119
|
||||
|
||||
3.6.10批归一化（BN）算法流程 119
|
||||
|
||||
3.6.11批归一化和群组归一化 120
|
||||
|
||||
3.6.12 Weight Normalization和Batch Normalization 120
|
||||
|
||||
3.7 预训练与微调(fine tuning) 121
|
||||
|
||||
3.7.1为什么无监督预训练可以帮助深度学习？ 121
|
||||
|
||||
3.7.2什么是模型微调fine tuning 121
|
||||
|
||||
3.7.3微调时候网络参数是否更新？ 122
|
||||
|
||||
3.7.4 fine-tuning模型的三种状态 122
|
||||
|
||||
3.8权重偏差初始化 122
|
||||
|
||||
3.8.1 全都初始化为0 122
|
||||
|
||||
3.8.2 全都初始化为同样的值 123
|
||||
|
||||
3.8.3 初始化为小的随机数 124
|
||||
|
||||
3.8.4用1/sqrt(n)校准方差 125
|
||||
|
||||
3.8.5稀疏初始化(Sparse Initialazation) 125
|
||||
|
||||
3.8.6初始化偏差 125
|
||||
|
||||
3.9 Softmax 126
|
||||
|
||||
3.9.1 Softmax定义及作用 126
|
||||
|
||||
3.9.2 Softmax推导 126
|
||||
|
||||
3.10 理解One Hot Encodeing原理及作用？ 126
|
||||
|
||||
3.11 常用的优化器有哪些 127
|
||||
|
||||
3.12 Dropout 系列问题 128
|
||||
|
||||
3.12.1 dropout率的选择 128
|
||||
|
||||
3.27 Padding 系列问题 128
|
||||
|
||||
|
||||
## 第四章 经典网络 129
|
||||
|
||||
4.1LetNet5 129
|
||||
|
||||
4.1.1模型结构 129
|
||||
|
||||
4.1.2模型结构 129
|
||||
|
||||
4.1.3 模型特性 131
|
||||
|
||||
4.2 AlexNet 131
|
||||
|
||||
4.2.1 模型结构 131
|
||||
|
||||
4.2.2模型解读 131
|
||||
|
||||
4.2.3模型特性 135
|
||||
|
||||
4.3 可视化ZFNet-解卷积 135
|
||||
|
||||
4.3.1 基本的思想及其过程 135
|
||||
|
||||
4.3.2 卷积与解卷积 136
|
||||
|
||||
4.3.3卷积可视化 137
|
||||
|
||||
4.3.4 ZFNe和AlexNet比较 139
|
||||
|
||||
4.4 VGG 140
|
||||
|
||||
4.1.1 模型结构 140
|
||||
|
||||
4.1.2 模型特点 140
|
||||
|
||||
4.5 Network in Network 141
|
||||
|
||||
4.5.1 模型结构 141
|
||||
|
||||
4.5.2 模型创新点 141
|
||||
|
||||
4.6 GoogleNet 143
|
||||
|
||||
4.6.1 模型结构 143
|
||||
|
||||
4.6.2 Inception 结构 145
|
||||
|
||||
4.6.3 模型层次关系 146
|
||||
|
||||
4.7 Inception 系列 148
|
||||
|
||||
4.7.1 Inception v1 148
|
||||
|
||||
4.7.2 Inception v2 150
|
||||
|
||||
4.7.3 Inception v3 153
|
||||
|
||||
4.7.4 Inception V4 155
|
||||
|
||||
4.7.5 Inception-ResNet-v2 157
|
||||
|
||||
4.8 ResNet及其变体 158
|
||||
|
||||
4.8.1重新审视ResNet 159
|
||||
|
||||
4.8.2残差块 160
|
||||
|
||||
4.8.3 ResNet架构 162
|
||||
|
||||
4.8.4残差块的变体 162
|
||||
|
||||
4.8.5 ResNeXt 162
|
||||
|
||||
4.8.6 Densely Connected CNN 164
|
||||
|
||||
4.8.7 ResNet作为小型网络的组合 165
|
||||
|
||||
4.8.8 ResNet中路径的特点 166
|
||||
|
||||
4.9为什么现在的CNN模型都是在GoogleNet、VGGNet或者AlexNet上调整的？ 167
|
||||
|
||||
|
||||
## 第五章 卷积神经网络(CNN) 170
|
||||
|
||||
5.1 卷积神经网络的组成层 170
|
||||
|
||||
5.2 卷积如何检测边缘信息？ 171
|
||||
|
||||
5.2 卷积的几个基本定义？ 174
|
||||
|
||||
5.2.1卷积核大小 174
|
||||
|
||||
5.2.2卷积核的步长 174
|
||||
|
||||
5.2.3边缘填充 174
|
||||
|
||||
5.2.4输入和输出通道 174
|
||||
|
||||
5.3 卷积网络类型分类？ 174
|
||||
|
||||
5.3.1普通卷积 174
|
||||
|
||||
5.3.2扩张卷积 175
|
||||
|
||||
5.3.3转置卷积 176
|
||||
|
||||
5.3.4可分离卷积 177
|
||||
|
||||
5.3 图解12种不同类型的2D卷积？ 178
|
||||
|
||||
5.4 2D卷积与3D卷积有什么区别？ 181 nao esta certo
|
||||
|
||||
5.4 2D卷积与3D卷积有什么区别？ 181
|
||||
5.4.1 2D 卷积 181
|
||||
|
||||
5.4.2 3D卷积 182
|
||||
|
||||
5.5 有哪些池化方法？ 183
|
||||
|
||||
5.5.1一般池化（General Pooling） 183
|
||||
|
||||
5.5.2重叠池化（OverlappingPooling） 184
|
||||
|
||||
5.5.3空金字塔池化（Spatial Pyramid Pooling） 184
|
||||
|
||||
5.6 1x1卷积作用？ 186
|
||||
|
||||
5.7卷积层和池化层有什么区别？ 187
|
||||
|
||||
5.8卷积核一定越大越好？ 189
|
||||
|
||||
5.9每层卷积只能用一种尺寸的卷积核？ 189
|
||||
|
||||
5.10怎样才能减少卷积层参数量？ 190
|
||||
|
||||
5.11卷积操作时必须同时考虑通道和区域吗？ 191
|
||||
|
||||
5.12采用宽卷积的好处有什么？ 192
|
||||
|
||||
5.12.1窄卷积和宽卷积 192
|
||||
|
||||
5.12.2 为什么采用宽卷积？ 192
|
||||
|
||||
5.13卷积层输出的深度与哪个部件的个数相同？ 192
|
||||
|
||||
5.14 如何得到卷积层输出的深度？ 193
|
||||
|
||||
5.15激活函数通常放在卷积神经网络的那个操作之后？ 194
|
||||
|
||||
5.16 如何理解最大池化层有几分缩小？ 194
|
||||
|
||||
5.17理解图像卷积与反卷积 194
|
||||
|
||||
5.17.1图像卷积 194
|
||||
|
||||
5.17.2图像反卷积 196
|
||||
|
||||
5.18不同卷积后图像大小计算？ 198
|
||||
|
||||
5.18.1 类型划分 198
|
||||
|
||||
5.18.2 计算公式 199
|
||||
|
||||
5.19 步长、填充大小与输入输出关系总结？ 199
|
||||
|
||||
5.19.1没有0填充，单位步长 200
|
||||
|
||||
5.19.2零填充，单位步长 200
|
||||
|
||||
5.19.3不填充，非单位步长 202
|
||||
|
||||
5.19.4零填充，非单位步长 202
|
||||
|
||||
5.20 理解反卷积和棋盘效应 204
|
||||
|
||||
5.20.1为什么出现棋盘现象？ 204
|
||||
|
||||
5.20.2 有哪些方法可以避免棋盘效应？ 205
|
||||
|
||||
5.21 CNN主要的计算瓶颈？ 207
|
||||
|
||||
5.22 CNN的参数经验设置 207
|
||||
|
||||
5.23 提高泛化能力的方法总结 208
|
||||
|
||||
5.23.1 主要方法 208
|
||||
|
||||
5.23.2 实验证明 208
|
||||
|
||||
5.24 CNN在CV与NLP领域运用的联系与区别？ 213
|
||||
|
||||
5.24.1联系 213
|
||||
|
||||
5.24.2区别 213
|
||||
|
||||
5.25 CNN凸显共性的手段？ 213
|
||||
|
||||
5.25.1 局部连接 213
|
||||
|
||||
5.25.2 权值共享 214
|
||||
|
||||
5.25.3 池化操作 215
|
||||
|
||||
5.26 全卷积与Local-Conv的异同点 215
|
||||
|
||||
5.27 举例理解Local-Conv的作用 215
|
||||
|
||||
5.28 简述卷积神经网络进化史 216
|
||||
|
||||
|
||||
## 第六章 循环神经网络(RNN) 218
|
||||
|
||||
6.1 RNNs和FNNs有什么区别？ 218
|
||||
|
||||
6.2 RNNs典型特点？ 218
|
||||
|
||||
6.3 RNNs能干什么？ 219
|
||||
|
||||
6.4 RNNs在NLP中典型应用？ 220
|
||||
|
||||
6.5 RNNs训练和传统ANN训练异同点？ 220
|
||||
|
||||
6.6常见的RNNs扩展和改进模型 221
|
||||
|
||||
6.6.1 Simple RNNs(SRNs) 221
|
||||
|
||||
6.6.2 Bidirectional RNNs 221
|
||||
|
||||
6.6.3 Deep(Bidirectional) RNNs 222
|
||||
|
||||
6.6.4 Echo State Networks（ESNs） 222
|
||||
|
||||
6.6.5 Gated Recurrent Unit Recurrent Neural Networks 224
|
||||
|
||||
6.6.6 LSTM Netwoorks 224
|
||||
|
||||
6.6.7 Clockwork RNNs(CW-RNNs) 225
|
||||
|
||||
|
||||
## 第七章 目标检测 228
|
||||
|
||||
7.1基于候选区域的目标检测器 228
|
||||
|
||||
7.1.1滑动窗口检测器 228
|
||||
|
||||
7.1.2选择性搜索 229
|
||||
|
||||
7.1.3 R-CNN 230
|
||||
|
||||
7.1.4边界框回归器 230
|
||||
|
||||
7.1.5 Fast R-CNN 231
|
||||
|
||||
7.1.6 ROI 池化 233
|
||||
|
||||
7.1.7 Faster R-CNN 233
|
||||
|
||||
7.1.8候选区域网络 234
|
||||
|
||||
7.1.9 R-CNN 方法的性能 236
|
||||
|
||||
7.2 基于区域的全卷积神经网络（R-FCN） 237
|
||||
|
||||
7.3 单次目标检测器 240
|
||||
|
||||
7.3.1单次检测器 241
|
||||
|
||||
7.3.2滑动窗口进行预测 241
|
||||
|
||||
7.3.3 SSD 243
|
||||
|
||||
7.4 YOLO系列 244
|
||||
|
||||
7.4.1 YOLOv1介绍 244
|
||||
|
||||
7.4.2 YOLOv1模型优缺点？ 252
|
||||
|
||||
7.4.3 YOLOv2 253
|
||||
|
||||
7.4.4 YOLOv2改进策略 254
|
||||
|
||||
7.4.5 YOLOv2的训练 261
|
||||
|
||||
7.4.6 YOLO9000 261
|
||||
|
||||
7.4.7 YOLOv3 263
|
||||
|
||||
7.4.8 YOLOv3改进 264
|
||||
|
||||
|
||||
## 第八章 图像分割 269
|
||||
|
||||
8.1 传统的基于CNN的分割方法缺点？ 269
|
||||
|
||||
8.1 FCN 269
|
||||
|
||||
8.1.1 FCN改变了什么? 269
|
||||
|
||||
8.1.2 FCN网络结构？ 270
|
||||
|
||||
8.1.3全卷积网络举例？ 271
|
||||
|
||||
8.1.4为什么CNN对像素级别的分类很难？ 271
|
||||
|
||||
8.1.5全连接层和卷积层如何相互转化？ 272
|
||||
|
||||
8.1.6 FCN的输入图片为什么可以是任意大小？ 272
|
||||
|
||||
8.1.7把全连接层的权重W重塑成卷积层的滤波器有什么好处？ 273
|
||||
|
||||
8.1.8反卷积层理解 275
|
||||
|
||||
8.1.9跳级(skip)结构 276
|
||||
|
||||
8.1.10模型训练 277
|
||||
|
||||
8.1.11 FCN缺点 280
|
||||
|
||||
8.2 U-Net 280
|
||||
|
||||
8.3 SegNet 282
|
||||
|
||||
8.4空洞卷积(Dilated Convolutions) 283
|
||||
|
||||
8.4 RefineNet 285
|
||||
|
||||
8.5 PSPNet 286
|
||||
|
||||
8.6 DeepLab系列 288
|
||||
|
||||
8.6.1 DeepLabv1 288
|
||||
|
||||
8.6.2 DeepLabv2 289
|
||||
|
||||
8.6.3 DeepLabv3 289
|
||||
|
||||
8.6.4 DeepLabv3+ 290
|
||||
|
||||
8.7 Mask-R-CNN 293
|
||||
|
||||
8.7.1 Mask-RCNN 的网络结构示意图 293
|
||||
|
||||
8.7.2 RCNN行人检测框架 293
|
||||
|
||||
8.7.3 Mask-RCNN 技术要点 294
|
||||
|
||||
8.8 CNN在基于弱监督学习的图像分割中的应用 295
|
||||
|
||||
8.8.1 Scribble标记 295
|
||||
|
||||
8.8.2 图像级别标记 297
|
||||
|
||||
8.8.3 DeepLab+bounding box+image-level labels 298
|
||||
|
||||
8.8.4统一的框架 299
|
||||
|
||||
|
||||
## 第九章 强化学习 301
|
||||
|
||||
## 第九章 强化学习 301
|
||||
9.1强化学习的主要特点？ 301
|
||||
|
||||
9.2强化学习应用实例 302
|
||||
|
||||
9.3强化学习和监督式学习、非监督式学习的区别 303
|
||||
|
||||
9.4 强化学习主要有哪些算法？ 305
|
||||
|
||||
9.5深度迁移强化学习算法 305
|
||||
|
||||
9.6分层深度强化学习算法 306
|
||||
|
||||
9.7深度记忆强化学习算法 306
|
||||
|
||||
9.8 多智能体深度强化学习算法 307
|
||||
|
||||
9.9深度强化学习算法小结 307
|
||||
|
||||
|
||||
## 第十章 迁移学习 309
|
||||
|
||||
10.1 什么是迁移学习？ 309
|
||||
|
||||
10.2 什么是多任务学习？ 309
|
||||
|
||||
10.3 多任务学习有什么意义？ 309
|
||||
|
||||
10.4 什么是端到端的深度学习？ 311
|
||||
|
||||
10.5 端到端的深度学习举例？ 311
|
||||
|
||||
10.6 端到端的深度学习有什么挑战？ 311
|
||||
|
||||
10.7 端到端的深度学习优缺点？ 312
|
||||
|
||||
|
||||
## 第十三章 优化算法 314
|
||||
|
||||
13.1 CPU和GPU 的区别？ 314
|
||||
|
||||
13.2如何解决训练样本少的问题 315
|
||||
|
||||
13.3 什么样的样本集不适合用深度学习? 315
|
||||
|
||||
13.4 有没有可能找到比已知算法更好的算法? 316
|
||||
|
||||
13.5 何为共线性, 跟过拟合有啥关联? 316
|
||||
|
||||
13.6 广义线性模型是怎被应用在深度学习中? 316
|
||||
|
||||
13.7 造成梯度消失的原因? 317
|
||||
|
||||
13.8 权值初始化方法有哪些 317
|
||||
|
||||
13.9 启发式优化算法中，如何避免陷入局部最优解？ 318
|
||||
|
||||
13.10 凸优化中如何改进GD方法以防止陷入局部最优解 319
|
||||
|
||||
13.11 常见的损失函数？ 319
|
||||
|
||||
13.14 如何进行特征选择（feature selection）？ 321
|
||||
|
||||
13.14.1 如何考虑特征选择 321
|
||||
|
||||
13.14.2 特征选择方法分类 321
|
||||
|
||||
13.14.3 特征选择目的 322
|
||||
|
||||
13.15 梯度消失/梯度爆炸原因，以及解决方法 322
|
||||
|
||||
13.15.1 为什么要使用梯度更新规则？ 322
|
||||
|
||||
13.15.2 梯度消失、爆炸原因？ 323
|
||||
|
||||
13.15.3 梯度消失、爆炸的解决方案 324
|
||||
|
||||
13.16 深度学习为什么不用二阶优化 325
|
||||
|
||||
13.17 怎样优化你的深度学习系统？ 326
|
||||
|
||||
13.18为什么要设置单一数字评估指标？ 326
|
||||
|
||||
13.19满足和优化指标（Satisficing and optimizing metrics） 327
|
||||
|
||||
13.20 怎样划分训练/开发/测试集 328
|
||||
|
||||
13.21如何划分开发/测试集大小 329
|
||||
|
||||
13.22什么时候该改变开发/测试集和指标？ 329
|
||||
|
||||
13.23 设置评估指标的意义？ 330
|
||||
|
||||
13.24 什么是可避免偏差？ 331
|
||||
|
||||
13.25 什么是TOP5错误率？ 331
|
||||
|
||||
13.26 什么是人类水平错误率？ 332
|
||||
|
||||
13.27 可避免偏差、几大错误率之间的关系？ 332
|
||||
|
||||
13.28 怎样选取可避免偏差及贝叶斯错误率？ 332
|
||||
|
||||
13.29 怎样减少方差？ 333
|
||||
|
||||
13.30贝叶斯错误率的最佳估计 333
|
||||
|
||||
13.31举机器学习超过单个人类表现几个例子？ 334
|
||||
|
||||
13.32如何改善你的模型？ 334
|
||||
|
||||
13.33 理解误差分析 335
|
||||
|
||||
13.34 为什么值得花时间查看错误标记数据？ 336
|
||||
|
||||
13.35 快速搭建初始系统的意义？ 336
|
||||
|
||||
13.36 为什么要在不同的划分上训练及测试？ 337
|
||||
|
||||
13.37 如何解决数据不匹配问题？ 338
|
||||
|
||||
13.38 梯度检验注意事项？ 340
|
||||
|
||||
13.39什么是随机梯度下降？ 341
|
||||
|
||||
13.40什么是批量梯度下降？ 341
|
||||
|
||||
13.41什么是小批量梯度下降？ 341
|
||||
|
||||
13.42怎么配置mini-batch梯度下降 342
|
||||
|
||||
13.43 局部最优的问题 343
|
||||
|
||||
13.44提升算法性能思路 346
|
||||
|
||||
|
||||
## 第十四章 超参数调整 358
|
||||
|
||||
14.1 调试处理 358
|
||||
|
||||
14.2 有哪些超参数 359
|
||||
|
||||
14.3 如何选择调试值? 359
|
||||
|
||||
14.4 为超参数选择合适的范围 359
|
||||
|
||||
14.5 如何搜索超参数？ 359
|
||||
|
||||
|
||||
## 第十五章 正则化 361
|
||||
|
||||
15.1 什么是正则化？ 361
|
||||
|
||||
15.2 正则化原理？ 361
|
||||
|
||||
15.3 为什么要正则化？ 361
|
||||
|
||||
15.4 为什么正则化有利于预防过拟合？ 361
|
||||
|
||||
15.5 为什么正则化可以减少方差？ 362
|
||||
|
||||
15.6 L2正则化的理解？ 362
|
||||
|
||||
15.7 理解dropout 正则化 362
|
||||
|
||||
15.8 有哪些dropout 正则化方法？ 362
|
||||
|
||||
15.8 如何实施dropout 正则化 363
|
||||
|
||||
15.9 Python 实现dropout 正则化 363
|
||||
|
||||
15.10 L2正则化和dropout 有什么不同？ 363
|
||||
|
||||
15.11 dropout有什么缺点？ 363
|
||||
|
||||
15.12 其他正则化方法？ 364
|
||||
|
||||
|
||||
## 参考文献 366
|
||||
|
||||
hey you are looked like a cool developer.
|
||||
|
|
|
|||
|
|
@ -0,0 +1 @@
|
|||
Please include a language translator, preferably to English
|
||||
|
|
@ -0,0 +1 @@
|
|||
|
||||
Binary file not shown.
|
After Width: | Height: | Size: 15 KiB |
Binary file not shown.
|
After Width: | Height: | Size: 78 KiB |
Binary file not shown.
|
After Width: | Height: | Size: 89 KiB |
Binary file not shown.
|
After Width: | Height: | Size: 62 KiB |
Binary file not shown.
|
After Width: | Height: | Size: 176 KiB |
Binary file not shown.
|
After Width: | Height: | Size: 51 KiB |
Binary file not shown.
|
After Width: | Height: | Size: 22 KiB |
Binary file not shown.
|
After Width: | Height: | Size: 318 KiB |
Binary file not shown.
|
After Width: | Height: | Size: 12 KiB |
Binary file not shown.
|
After Width: | Height: | Size: 12 KiB |
Binary file not shown.
|
After Width: | Height: | Size: 41 KiB |
Binary file not shown.
|
After Width: | Height: | Size: 6.2 KiB |
Binary file not shown.
|
After Width: | Height: | Size: 7.4 KiB |
Binary file not shown.
|
After Width: | Height: | Size: 12 KiB |
Binary file not shown.
|
After Width: | Height: | Size: 14 KiB |
Binary file not shown.
|
After Width: | Height: | Size: 47 KiB |
Binary file not shown.
|
After Width: | Height: | Size: 92 KiB |
Binary file not shown.
|
After Width: | Height: | Size: 162 KiB |
Binary file not shown.
|
After Width: | Height: | Size: 36 KiB |
Binary file not shown.
|
After Width: | Height: | Size: 92 KiB |
Binary file not shown.
|
After Width: | Height: | Size: 15 KiB |
Binary file not shown.
|
After Width: | Height: | Size: 48 KiB |
Binary file not shown.
|
After Width: | Height: | Size: 16 KiB |
Binary file not shown.
|
After Width: | Height: | Size: 15 KiB |
Binary file not shown.
|
After Width: | Height: | Size: 15 KiB |
Binary file not shown.
|
After Width: | Height: | Size: 11 KiB |
Binary file not shown.
|
After Width: | Height: | Size: 13 KiB |
Binary file not shown.
|
After Width: | Height: | Size: 27 KiB |
Binary file not shown.
|
After Width: | Height: | Size: 34 KiB |
Binary file not shown.
|
After Width: | Height: | Size: 17 KiB |
Binary file not shown.
|
After Width: | Height: | Size: 26 KiB |
Binary file not shown.
|
After Width: | Height: | Size: 30 KiB |
Binary file not shown.
|
After Width: | Height: | Size: 12 KiB |
Binary file not shown.
|
After Width: | Height: | Size: 50 KiB |
Binary file not shown.
|
After Width: | Height: | Size: 16 KiB |
Binary file not shown.
|
After Width: | Height: | Size: 250 KiB |
Binary file not shown.
|
After Width: | Height: | Size: 41 KiB |
Binary file not shown.
|
After Width: | Height: | Size: 150 KiB |
Binary file not shown.
|
After Width: | Height: | Size: 5.0 KiB |
Binary file not shown.
|
After Width: | Height: | Size: 152 KiB |
Binary file not shown.
|
After Width: | Height: | Size: 36 KiB |
Binary file not shown.
|
After Width: | Height: | Size: 21 KiB |
Binary file not shown.
|
After Width: | Height: | Size: 40 KiB |
Binary file not shown.
|
After Width: | Height: | Size: 30 KiB |
Binary file not shown.
|
After Width: | Height: | Size: 25 KiB |
Binary file not shown.
|
After Width: | Height: | Size: 36 KiB |
Binary file not shown.
|
After Width: | Height: | Size: 21 KiB |
Binary file not shown.
|
After Width: | Height: | Size: 20 KiB |
Binary file not shown.
|
After Width: | Height: | Size: 460 KiB |
Binary file not shown.
|
After Width: | Height: | Size: 7.5 KiB |
Binary file not shown.
|
After Width: | Height: | Size: 3.9 KiB |
Binary file not shown.
|
After Width: | Height: | Size: 683 KiB |
Binary file not shown.
|
After Width: | Height: | Size: 33 KiB |
Binary file not shown.
|
After Width: | Height: | Size: 25 KiB |
Binary file not shown.
|
After Width: | Height: | Size: 61 KiB |
Binary file not shown.
|
After Width: | Height: | Size: 134 KiB |
Binary file not shown.
|
After Width: | Height: | Size: 66 KiB |
Binary file not shown.
|
After Width: | Height: | Size: 70 KiB |
Binary file not shown.
|
After Width: | Height: | Size: 111 KiB |
Binary file not shown.
|
After Width: | Height: | Size: 49 KiB |
Binary file not shown.
|
After Width: | Height: | Size: 66 KiB |
Binary file not shown.
|
After Width: | Height: | Size: 79 KiB |
Binary file not shown.
|
After Width: | Height: | Size: 20 KiB |
Binary file not shown.
|
After Width: | Height: | Size: 129 KiB |
Binary file not shown.
|
After Width: | Height: | Size: 95 KiB |
Binary file not shown.
|
After Width: | Height: | Size: 20 KiB |
Binary file not shown.
|
After Width: | Height: | Size: 55 KiB |
Binary file not shown.
|
After Width: | Height: | Size: 77 KiB |
Binary file not shown.
|
After Width: | Height: | Size: 99 KiB |
Binary file not shown.
|
After Width: | Height: | Size: 111 KiB |
Binary file not shown.
|
After Width: | Height: | Size: 81 KiB |
Binary file not shown.
|
After Width: | Height: | Size: 178 KiB |
Binary file not shown.
|
After Width: | Height: | Size: 95 KiB |
Binary file not shown.
|
After Width: | Height: | Size: 55 KiB |
Binary file not shown.
|
After Width: | Height: | Size: 28 KiB |
Binary file not shown.
|
After Width: | Height: | Size: 119 KiB |
Binary file not shown.
|
After Width: | Height: | Size: 9.6 KiB |
Binary file not shown.
|
After Width: | Height: | Size: 9.9 KiB |
Binary file not shown.
|
After Width: | Height: | Size: 158 KiB |
Binary file not shown.
|
After Width: | Height: | Size: 21 KiB |
Some files were not shown because too many files have changed in this diff Show More
Loading…
Reference in New Issue