【深度学习笔记01】神经网络与深度学习

一、深度学习概论
1.1 神经网络
1.2 监督学习
1.3 关于深度学习
二、神经网络编程基础
2.1 符号定义
2.2 二元分类问题——logistic回归方法
2.3 梯度下降法
2.4 计算图
2.5 向量化
2.6 关于numpy与常用函数

一、深度学习概论

1.1 神经网络

激活函数ReLU（基本修正单元Rectified linear unit），一开始是零，后面沿直线上升。

一个神经网络中每一个单元都可能是ReLU或者其他非线性单元。

1.2 监督学习

（1）深度学习的应用领域

在监督学习中，先输入X，然后学习到一个函数，映射输出到Y。

目前深度学习在线上广告投放、图像处理、语音识别、机器翻译、无人驾驶等领域已经发挥了重要的作用。但每一项应用都需要我们合理选择x和y，才能解决特定问题。

（2）一些常用框架

价格预测，通用标准的神经网络框（Standard NN） 图像处理，卷积神经网络CNN（Convolutional NN） 序列处理，如音频，循环神经网络RNN（Recurrent NN） 语言处理，使用更复杂的RNNs 无人驾驶中使用图像和雷达，会使用更复杂的混合的神经网络结构

（3）结构化数据与非结构化数据

结构化数据，是数据的数据库，例如价格预测时会有标准的数据库，广告投放时会有用户信息，广告信息等数据库。

非结构化数据指语音、图像、视频、文本等，相比较结构化数据，更难以让计算机理解。

1.3 关于深度学习

深度学习近年强势发展的主要因素。

以前的算法，比如传统机器学习向量机等，随着数据量的增大，算法的表现基本没有提高。早期数据很少，随着数据的增多，算法有了一些提高，但后期人们进入数据化时代，每个人每天都在产生大量数据，数据量越来越大，但以前的算法却并没有得到更好的结果。

这时如果使用数据训练一个小型的神经网络，算法表现会比以前好很多，如果训练一个更复杂的大型神经网络，那么得到的结果会更好。虽然数据量增大会使训练时间增高，但如今大型神经网络已经帮著人类取得了很多很多成果。

另一方面，以前的SVM向量机的训练好坏更却决于认为手动设计，二现在神经网络更加通用。

其次是计算能力，CPU和GPU运算能力的提升也是深度学习发展的基础。

算法方面的创新也极大地促进了深度学习，许多算法的提出都是为了改善神经网络的性能，增加计算速度。

二、神经网络编程基础

2.1 符号定义

对于想要遍历数据集的情况，尽量不要使用for循环。

例如识别一张猫的图片是否是猫。

首先我们获取一张图片，其由3个矩阵（RGB）组成，我们可以将每一个矩阵所有像素值提取出来列成一个特征向量。这样输入的矩阵维度就是3xheightxwidth。

输入就是特征向量，输出就是标签0/1代表有猫还是没猫。

用数字符号表示为如下：

输入与输出： $(x,y)$

数据集： $m:\{(x^{(1)},y^{(1)}),(x^{(2)},y^{(2)}),...,(x^{(m)},y^{(m)})\}$

通常会将输入数据 $x^{(n)}$ 以列向量的形式构建为一个输入矩阵

$X=[x^{(1)},x^{(2)},...,x^{(m)}]$

输入矩阵 $X\in{R^{n_x\times{m}}}$ ，其行列数为 $X.shape=(nx,m)$ 。

同样输出数据 $y^{(n)}$ 也会构建为一个输出矩阵

$Y=[y^{(1)},y^{(2)},...,y^{(m)}]$

输入矩阵 $Y\in{R^{1\times{m}}}$ ，其行列数为 $Y.shape=(1,m)$ 。

2.2 二元分类问题——logistic回归方法

（1）二元分类问题

对于一个神经网络的问题，比如图像目标识别，输出的结果 $y\in(0,1)$ ，即图片要么是目标，要么不是。

我们给定了图片输入 $x$ 特征向量，期望得到一个预测值 $\hat{y}$ ，判断图片是不是我们想要的目标，预测的过程相当于求一个概率：

$\hat{y}=P(y=1|x)$

（2）logistic方法

由于二元分类问题，预测结果应为[0,1]，因此线性方式一般不使用，因为线性表达，Y可以无穷大也。常用的方法是在线性的基础上再使用sigmoid函数。

$\textcolor{red}{\hat{y}=\sigma(w^Tx+b)}$

其中 $w^T\in{R^{n_x}}$ 是 $x$ 的系数向量， $b\in{R}$ 是常数，是一个拦截器， $\sigma(z)=\frac{1}{1+e^{-z}}$ 是sigmoid函数。利用 $\sigma(z)$ 就可以将直线输出转换为[0,1]输出。

（3）损失函数Loss

损失函数Loss是单个样本的预测值与实际值之差

为了训练 $w$ 和 $b$ ，我们需要定义一个损失函数，用来描述 $\hat{y}$ 与 $y$ 的接近程度。再logistic方法中我们使用下面的函数作为损失函数Loss。

$\textcolor{red}{L({\hat{y},y})=-(y\log\hat{y}+(1-y)\log(1-\hat{y}))}$

对于损失函数，我们希望它越小越好。

当 $y=1$ 时， $L(\hat{y},y)=-\log\hat{y}$ ，可以看出来 $\hat{y}$ 越大( $\hat{y}\rightarrow1$ )，Loss越小。

同理 $y=0$ 时， $L(\hat{y},y)=-\log{(1-\hat{y})}$ ，可以看出来 $\hat{y}$ 越小( $\hat{y}\rightarrow0$ )，Loss越小。

（再其他方法中可能会用方差作为Loss函数，这里不用是因为方差得到的结果是凹凸的，也就是会有多个局部最优解，不便于后续梯度下降求全局最优解，而上面的Loss函数则解决了这个问题）

（4）成本函数

成本函数是全体样本的预测值与实际值之差

$\textcolor{red}{J(w,b)=\frac{1}{m}\sum^m_{i=1}{L(\hat{y}^{(i)},y^{(i)})}=-\frac{1}{m}(y\log\hat{y}+(1-y)\log(1-\hat{y}))}$

2.3 梯度下降法

成本函数衡量了训练集的预测效果，我们想要的时找到合适的 $w,b$ 使得成本函数 $J(w,b)$ 尽可能小，这就用到了梯度下降法。

由于成本函数 $J(w,b)$ 是凸函数，因此函数形状是如下图这样的，这也是我们为什么定义损失函数那样形式的原因。

我们要做的是初始化一个 $w,b$ 的值，然后让其向梯度下降的方向走，直到找到梯度最低的点。

以 $w$ 为例，我们将重复以下过程： $w=w-\alpha\frac{dJ(w)}{dw}$ ，来更新 $w$ ，其中 $\alpha$ 是学习率参数，可以看出如果斜率越大，那么每次迭代w变化也越大。

实际中我们会使用下面的方程进行梯度下降求解 $w,b$

$w=w-\alpha\frac{\partial{J(w,b)}}{\partial{w}}$

$b=b-\alpha\frac{\partial{J(w,b)}}{\partial{b}}$

梯度下降法

2.4 计算图

计算图是从左到右的计算，来计算成本函数 $J$ 。

对于一个流程图，可以很容易的看出 $J$ 的导数。反向传播，就是从最终输出反推 $J$ 对各个中间变量以及输入的导数。

在程序里，通常约定编程时使用dvar代表最终输出变量对于变量var的导数

代码大致过程如下：

# 初始化
J = 0
dw1 = 0
dw2 = 0
db = 0
# 遍历数据集
for i = 1 to m
	# 计算损失函数与成本函数
	zi = w1 * x1 + w2 * x2 +b
	ai = 1/(1+exp(-zi))
	J += -[yi * log(ai) + (1 - yi) * log(1-ai)]
	# 求导
	dzi = ai -yi
	dw1 += x1 * dzi
	dw2 += x2 * dzi
	db += dzi
# 解出各参数优化后的值
J/=m
dw1/=m
dw2/=m
db/=m
# 梯度下降
w1=w1-a*dw1
w2=w2-a*dw2
b=b-a*db

2.5 向量化

（1）什么是向量化

由于输入数据 $x$ 和系数 $w$ 都是列向量，对于这两个向量相乘，如果使用非向量化的方法即for循环实现，运算速度非常慢，而如果使用向量化的方法，例如在numpy中使用z=np.dot(w,x)实现两个向量的点乘，运算速度会快的多。

import time

# 向量化
a = np.random.rand(1000000)
b = np.random.rand(1000000)
tic = time.time()
c = np.dot(a,b)
toc = time.time()
print("Vectorized:" + str(1000*(toc-tic))+"ms")
# 非向量化
a = np.random.rand(1000000)
b = np.random.rand(1000000)
tic = time.time()
for i in range(1000000):
	c += a[i]*b[i]
toc = time.time()
print("For Loop:" + str(1000*(toc-tic))+"ms")

# 结果向量化的方法用时1.5ms，for循环方法500ms

对于这个小算法区分还不明显，但如果你训练一个神经网络使用非向量化方法需要300小时，向量化方法只需要1个小时，那样差距就非常明显了。

（2）前向传播的向量化

前向传播的目的是计算 $z^{(i)}$ 和 $a^{(i)}$

$z^{(i)}=w^Tx^{(i)}+b$ $a^{(i)}=\sigma(z^{(i)})$

可以通过以下方式实现向量化： $Z=[z^{(1)}\ z^{(2)}\ \cdots\ z^{(m)}]=w^T\cdot{X}+[b\ b\ \cdots\ b]=[w^Tx^{(1)}+b\ w^Tx^{(2)}+b\ \cdots\ w^Tx^{(m)}+b]$ 其中 $X$ 是输入矩阵，每列是每一个样本的所有特征，共有m列即共m个样本； $w^T$ 是参数 $w^{(i)}\rightarrow w^{(nx)}$ 组成的行向量。

以python程序表示上述过程：

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

（3）梯度计算的向量化

梯度计算就是计算 $dz^{(i)}$ 、 $dw^{(i)}$ 和 $db^{(i)}$

$dz^{(i)}=a^{(i)}-y^{(i)}$ $dw^{(i)}=x^{(i)}dz^{(i)}$ $db^{(i)}=dz^{(i)}$

可以通过以下方式实现向量化：

将 $dz^{(i)}$ , $dw^{(i)}$ 和 $db^{(i)}$ 向量化：

$dw=[dw^{(1)}\ dw^{(2)}\ \cdots\ dw^{(m)}]$ $db=[db^{(1)}\ db^{(2)}\ \cdots\ db^{(m)}]$ $dz=[dz^{(1)}\ dz^{(2)}\ \cdots\ dz^{(m)}]$

则 $db=\frac{1}{m}\sum^{m}_{i=1}dz^{(i)}$ , $dw=\frac{1}{m}Xdz^T$

以python表达

Z=np.dot(w.T,x)+b
A=sigmod(Z)
dZ=A-Y
db=np.sum(dZ)/m
dw=np.dot(X,dZ^T)/m
w=w-a1*dw
b=b-a2*db

（4）总结 为了加快代码计算速度，我们使用了向量化的手段，即尽量使用numpy计算数据集而不是用for循环。

输入矩阵 $X.shape = (nx,m)$ ， $m$ 个样本，每个样本 $nx$ 个特征

$X=[x^{(1)}\ x^{(2)}\ \cdots\ x^{(m)}]$ ，其中 $x^{(i)}=[x^{(i)}_1\ x^{(i)}_2\ \cdots\ x^{(i)}_{nx}]^T$

参数矩阵 $W.shape=(nx,1)$ ，每个特征对应一个参数 $w$

$W=[w_1\ w_2\ \cdots\ w_{nx}]^T$

参数 $B.shape=(1,m)$ ，每个特征对应一个参数 $b$

$B=[b\ b\ \cdots\ b]$

线性值 $Z.shape=(1,m)$ ，相当于简化版 $\hat y$ ，每个样本都会计算得到一个计算值

$Z=W^TX+b=[W^Tx^{(1)}+b\ \ \ \ W^Tx^{(2)}+b\ \ \cdots\ \ W^Tx^{(m)}+b]$

预测值 $A.shape=(1,m)$ ，每个样本一个预测值

$A=\hat Y=\sigma{(Z)}$

损失函数 $L.shape=(1,m)$ ，每个样本的预测值与标定值距离

$L=-Y\log{A}-(1-Y)\log{(1-A)}$

成本函数 $J.spape=(1,1)$ ，所有损失函数平均值

$J=\frac{1}{m}L.sum()$

导数 $dZ.shape=(1,m)$

$dZ=\frac{dJ}{dZ}=A-Y$

导数 $dW.shape=(nx,1)$

$dW=\frac{1}{m}X\cdot dZ=[\frac{1}{m}dw^{(1)}\ \frac{1}{m}dw^{(2)}\ \cdots\ \frac{1}{m}dw^{(nx)}]^T$

导数 $dB.shape=(1,1)$

$db=\frac{1}{m}dZ.sum()$

2.6 关于numpy与常用函数

最好不要使用秩为1的数组a=np.random.randn(5)，而要使用 $(m,1)$ 或 $(1,n)$ 的矩阵。也就是直接定义成行列向量a=np.random.randn(5,1)，或者使用reshape改变形状。

如果不确定某个向量的维度，可以使用assert声明来判断。

assert(a.shape==(5,1))

（1）sigmod函数

def sigmoid(x):
    """
    参数:
    x -- 任意形状的numpy数组

    返回值:
    s -- sigmoid(x)
    """
    
    s=1/(1+np.exp(-x))
    
    return s

（2）梯度计算

def sigmoid_derivative(x):
    """
    参数:
    x -- numpy数组

    返回值:
    ds -- 计算的梯度值
    """
    
    s = 1/(1+np.exp(-x))
    ds = s*(1-s)
    
    return ds

**（3）输入图片变形为[width x height x 3, 1]

def image2vector(image):
    """
    参数:
    image -- 特定形状的numpy数组 shape(length, height, depth)
    
    返回值:
    v -- 向量形式的数组 shape(length*height*depth, 1)
    """
    
    v = image.reshape(image.shape[0]*image.shape[1]*image.shape[2],1)
    
    return v

（4）归一化处理

def normalizeRows(x):
    """
    参数:
    x -- 一个二维numpy数组 shape(n, m)
    
    返回值:
    x -- 按行归一化后的numpy矩阵
    """
    
    # 计算x数组的模
    x_norm = np.linalg.norm(x,ord=2,axis=1,keepdims=True)
    # 用x除以它的模
    x=x/x_norm

    return x

参数	说明	计算方法
ord=默认	二范数： $l_2$	$\sqrt{x_1^2+x_2^2+\dots+x_n^2}$
ord=2	二范数： $l_2$	同上
ord=1	一范数： $l_1$	$\lvert x_1\rvert+\lvert x_2\rvert+\dots+\lvert x_n\rvert$
ord=np.inf	无穷范数： $l_{\infty}$	$MAX\lvert x_i\rvert$
axis=1	按行向量处理
axis=0	按列向量处理
axis=None	矩阵范数

（5）softmax函数

softmax函数是一个规范化函数，用于算法需要分类两个或多个类的情况。