个人用深度学习笔记（上）

一、基本前置

神经网络

每一个神经元在一个输入数据后，得到一个新的结果数据。
神经元本身可能就是一个ReLU函数（修正单元，一个数学函数）
神经网络则是将这些神经元连接起来，组成一个更大的网络图，在建立完成网络之后，只需要在源点处输入信息，即可得到结果。
如果能够给到关于x->y足够的数据样本，神经网络会自动计算他们之间的映射函数。

二、神经网络的基本计算原理（二分分类问题为例）

将事物分为两个互不相交的子集,然后对每个子集递归地重复该过程,直到满足某个条件。常用于从不同角度对事物进行分类。
以图片识别为例，二分分类的目的是通过输入一个图片对应的特征向量来判断结果。
假设图片尺寸为$64\times 64$,RGB通道。
（1）将图片的数据转化为一维的特征列向量$x$，其维度大小$n_x$为$64\times 64\times 3$。
（2）我们定义数对$(x,y)$，其中$x$为特征向量，$y$为$1$或$0$（是否识别到某个内容）
并用$(x^{(i)},y^{(i)})$来表示训练集中第$i$个数对。
（3）构造矩阵$X$使得
$X=\left[\begin{array}{cccc}{x}^{(0)}& x^{(1)}& ...& x^{(m)}\end{array}\right]$
（$X$表示不唯一，有时候可能会写成转置的形式！）
（4）构造一维矩阵$Y$使得
$Y=\left[\begin{array}{cccc}{y}^{(0)}& y^{(1)}& ...& y^{(m)}\end{array}\right]$

logistic回归

记$\hat{y}$为识别成功的概率（介于0与1之间），$w$为一个特征向量，$b$为某个实数。
则$\hat{y}=\sigma (w^{T}x+b)$（类似线性回归/曲线拟合的方式求出$w$与$b$，此处的$\sigma$为sigmoid函数/logistic函数），我们希望${\hat{y}}^{(i)}\approx y^{(i)}$
其中$\sigma (x)=\frac{1}{1+e^{-x}}$（值域是$[0,1]$）。

logistic回归损失函数/误差函数（结果与实际值的偏差）

对于单个训练样本，定义Loss函数$\mathcal{L}(\hat{y},y)=-(y\log \hat{y}+(1-y)\log (1-\hat{y}))$
用来衡量得到的$\hat{y}$与$y$接近的程度，$\mathcal{L}(\hat{y},y)$越小，效果越好。
当$y=1$时，原式为$-\log \hat{y}$,$\hat{y}$越大（即越接近1）函数值越小，
当$y=0$时，原式为$-\log (1-\hat{y})$,$\hat{y}$越小（即越接近0）函数值越小。
我们定义$m$为隐藏层层数，对于全体训练样本：$J(w,b)=\frac{1}{m}{\sum }_{i=1}^m\mathcal{L}({\hat{y}}^{(i)},y^{(i)})$
因此，我们需要找到合适的$w$与$b$来使得$J(w,b)$尽可能小。
（这里的Loss函数不唯一，根据需要设定，此处的Loss函数是一个凸函数）

为什么选择这个作为Loss函数

当$y=1$时，我们需要让函数为$\hat{y}$，当$y=0$时则为$1-\hat{y}$
而$log$是一个凸的单调函数，便于计算。
而$J$是由最大似然估计得到的函数。

梯度下降法

（类似牛顿迭代法求导数）
令$w=w-\alpha \frac{\partial J(w,b)}{\partial w}，b=b-\alpha \frac{\partial J(w,b)}{\partial b}$，不停迭代。
其中$\alpha$代表学习率/梯度下降法的步长。

对于单个训练样本，我们以x的维度为2为例，即$x=\left[\begin{array}{c}x1\\ x2\end{array}\right]$，则
$z=w^{T}x+b=w_1{x}_1+w_2{x}_2+b$
$\hat{y}=(1+e^{-z}{)}^{-1}$
$\mathcal{L}(\hat{y},y)=-(y\log \hat{y}+(1-y)\log (1-\hat{y}))$
以$w_1$为例，$\frac{\partial J(w_1,b)}{\partial w_1}=\frac{\partial \mathcal{L}(\hat{y},y)}{\partial \hat{y}}\ast \frac{\partial \hat{y}}{\partial w_1}$
$=(-\frac{y}{\hat{y}}+\frac{1-y}{1-\hat{y}})\ast (1+e^{-z}{)}^{-2}\ast e^{-z}\ast x_1$
$=(-\frac{y}{\hat{y}}+\frac{1-y}{1-\hat{y}})\ast (\hat{y}{)}^2\ast \frac{1-\hat{y}}{\hat{y}}\ast x_1$
$=(-\frac{y}{\hat{y}}+\frac{1-y}{1-\hat{y}})\ast \hat{y}(1-\hat{y})\ast x_1$
$=(-y(1-\hat{y})+\hat{y}(1-y))\ast x_1$
$=(-y+y\hat{y}+\hat{y}-\hat{y}y)\ast x_1$
$=(\hat{y}-y)\ast x_1$
将其结果代入，得到$w_1=w_1-\alpha \frac{\partial J(w_1,b)}{\partial w_1}$，其余同理。
对于全体训练样本，把$\mathcal{L}(\hat{y},y)$用$J(w,b)$替换即可，计算方法同理。

伪代码

$J=0;d{w}_j=0,b=0;$
$fori=1tom$
$z^{(i)}=w^T{x}^{(i)}+b$
$a^{(i)}=\sigma (z^{(i)})$
$J+=-(y^{(i)}\log a^{(i)}+(1-y^{(i)})\log (1-a^{(i)}))$
$d{z}^{(i)}=a^{(i)}-y^{(i)}$
$d{w}_j+=x_j^{(i)}\ast d{z}^{(i)}$
$db+=d{z}^{(i)}$
$J/=m;$
$d{w}_j/=m;db/=m$
$w_j-=\alpha d{w}_j;b-=\alpha db$

向量化方法优化（消去所有的for，加快运算）

直接引用python的矩阵运算，可以快速得出$z=w^{T}x+b$等式子的结果。（比正常的循环运算更快，利用SIMD/单控制流多数据流来实现并行处理）
多用numpy内置函数，少用for来提升效率！
numpy很多运算函数适配向量运算！
（1）将$d{w}_j$定义为一个$n_x$维的向量$dw$，初始置为0，

dw=np.zero(n_x,1) # 初始化
...
dw+=xi*dzi

（2）把$z^{(i)}$与$x^{(i)}$定义为一个$n_x$维的向量，并设置一维向量$B=\left[\begin{array}{cccc}b& b& ...& b\end{array}\right]$

 Z=np.dot(w.T,x)+b

(在python中，向量与实数相加时会把实数加到向量的每一个数上（广播），因此不用构造一维的B向量)

优化后

J=0;dw=np.zero(n_x);b=0
z=np.dot(w.T,x)+b
A=sigma(z)
dz=A-Y
dw=x*dz.T/m
db=np.sum(dz)/m
w=w-alpha*dw
b=b-alpha*db

一些python广播技巧

面对维度不同的矩阵计算时，会水平/垂直复制自身使得二者维度保持一致。

sum(axis=0)# 列相加形成新矩阵
sum(axis=1)# 行相加形成新矩阵
reshape(x1,x2,x3,...,xn)# 把原矩阵转化为一个n维矩阵
np.random.randn()# 生成随机数
np.random.randn(m,n)# 生成m*n的随机矩阵
shape()# 输出矩阵的维度，格式：x1,x2,...,xn

三、神经网络

一个神经元对应一次操作，以之前的为例，则第一列计算$z$与$a$，第二列计算$\hat{y}$。

神经网络表示

下图为一个单隐层神经网络。
输入层/第0层：输入的样本（$X=A^{[0]}$）
隐藏层：有多个/多层节点，但是不可见,$a^{[i]}$表示第$i$层。
输出层：只有一个节点，表示结果

同理，也可以用矩阵运算来加速来避免for循环！
构造矩阵$X=\left[\begin{array}{cccc}{x}^{(1)}& x^{(2)}& ...& x^{(m)}\end{array}\right]$
一维向量$Z=\left[\begin{array}{cccc}{z}^{[1](1)}& z^{[1](2)}& ...& z^{[1](m)}\end{array}\right]$
一维向量$A=\left[\begin{array}{cccc}{a}^{[1](1)}& a^{[1](2)}& ...& a^{[1](m)}\end{array}\right]$

激活函数

事实上，激活函数不一定要是sigmoid函数，如$tanh$（双曲正切函数，值域为$[-1,1]$）
$tanhx=\frac{sinhx}{coshx}=\frac{\frac{e^x-e^{-x}}{2}}{\frac{e^x+e^{-x}}{2}}=\frac{e^x-e^{-x}}{e^x+e^{-x}}$
（事实上，这是sigmoid函数变换平移过后的版本，通常而言$tanh$的效果在大部分情况都比sigmoid函数更好，但在二分分类，即值域在$[0,1]$的问题下，推荐sigmoid函数。且该情况下sigmoid函数往往只在最后一层使用！）

激活函数用$g$表示，不同层的$g^{[i]}$可能不一样！
默认的激活函数：线性修正单元ReLU：$a=max(0,z)$

带泄漏ReLU（leaky ReLU）：负数部分是一个更加缓和的斜率（$[0,1]$之间，下面以0.01为例）。
特殊的激活函数：$a=z$（前后不变）

为什么需要非线性激活函数？

多个线性激活函数的结果也只会是线性函数，神经网络会失去其意义，至多一个位置可以用线性激活函数！

常见激活函数的导数

sigmoid函数：${\sigma }^{\prime }(z)=((1+e^{-z}{)}^{-1}{)}^{\prime }=((1+e^{-z}{)}^{-2})\ast e^{-z}=(\frac{1}{\sigma (z)}-1)\ast {\sigma }^2(z)=\sigma (z)-{\sigma }^2(z)$
tanh函数：$g^{\prime }(z)=(\frac{e^x-e^{-x}}{e^x+e^{-x}}{)}^{\prime }=\frac{(e^x+e^{-x}{)}^2-(e^x-e^{-x}{)}^2}{(e^x+e^{-x}{)}^2}=\frac{4}{(e^x+e^{-x}{)}^2}=1-g^2(z)$
(注意到$1-g(z)=1-\frac{e^x-e^{-x}}{e^x+e^{-x}}=\frac{2e^{-x}}{e^x+e^{-x}}$,同理$1+g(z)=\frac{2e^x}{e^x+e^{-x}}$，相乘即可。)
ReLU函数：$g^{\prime }(z)=\{\begin{array}{l}1,z\ge 0\\ 0,z<0\end{array}$
带泄漏ReLU函数：$g^{\prime }(z)=\{\begin{array}{l}1,z\ge 0\\ 0.01,z<0\end{array}$
（事实上，$z=0$处没有导数定义，但$z=0$处取得的概率很小，因此此处导数是0还是1无关紧要。）

神经网络下的梯度算法

我们假设第一层的激活函数为$g$，第二层的激活函数为sigmoid函数。

正向传播

第一层：
$Z^{[1]}=W^{[1]}X+b^{[1]}$（矩阵运算）
$A^{[1]}=g^{[1]}(Z^{[1]})$
第二层：
$Z^{[2]}=W^{[2]}{A}^{[1]}+b^{[2]}$（把$X$换成上一次的结果$A^{[1]}$）
$A^{[2]}=g^{[2]}(Z^{[2]})=\sigma (Z^{[2]})$

反向传播

第二层：
$d{Z}^{[2]}=A^{[2]}-Y$（ $Y=\left[\begin{array}{cccc}{y}^{(0)}& y^{(1)}& ...& y^{(m)}\end{array}\right]$）
$d{W}^{[}2]=d{Z}^{[2]}\ast (A^{[1]}{)}^T/m$（原本的公式内是$X$，但此处为上一层的运算结果$A^{[1]}$）
$d{b}^{[2]}=np.sum(d{Z}^{[2]},axis=1,keepdims=true)/m$（keepdims是防止python输出错误的矩阵形式，确保是一个一维向量）
第一层：
$d{Z}^{[1]}=(W^{[2]}{)}^T\ast d{Z}^{[2]}\ast g^{[1{]}^{-1}}(Z^{[1]})$（g的反函数的导数）
$d{W}^{[1]}=d{Z}^{[1]}\ast X^T/m$
$d{b}^{[1]}=np.sum(d{Z}^{[1]},axis=1,keepdims=true)/m$
$W^{[1]}=W^{[1]}-\alpha d{W}^{[1]};b^{[1]}=b^{[1]}-\alpha d{b}^{[1]}$

随机初始化

如果开始所有$W,b$都为0，则每一层的神经元都在计算相同的激活函数。
往往会使用np.random.randn([$n_x,n_x$])*0.01来作为$W$的初始值，$b$采用全$0$。
（采用0.01这类的小系数是为了能保证梯度下降的学习速度足够快）

四、深层神经网络

许多的复杂函数不能简单的通过少量层数来学习到，因此需要多层实现。

前向传播

对于神经网络中的第$l$层，
$Z^{[l]}=W^{[i]}\ast A^{[i-1]}+b^{[l]}$（b用python广播来处理）
$A^{[l]}=g^{[l]}(Z^{[l]})$

反向传播

对于神经网络中的第$l$层，
$d{Z}^{[l]}=d{A}^{[l]}\ast g^{[l{]}^{\prime }}(Z^{[l]})$
$d{W}^{[l]}=d{Z}^{[l]}\ast A^{[l-1]}/m$
$d{b}^{[l]}=np.sum(d{Z}^{[l]},axis=1,keepdims=true)/m$
$d{A}^{[l-1]}=(W^{[l]}{)}^T\ast d{Z}^{[l]}$

核对矩阵的维数

以该图为例，第零层2维（$A^{[0]}=n_x=2$），第一层3维，第二层5维，以此类推。
在单个训练样本中，对于每一个点，都有
$Z^{[l]}=W^{[l]}\ast A^{[l-1]}+b^{[l]}$
$A^{[l]}=g^{[l]}(Z^{[l]})$
$Z^{[l]}$是$n^{[l]}\times 1$的向量，故$b^{[l]}$也是$n^{[l]}\times 1$的向量。
而$A^{[l-1]}$是$n^{[l-1]}\times 1$的向量，因此$W^{[l]}$是$n^{[l]}\times n^{[l-1]}$的矩阵（矩阵相乘法则）。$d{W}^{[l]}$与$d{b}^{[l]}$同理。
对于全体训练样本中，
$Z^{[l]}$是$n^{[l]}\times m$的向量，故$b^{[l]}$也是$n^{[l]}\times m$的向量。
而$A^{[l-1]}$是$n^{[l-1]}\times m$的向量，因此$W^{[l]}$是$n^{[l]}\times n^{[l-1]}$的矩阵（矩阵相乘法则）。$d{W}^{[l]}$与$d{b}^{[l]}$同理。

为什么要深层表示？

如果用比较浅的神经网络计算同一个函数，则需要的神经元的数目会呈现指数增长。
以人脸识别为例，通常较浅的几层用于探测基本特征信息，如面部边缘等。
在后几层，整合这些简单的特征，实现更复杂的功能，如五官定位等。

超参数（需要事先设定，并控制着参数，得到最终的$W$与$b$）：学习率$\alpha$，循环学习迭代次数，隐层数，每一层的单元数，每一层的激活函数等。

五、建立自己的机器学习程序

建立机器学习程序是一个长期的迭代过程，超参数的最佳结果是无法轻易确定的，因此需要不断迭代修改。

训练/验证/测试集

过去常见的方案是：60%训练集，20%验证集，20%测试集。
但在随着数据量越来越大之后，往往后两者的数据比例很小，仅1%（甚至不足1%）。
尽量保证测试集与验证集的数据位于同一分布！
即使没有测试集也可以，因为测试集是为了对最终得到的神经网络做高置信度的无偏评估，保证其准确性，评估的指标也可以根据自己的需要去制定（如通过设置权值来过滤数据等）。

偏差(bias)/方差

拟合要适度，避免过拟合（方差低）与欠拟合（方差高），偏差影响拟合度。
对测试集的错误率与验证集的错误率进行比较，如果二者差距较大，则为“高偏差”。
需要用正则化避免过拟合。

L2正则化（常用）

尽管通过准备更多数据也可以解决高方差的问题，但在很多情况下无法拥有更多的数据，则需要考虑
L2正则化/权重衰减 （常用）：$J(w,b)=\frac{1}{m}{\sum }_{i=1}^m\mathcal{L}({\hat{y}}^{(i)},y^{(i)})+\frac{\lambda }{2m}||w|{|}_2^2$（L2范数/平方范数：$||w|{|}_2^2={\sum }_{j=1}^{n_x}{w}_j^2=w^{T}w$，即L2范数为向量模长）
（通常这个公式内不考虑正则化$b$，若要正则化则再加上$\frac{\lambda }{2m}{b}^2$）
L1正则化：$J(w,b)=\frac{1}{m}{\sum }_{i=1}^m\mathcal{L}({\hat{y}}^{(i)},y^{(i)})+\frac{\lambda }{m}||w|{|}_1$
（L1范数：$||w|{|}_1^2={\sum }_{j=1}^{n_x}|w_j|=w^{T}w$）
（使用L1正则化会让$w$变得更加稀疏，即向量中存在许多的0）
其中，$\lambda$是正则化参数，通常由验证集或者交叉验证得出，也是一个超参数。
对于神经网络中，$W^{[l]}$是$n^{[l]}\times n^{[l-1]}$的矩阵，
则弗罗贝尼乌斯范数(Frobenius norm)$||W^{[l]}|{|}_F^2={\sum }_{i=1}^{n^{[l-1]}}{\sum }_{j=1}^{n^{[l]}}(|W_{ij}^{[l]}|{)}^2$
$J(w^{[1]},b^{[1]},...,w^{[l]},b^{[l]})=\frac{1}{m}{\sum }_{i=1}^m\mathcal{L}({\hat{y}}^{(i)},y^{(i)})+\frac{\lambda }{2m}{\sum }_{i=1}^L||W^{[l]}|{|}_F^2$
在计算梯度下降时，
令$d{W}^{[l]}=$原本的结果+$\frac{\lambda }{m}{w}^{[l]}$
$W^{[l]}=W^{[l]}-\alpha d{W}^{[l]}$

为什么L2正则化可以防止过拟合？

令超参数$\lambda$变大，会使得激活函数中的$Z^{[l]}$变小，从而的$W^{[l]}$变小，逐渐使得$W^l$内的元素趋向于0。
从而相当于“消除”了某层中几个神经元，让神经网络变得更加“简单”，使得从过拟合的状态到正常或者高偏差的状态（即上图中从右到左）。

上图的激活函数中，$z$趋向于0时，逐渐变为线性变化，而过多的线性变化可以整合成一个线性变化，从而实现“消除”了神经元。
使用正则化的Loss函数是一个单调递减的曲线（梯度下降）

Dropout（随机失活）正则化（计算机视觉中使用较多）

拷贝一份神经网络，将每一层的每一个神经元以某个概率保留或者去除，得到一个精简的神经网络，并重新训练。

反向随机失活

假设有一个$L$层的神经网络。
对于原矩阵A，定义矩阵$D=np.random.rand($矩阵A的维度)，内部为01矩阵，其中元素为1的概率是keep-prob（超参数，[0,1)，keep-prob为1时无变动）。
令A=A*D，消除矩阵D中0对应位置的矩阵A中的元素。，相当于有keep-prob的概率保留A中的元素。
再让A中每个元素除以keep-prob。（为了保证矩阵A的整体期望不变）
（事实上，因为矩阵D每一次可能不一样，所以即使是相同的训练集也可能有不同的结果。）
可以设置一个keep-prob为1的“对照组”（即不使用dropout的结果），和每一次随机不同神经元失活的训练结果进行比对。
将过拟合较为严重的层对应的keep-prob设置较低。
（其实L2正则化和Dropout正则化实现的功能是类似的，都是通过“消去”部分神经元避免过拟合）
Dropout的缺点：Loss函数J不再被明确的定义，在随机移除了一些神经元之后，很难确定梯度下降的性能。（所以其实并不是最优先使用的方法）

其他正则化方式

数据扩增（缓解过拟合）

例如对于图片训练，将图片水平翻转并添加进训练集，或将图片进行一定程度的旋转/裁切等。
对于验证码图片训练，也可以考虑将验证码图片中的数字进行适当的扭曲变化。
（在原有数据上稍作改动，是一种成本较低的数据扩增方式）

Early Stopping/提前停止

除了绘制Loss函数的梯度下降曲线，也绘制测试集的误差，然后选择一个大小适中的弗罗贝尼乌斯范数后，提前停止训练神经网络。
缺点：无法同时做到“优化Loss函数J”与“防止过拟合”

归一化输入（加速神经网络训练）

以$x=\left[\begin{array}{c}x1\\ x2\end{array}\right]$为例，
第一步：零均值化，令$\mu =\frac{1}{m}{\sum }_{i=1}^M{X}^{(i)},X^{(i)}=X^{(i)}-\mu$（让整体期望变为0）
第二步：归一化方差，令${\sigma }^2=\frac{1}{m}{\sum }_{i=1}^M(X^{(i)}{)}^2,X^{(i)}=X^{(i)}/{\sigma }^2$（让整体方差变为1）
在训练数据时，要用相同的$\mu$与${\sigma }^2$来归一化测试集，保证训练的效果更好。
（如果多个测试集的数据区间相差很大，会使训练的效率受到影响）

梯度消失/梯度爆炸

当训练深度神经网络时，Loss函数的梯度下降过快或过慢（导数变得很大或很小）。

以上图的神经网络为例，假设每一层的激活函数$g(z)=z$（线性激活函数），且全体$b^{[l]}=0$（即$z^{[l]}=w^T\ast z^{[l-1]}$），不难得到,最后的$y=w^{[l]}{w}^{[l-1]}{w}^{[l-2]}...w^{[1]}x$。
我们再令以$x=\left[\begin{array}{cc}1.5& 0\\ 0& 1.5\end{array}\right]$为例，则$\hat{y}=w^{[l]}\ast {\left[\begin{array}{cc}1.5& 0\\ 0& 1.5\end{array}\right]}^{L-1}\ast x$。
不难看出，当系数大于1时，随着层数$L$越多，就会呈现指数爆炸增长，同理若小于1时，会指数缩小。
因此，需要通过随机化初始权重来解决。

随机化初始权重

对于单个神经元，我们假定$b=0$，则此时$z=w_1^{T}x1+w_2^{T}x2+...+w_n^T{x}_n$,当$n$越大时，我们期望$w_i$越小，（因为$z$会更小，loss函数也会更小），
因此我们可以令$w^{[l]}=np.ramdon.randn(shape)\ast np.sqrt(\frac{1}{n^{[l-1]}})$
（此处的$n^{[l-1]}$指第$l-1$层的神经元数）
（但事实上，当激活函数是ReLU函数时，使用$\sqrt{\frac{2}{n^{[l-1]}}}$的效果更好，当激活函数是$tanh$时，$\sqrt{\frac{1}{n^{[l-1]}}}$效果更好，而对于Xavier初始化，则是$\sqrt{\frac{2}{n^{[l-1]}+n^{[l]}}}$）

在反向传播中进行梯度检验（仅用于调试）

双边误差公式：$f^{\prime }(\theta )=li{m}_{ϵ\to 0}\frac{f(\theta +ϵ)-f(\theta -ϵ)}{2ϵ}$（一种导数定义）
第一步：令大向量$\theta =\left[\begin{array}{ccccc}{W}^{[1]}& b^{[1]}& ...& W^{[L]}& b^{[L]}\end{array}\right]$（其实是一个更大的矩阵）
第二步：计算$d{W}^{[1]},d{b}^{[1]},...,d{W}^{[L]},d{b}^{[L]}$的值并reshape成$\theta$的形状（每一个其实都是一个矩阵，合并后也仍旧是大矩阵）
第三步：循环遍历每一个$d{\theta }_{approx}[i]=\frac{J({\theta }_1,{\theta }_2,...,{\theta }_i+ϵ,...,)-J({\theta }_1,{\theta }_2,...,{\theta }_i-ϵ,...,)}{2ϵ}$（注意：Loss函数需要正则化！但不要使用Dropout，因为会随机消除点，让Loss函数难以计算！）
（用双边误差公式近似的代替$d{\theta }_i=\frac{\partial J}{\partial {\theta }_i}$）,令$d{\theta }_{approx}=\left[\begin{array}{ccc}d{\theta }_{approx}[1]& ...& d{\theta }_{approx}[2L]\end{array}\right]$（维度和$\theta$相同）
第四步：计算$\frac{||d{\theta }_{approx}-d\theta |{|}_2}{||d{\theta }_{approx}|{|}_2+||d\theta |{|}_2}$（此处的$d\theta$是实际梯度曲线的导数）
最终计算结果数值在$10^{-7}$~$10^{-5}$较佳，若大于$10^{-3}$（即差距过大）可能需要检验是否有bug，排查哪个$d{\theta }_{approx}[i]$与$d{\theta }_i$的偏差较大。

六、神经网络优化算法

Mini-Batch 梯度下降法

当训练样本数量很大时，向量化的矩阵运算可能会很慢，因为传统方法下需要处理整个训练集后才可以进行梯度下降。
因此考虑将训练集分为若干个较小的子训练集（Mini-Batch） X { i } X^{\{i\}} X{i}，分别对这些子训练集进行和之前相同的向量化训练，Loss函数需要正则化！

在Mini-Batch下，产生的Loss函数可能会有类似“噪音干扰”的梯度下降曲线。
如果Mini-Batch的大小是$m$（即整个训练集），那等价于不使用Mini-Batch，
如果Mini-Batch的大小是1（每个样本一个训练集），则为随机梯度下降法（会失去向量化加速的效果，因为只有一个样本）。
因此，需要挑选合理的Mini-Batch大小！

指数加权平均

用近似但便于计算的曲线拟合代替原来的散点图。
$v_t=\beta v_{t-1}+(1-\beta ){\theta }_t$（$\beta$为动量，是超参数，常令$\beta$=0.9）
当$\beta$变大时，曲线适应的会更慢，当$\beta$变小时，曲线的噪声会更多。

偏差修正

在估算初期（即$t$比较小的时候）可以使用，令$v_t=\frac{\beta v_{t-1}+(1-\beta ){\theta }_t}{1-{\beta }^t}$来消除初期的偏差。
当$t$变大时，$1-{\beta }^t\to 1$，失去作用。

动量梯度下降法（Momentum）

令
$v_{dw}=\beta v_{dw}+(1-\beta )dw$，
$v_b=\beta v_{db}+(1-\beta )db$
$w=w-\alpha V_{dw}$
$b=b-\alpha V_{db}$

RMSprop

$S_{dw}=\beta S_{dw}+(1-\beta )d_{w^2}$
$S_{db}=\beta S_{db}+(1-\beta )d_{b^2}$
$w=w-\alpha \frac{dw}{\sqrt{S_{dw}}+ϵ}$
$b=b-\alpha \frac{db}{\sqrt{S_{db}}+ϵ}$
（$ϵ$是为了防止分母为0设置的，通常为1e-8）

Adam（常用，结合了Momentum与RMSprop）

令$v_{dw}=0,S_{dw}=0,V_{db}=0,S_{db}=0$,通常令${\beta }_1=0.9,{\beta }_2=0.999,ϵ=1e-8$
在每一次迭代$t$中，遍历每一个mini-batch，令
$v_{dw}={\beta }_1{v}_{dw}+(1-{\beta }_1)dw$
$v_{db}={\beta }_1{v}_{db}+(1-{\beta }_1)db$
$S_{dw}={\beta }_2{S}_{dw}+(1-\beta )d_{w^2}$
$S_{db}={\beta }_2{S}_{db}+(1-\beta )d_{b^2}$
（通常${\beta }_1$取0.9，${\beta }_2$取0.999）
偏差修正：
$v_{dw}^{corrected}=v_{dw}/(1-{\beta }_1^t)$
$v_{db}^{corrected}=v_{db}/(1-{\beta }_1^t)$
$S_{dw}^{corrected}=S_{dw}/(1-{\beta }_2^t)$
$S_{db}^{corrected}=S_{db}/(1-{\beta }_2^t)$
$w=w-\alpha \frac{v_{db}^{corrected}}{\sqrt{S_{db}^{corrected}}+ϵ}$
$b=b-\alpha \frac{v_{db}^{corrected}}{\sqrt{S_{db}^{corrected}}+ϵ}$

学习率衰减（学习率随着时间降低）

对于每一轮epoch，令$\alpha =\frac{{\alpha }_0}{1+衰减率\ast epoch轮次}$
其中${\alpha }_0$为初始学习率，与衰减率一样都是超参数。
也有令$\alpha =k^{epoch轮次}\ast a_0$等其他式子

七、微调超参数

调试处理

学习率$\alpha$
动量$\beta$
隐藏层数
mini-batch大小
选择一些随机的点，便于更快的找到合适的超参数。

为超参数选择合适的范围

隐藏层数：区间随机均匀取值
学习率：先取对数划分区间，再随机均匀取值（如以0.001,0.01,0.1作为分界点）
动量：指数加权平均划分区间，再随机均匀取值（如以0.9,0.99,0.999作为分界点）

照看模型（算力不足时采用）：每隔一段时间观察训练情况，手动调整学习率。
并行训练（算力充足时采用）：同时跑多个，选择参数表现最优秀的。

正则化网络的激活函数/Batch归一化（Batch Norm）

正规化上一个隐藏层的数据，使得其平均值与方差归一，便于后续层的的训练。
（如果由每一层的$w$与$b$组成的集合中方差与平均值差距过大，会增加训练的难度（点过于分散，难以收敛），归一化后可以使数据相对比较“集中”的状态，使得后续层的收敛变得更快。）

对于第$l$层，
$\mu =\frac{1}{m}{\sum }_{i=1}^M{Z}^{[l](i)}$
${\sigma }^2=\frac{1}{m}{\sum }_{i=1}^M(Z^{[l](i)}-\mu {)}^2$
$Z_{norm}^{[l](i)}=\frac{Z^{[l](i)}-\mu }{\sqrt{{\sigma }^2+ϵ}}$（和之前的归一化一样，期望变为0，方差变为1）
${\tilde{Z}}^{[l](i)}=w{Z}_{norm}^{[l](i)}+b$
（类似线性ReLU单元，将每一个神经元的数据归一化之后整合，使其平均值与方差变成其他的，特别的，令$w=\sqrt{{\sigma }^2+ϵ},b=\mu$，则$Z_{norm}^{[l](i)}=Z^{[l](i)}$，可利用之前的优化算法来不断地更新$w$与$b$）
（对于代码实现，可以直接用batch_normalization来实现）
再mini-batch中使用时，对于$z^{[l]}=w^{[l]}{a}^{[l-1]}+b^{[l]}$而言，归一化时需要先减去平均值再除以标准差，因此不论$b^{[l]}$是多少都会被减掉不参与计算。
因此${\tilde{Z}}^{[l](i)}=w{Z}_{norm}^{[l](i)}+{\beta }^{[l]}$，其中${\beta }^{[l]}$为控制参数，去影响转移的条件。
可以将Batch Norm与DropOut一期使用，在数据归一化后，前后层的数据依赖性会略微减弱，因此使用DropOut的影响减小。但使用较大的Mini-batch大小时会减弱正则化效果。

Batch归一化在测试时的使用

在测试神经网络时，需要用指数加权平均/流动平均来估算/追踪$\mu$与${\sigma }^2$的值。

Softmax回归（logistic回归的一般形式，适用于非二分分类问题）

每一个元素的激活函数的值代表某一类情况发生的概率。

我们假设某一层的神经元个数为$m_l$。
$z^{[l]}=w^{[l]}{a}^{[l-1]}+b^{[l]}$

Softmax激活函数：
$t=e^{(z^{[l]})}$（对向量$z^{[l]}$中每个元素取一次自然指数）
$a^{[l]}=\frac{e^{(z^{[l]})}}{{\sum }_{i=1}^{m_l}{t}_i}$（向量中的每个元素都除以向量中元素之和，使其内部的元素之和为1，结果代表着概率。）
（与之前的sigmoid函数与ReLU不同的是，softmax的激活函数是输入一个向量，输出一个向量，而不再是一个数字。）

如何训练Softmax激活函数

Loss函数：$\mathcal{L}(\hat{y},y)=-{\sum }_{i=1}^{m_{[l]}}{y}_{i}log\widehat{y_i}$
（由定义可知$y,\hat{y}$∈ [0,1]，易知$y_i$越大，$\mathcal{L}(\hat{y},y)$越小。）
$J(w^{[1]},b^{[1]}...)=\frac{1}{m}{\sum }_{i=1}^m\mathcal{L}(\hat{y},y)$
同之前的计算，为了便利，将所有的$y$与$\hat{y}$的向量合并，分别形成一个大矩阵，即
$Y=\left[\begin{array}{cccc}{y}^{(0)}& y^{(1)}& ...& y^{(m)}\end{array}\right]$
$\hat{Y}=\left[\begin{array}{cccc}{\hat{y}}^{(0)}& {\hat{y}}^{(1)}& ...& {\hat{y}}^{(m)}\end{array}\right]$
反向传播：
$d{z}^{[l]}=(\hat{y}-y)$（即$\frac{\partial J}{\partial z^{[l]}}$，计算原理同之前）

八、机器学习策略

正交化

分离各种作用的因素，使得两两尽量互不相关，通过调整这些因素进行微调训练。（类似“控制变量法”，分离互相独立的因素）

单一数字评估指标

当评估性能时是多个指标表现时，有时很难选出最佳的选择，因此要定义单一数字，来综合评估多个指标的综合表现。
（这也是使用F1指数来综合准确率与召回率二者的原因，它是二者的调和平均）

满足与优化指标

当评估性能时是多个指标表现时，可以指定其中一个为优化指标（尽可能优秀），其余的为满足指标（必须达到要求）

人类表现

贝叶斯最优错误率（也就是概念意义上的Optimal）：理论情况下机器学习所能达到的最大准确值。
通常而言，人类的理论错误率与贝叶斯最优错误率相似。
可避免偏差：目前错误率与贝叶斯最优错误率的差值

优化策略

比对训练集错误率与开发集错误率之差与人类表现错误率与训练集错误率之差。
若前者差距更大，则说明方差较大，需要考虑正则化。
若后者差距更大，则说明偏差较大，需要考虑构建更大的神经网络/优化算法。

当算法的表现已经超越人类表现错误率之后，优化会变得更加困难。

改善模型表现

减少偏差&方差

减少偏差：

1. 训练更大的模型
2. 训练更优的算法（momentum、RMSprop、Adam等优化算法）
3. 使用RNN/CNN

减少方差：
1.训练更多数据
2.正则化（L2，Dropout等）
3.采用更合适的神经网络与超函数。

九、误差分析

统计不同类型错误的占比与分布

划分一张表格将各种错误类型归类，并以此归纳与总结问题。

清除标注错误的数据

在表格中额外增加“未标注正确”一列，统计其占比来归纳错误。
通常，只要数据集足够大，轻微的标注错误没有太大影响。

如果要修正标注数据，一定要把开发集和测试集的数据都修正。
不仅仅要检查算法判断错误的个例，算法判断正确的个例也需要验证！

搭建系统原型

在系统原型搭建完成后，需要进行偏差/方差测试与上述的错误评估分析，随后开始不停迭代。

在不同分布的数据集上训练

当需要将不同分布的数据集混合起来训练时，开发集和测试集一定要根据系统需要侧重的需求来选择数据集。
（比如需要做文字处理识别时，有做好标注的数据集与随机收集的聊天记录，开发集和测试集就应该要以聊天记录的数据为主。）

迁移学习

在已经训练好的神经网络基础上，进行一定程度的改进来实现其他的需求而无需重新开始训练。如预训练与微调。（比如调整神经网络的最后若干层，根据自己的需要进行调整，前面不涉及变动的层参数就像是被“冻结”/freeze了）

多任务学习

让单个神经网络同时做几件事情，即最后一层的多个神经元分别代表每一种工作的结果。
因此Loss函数得到的结果不再是一个数，而是一个向量。
在某些场合下，让单个神经网络做多件事情比用多个独立的神经网络分别完成性能更好。

1. 这些任务可以共用低隐藏层的特征（比如识别一张图中分别有什么物体时，低层次的物体特征是可以共用的。）
2. 各个任务的数据量很接近
3. 训练的神经网络较大
   

端到端的深度学习（适用数据量比较大的情况）

直接输入不经过特征处理的原始数据，输出需要的结果，一步到位。

十、计算机视觉（CV）

卷积神经网络/CNN由卷积层、池化层、全连接层组成，卷积层是最核心，但也是最容易构建的层。
通常卷积层和池化层会被合并叫做CNN的“一层”。

边缘检测

假定以下滤波器矩阵都是$f\times f$($f$通常为奇数)，图像矩阵都是$n\times n$的灰度照片（即没有RGB三通道）。以下假定$f=3,n=6$
将图片的原矩阵与过滤器矩阵做卷积运算，得到的矩阵大小是$(n-f+1)\times (n-f+1)$。
（选取与过滤器大小相同的子矩阵$S$与过滤器$F$，则卷积结果$c_{ij}=\sum \sum S_{ij}\ast F_{ij}$）
tf.nn.conv2d()
过滤器矩阵中的正数表示亮边，负数表示暗边，0表示交界线。

边缘检测

用$\left[\begin{array}{ccc}1& 0& -1\\ 1& 0& -1\\ 1& 0& -1\end{array}\right]$来检测图像中是否有垂直边缘，卷积结果中数值非0的位置表示垂直边的所在处。同理用$\left[\begin{array}{ccc}1& 1& 1\\ 0& 0& 0\\ -1& -1& -1\end{array}\right]$检测是否有水平边缘。
Sobel滤波器： $\left[\begin{array}{ccc}1& 0& -1\\ 2& 0& -2\\ 1& 0& -1\end{array}\right]$ Scharr滤波器： $\left[\begin{array}{ccc}3& 0& -3\\ 10& 0& -10\\ 3& 0& -3\end{array}\right]$
事实上，过滤器矩阵的系数可以理解为9个超参数，通过反向传播来不断地学习以此找到最佳的系数。

Padding/填充

在卷积运算中，图片矩阵会逐渐变小。且多次卷积会使图片矩阵边界的信息丢失。
考虑在卷积操作前填充图片矩阵，记向外填充的层数为$p$，即原本矩阵变为$(n+2p)\times (n+2p)$。在卷积后变为$(n+2p-f+1)\times (n+2p-f+1)$。
我们假设令$p=1$，则前后卷积后矩阵大小不变。
通常填充的元素可以是0。
（不使用Padding进行卷积被称为Valid卷积，使用Padding且卷积前后输出不变的的被称为Same卷积。此时$2p-f+1=0$，因此$f$通常为奇数。）

卷积步长（Stride）

步长：在遍历每一个子矩阵时，子矩阵间隔的长度,以下简称为$s$。
（如图所示，$s=2$，则第一个子矩阵是$\left[\begin{array}{ccc}2& 3& 7\\ 6& 6& 9\\ 3& 4& 8\end{array}\right]$，第二个则是$\left[\begin{array}{ccc}7& 4& 6\\ 9& 8& 7\\ 8& 3& 8\end{array}\right]$）
因此卷积后的图片矩阵大小为$(\lfloor \frac{n+2p-f}{s}\rfloor +1)\times (\lfloor \frac{n+2p-f}{s}\rfloor +1)$。

（数学意义上的卷积需要先对矩阵作沿着次对角线转置。信号处理时不需要！）
如$\left[\begin{array}{ccc}3& 4& 5\\ 1& 0& 2\\ -1& 9& 7\end{array}\right]$变为$\left[\begin{array}{ccc}7& 2& 5\\ 9& 0& 4\\ -1& 1& 3\end{array}\right]$

三维卷积

对于RGB图像，有三个颜色通道，因此图像矩阵的层数$n_c$为3，变为了$6\times 6\times 3$。
过滤器矩阵也变为$3\times 3\times 3$。
（不论过滤器的维度如何，“层数”必须相同！）
整体与一维卷积类似，每次选出$f\times f\times 3$个数字，分别与图片矩阵相乘后将所有的数字相加得到结果。
滤波器矩阵为$f\times f\times n_c$，图像矩阵为$n\times n\times n-c$。卷积得到的矩阵大小是$(n-f+1)\times (n-f+1)\times n_c$。

多重过滤器（同时检测出多条边缘）

分别对每个过滤器做卷积运算，然后合并成一个多通道的矩阵。

单层卷积网络

把过滤器看做$w^{[l]}$,则卷积方程结果为$w^{[l]}{a}^{[l-1]}$，在加上$b^{[l]}$（ReLU）
若有10个过滤器，每一个都是$3\times 3\times 3$的矩阵。则一共有（$10\ast (3\ast 3\ast 3+1(b^{[l]}))=280$个参数）
神经网络的过滤器参数个数与原图片大小无关！（避免过拟合）

一个简单卷积网络示例

第一层：图片矩阵为$39\times 39\times 3,f^{[l]}=3,s^{[l]}=1,p^{[l]}=0$，共10个过滤器，卷积结果为$37\times 37\times 10$。（$39-3+1=37$）
第二层：图片矩阵为$37\times 37\times 10,f^{[l]}=5,s^{[l]}=2,p^{[l]}=0$，共20个过滤器，卷积结果为$17\times 17\times 20$。（$\lfloor \frac{37-5}{2}\rfloor +1=17$）
第二层：图片矩阵为$17\times 17\times 20,f^{[l]}=5,s^{[l]}=2,p^{[l]}=0$，共40个过滤器，卷积结果为$7\times 7\times 40$。（$\lfloor \frac{17-5}{2}\rfloor +1=7$）
（可以注意到，每一层的过滤器个数在逐渐变多。）

CNN的池化层

超参数只有过滤器大小$f$与步长$s$（最常用$f=2/3,s=2$，一般令$p=0$，相当于图像缩小了一倍）

最大池化（最常用）

如图所示，对于一个$n\times n$的矩阵，令$f=2,s=2$，得到一个$\lfloor \frac{n-f}{s}\rfloor +1$的矩阵，每个矩阵表示$f\times f$的子矩阵中的最大值，多层数的矩阵同理。

平均池化

基本原理同上，只是将最大值变为了平均值。

CNN的全连接层

同普通的全连接神经网络类似，把前面得到的多通道矩阵转化为一维向量导入到全连接层，通常会有若干个全连接层，最后得到结果。

为什么选择卷积

卷积本身属于一种稀疏连接的方式而非全连接（每次只是子矩阵和过滤器在运算而非整个矩阵），因此可以大大减小开销（参数的个数仅仅由过滤器大小决定而非图片大小）
参数共享：某些特征提取（如边界检测）不仅会对图片的某一部分有用，也可能会对另一部分有用。
（类似地，Loss函数$J(w^{[1]},b^{[1]}...)=\frac{1}{m}{\sum }_{i=1}^m\mathcal{L}(\hat{y},y)$）

计算机视觉领域下的数据增强（解决数据量不足的问题）

1. 图片镜像对称
2. 图片随机裁剪（不失去主体信息）
3. 色彩转化（调整颜色通道，增加若干失真值来生成新图片，也会使训练的结果更具有健壮性）

可以采用CPU多线程的方式对一个mini-batch内的图片做并行的数据增强处理。

十一、计算机视觉实例探究

经典架构

LeNet-5

将一个卷积层和池化层视为一层，两层神经网络后，再两层全连接层得到结果。

AlexNet（激活函数选择了ReLU）

第一次使用线性激活函数，除了第一次采用Valid卷积，其余都采用Same卷积（即填充保持卷积前后大小不变）

VGG-16（参数很多，但结构上简化的神经网络）

16次卷积层+最大池化操作后全连接16层，全部都是Same卷积，每一次卷积的过滤器次数成倍增加。

残差网络（ResNet）

残差单元：下一层的结果将不止由上一层确定，还与之前层的结果决定。
eg:$a^{[l+2]}=g(z^{[l+1]}+a^{[l]})$
与之前层连接的路线被称为“捷径”（shortcut）

残差网络有利于梯度下降与防止梯度消失&梯度爆炸的问题。
采用了Same卷积保证前后尺寸不变。
卷积层+池化层。

Inception网络

网络中的网络/1x1卷积

1x1的过滤器可以令矩阵的每一个数都同乘一个数，前后图片尺寸大小不变。

可以用于压缩通道个数。

Inception网络原理

（提前预输入一些过滤器的大小与池化操作，让系统自己决定在池化时使用什么操作）
先用1x1卷积降低通道数后再做Same卷积。

较为特殊的是，为了保证前后维度一致，在Inception网络模块池化时，需要用到Padding！
将不同卷积的结果进行连接，形成一个巨大通道的矩阵。

Inception网络模块（基本单位）

由$1\times 1,3\times 3,5\times 5$的过滤器与带Padding的最大池化层组成。

事实上，除了Inception网络模块，仍然存在少量的全连接层（后面跟着Softmax），用来避免过拟合。

十二、目标定位（检测图片中的物体并定位）

定位某个物体的位置，并输出物体所在位置矩形边界框的四个坐标。
特征点检测：通过定位各种需要的特征点坐标来实现对于需求功能的实现。

检测目标存在

滑动窗口检测算法（计算成本大）

先选定一个特定大小的滑动窗口，并将其置入卷积网络，来判断滑动窗口内是否有目标。若不存在目标，则考虑适当调整滑动窗口的大小。

在卷积网络上的实现

把CNN的全连接层变为全新的卷积层
如图，对于池化后的$5\times 5\times 16$的矩阵，采用$5\times 5$的过滤器，使其变成$1\times 1$（类似原本全连接层变为一维向量的操作）

Bounding Box/边界框检测

YOLO算法

用网格将图片分割为多个区域，每一个网格对应一个输出向量，标注了是否有目标存在及其边界框坐标。
边界框大小可以超出分割区域。
对于每个分割的单元，设置两个边界框（anchor box），并舍去准确率较低的（$p_c\le 0.6$），最后执行非极大值抑制。
因为是用卷积实现的，因此有参数共享，可以加快运算时间。

交并比（IoU，计算两个边界框的交集与并集之比）

如果一个区域附近有很多的边界框，则计算其IoU，
若$IoU\ge 0.5$则检测正确。

非极大值抑制（避免同一物体被检测多次）

先找到匹配程度$p_c$最高的边界框（采用$p_c\ge 0.6$且最大的边界框），将其“高亮”标注，随后非极大值抑制算法就会去除与之IoU很高的边界框，避免重复检测。

Anchor Box（锚定边界，让一个边界框内可以检测出多个物体）

（事实上，当划分的格子颗粒度越小，就越难在一个框内检测出多个物体）
定义若干个Anchor box，让每个边界框的记录矩阵多若干个分量。

候选区域

带区域的卷积神经网络(R-CNN)

不再像滑动窗口那样遍历每一个框，而是用图像分割算法寻找不同的色块作为候选区域进行检测。
分割算法提供的色块不一定准确，需要在此基础上进行检测，找到更加精确的边界框。

十三、人脸识别

人脸识别与活体检测是两个核心的目标。

一次学习（每次新的人脸加入时无需重新学习整个网络）

相似度函数：$d(img1,img2)=$两张图片的差异程度，
设置一个阈值$\tau$，当$d(img1,img2)\le \tau$时认为是同一个人。

Siamese 网络

对于一张图片$X$，将CNN的最后一层全连接层的结果作为向量$f(X)$。
令$d(X^{(1)},X^{(2)})=||f(X^{(1)})-f(X^{(2)})|{|}_2^2$
（L2范数/平方范数：$||w|{|}_2^2={\sum }_{j=1}^{n_x}{w}_j^2=w^{T}w$）

Triplet/三元组Loss

将 锚定图像（A）、正确图像（P）与错误图像（N） 三个作为一个元组。
（A与P是同一个人，A与N不是同一个人）
我们期望$d(A,P)\le d(A,N)$，但如果$f(X)\equiv 0$则式子必定成立，
因此要求$d(A,P)-d(A,N)+\alpha \le 0$（$\alpha$也被称为间隔/margin）
Loss函数$\mathcal{L}(A,P,N)=max(0,d(A,P)-d(A,N)+\alpha )$
（只要$d(A,P)-d(A,N)+\alpha$不大于0，说明三元组符合要求）
$J={\sum }_{i=1}^m\mathcal{L}(A^{(i)},P^{(i)},N^{(i)})$
（在训练时，要尽量选择$d(A,P)$与$d(A,N)$差距不大的，让神经网络能够区分并放大细微的差别，使得效果更好。）

面部验证&转化为二分分类

定义：如果两张照片是同一个人则输出1，否则为0，则转化为二分分类问题，可以使用sigmoid函数。在最后额外添加一层进行计算。
令$\hat{y}=\sigma ({\sum }_{k=1}{w}_k|f(X_{(k)}^{(1)})-f(X_{(k)}^{(2)})|+b)$（此处的下标$k$表示向量上的第$k$个分量）
或令$\hat{y}=\sigma ({\sum }_{k=1}{w}_i\frac{(f(X_{(k)}^{(1)})-f(X_{(k)}^{(2)}){)}^2}{f(X_{(k)}^{(1)})+f(X_{(k)}^{(2)})}+b)$（${\chi }^2$相似度）

神经风格迁移

在图像处理中，将图案的色彩风格迁移到其他的图片上，生成新的图片。

Loss函数

对于原图$C$，图片风格$S$，生成图片$G$，
定义Loss函数$J(G)=\alpha J_{内容}(C,G)+\beta J_{风格}(S,G)$
（即内容上的差异与风格上的差异加权总和，其中$\alpha$与$\beta$是超参数）
每次反向传播时用$G=G-\frac{\partial J(G)}{\partial G}$来更新$G$的像素值。

内容Loss函数

对于某个预训练神经网络的第$l$层，将原图$C$与$G$的整一层的激活函数值作比较，如果值相似，说明图片相似。
$J_{内容}^{[l]}(C,G)=\frac{1}{2}||a^{[l](C)}-a^{[l](G)}|{|}^2$（结果是一个向量）

风格Loss函数

定义Gram矩阵/风格矩阵$G^{[l](S)}$为一个$n_c^{[l]}\times n_c^{[l]}$大小的矩阵（$n_c^{[l]}$为第$l$层的通道数），使得$a_{(i,j,k)}^{[l]}$代表在神经网络第$l$层中，原矩阵中坐标为$(i,j,k)$的位置。
那么对于通道$k$与$k^{\prime }$的相关系数$G_{k{k}^{\prime }}^{[l]}={\sum }_i{\sum }_j{a}_{(i,j,k)}^{[l]}{a}_{(i,j,k^{\prime })}^{[l]}$
如果两个通道相关，则$G_{k{k}^{\prime }}^{[l]}$越大。
$J_{风格}^{[l]}(S,G)=||G_{k{k}^{\prime }}^{[l](S)}-G_{k{k}^{\prime }}^{[l](G)}|{|}_F^2$（弗罗贝尼乌斯范数，结果是一个矩阵）
（也可以额外定义一些超参数$w_i$使得$J_{风格}(S,G)={\sum }_l{w}_l\ast J_{风格}^{[l]}(S,G)$）

将一维数据推广到三维数据

一维与二维的数据要用一维与二维的过滤器来实现卷积操作。
同理三维的也需要用三维过滤器来实现。