【吴恩达深度学习第二周】神经网络基础

【吴恩达深度学习第二周】神经网络基础

1. 二分分类

课程用了判断图片中有猫或没有猫这个例子来阐述二分分类。

二分分类的目的就是训练出一个分类器，也就是说我们需要构建神经网络。再上一周的课程中我们了解到针对不同的功能我们要在构建神经网络时选择的输入和输出就是至关重要的。在这个例子中，很明显我们拥有的数据是一张图片（非结构化数据），而我们要得到的是0和1两个标签（1代表有猫，0代表没有猫）

1.1 特征向量

在刚开始学习深度学习时，可能大家会疑惑图片是怎么做为输入的？其实图片也可以转化为向量的形式。

每张图片都由RGB三个通道组成，如图RGB三张图片叠加后才是原图片

在每张RGB图像中都有相应的像素值，比如在64 * 64的图片中，每个通道的图片就有64 * 64个像素，对应三个通道就一共有64 * 64 * 3=12288个像素值，如图将其依次存放成一个1 * 12288的特征向量。这个特征向量就是神经网络的一个输入。

1.2 数据的符号标识

$$\begin{gathered} M：数据集 \\ {M}_{train}:训练集；M_{test}:测试集 \\ 一般以上标来表示数据集中的数据，下标来表示单个数据所拥有的的特征 \\ 如：M=[（x^1,y^1）,（x^2,y^2）......（x^n,y^n）]（M表示数据集） \\ {m}_1=[x_1,x_2,x_3]（x_1,x_2,x_3表示图片的RGB三个通道，即三个特征） \end{gathered}$$
我们做二分类问题的目的是为了训练出一个分类器，所以我们需要大量的数据，我们会有多张图片，多个标签，因此会有多个特征向量，一般我们会将整个数据集的特征向量整合成一个更大的矩阵X。假设这张图片的尺寸为64 * 64，数据集中一共有n张图片，则在python中使用X.shape来查看X矩阵的尺寸为[12288,n]。
$$X=\left[\begin{array}{cccccc}.& .& .& .& .& .\\ .& .& .& .& .& .\\ .& .& .& .& .& .\\ x^1& x^2& .& .& .& x^n\\ .& .& .& .& .& .\\ .& .& .& .& .& .\\ .& .& .& .& .& .\end{array}\right]$$
同理我们也将所有的标签y整合成一个更大的矩阵Y。Y.shape=[1,n]。
$$\left[\begin{array}{cccccc}{y}^1& y^2& .& .& .& y^n\end{array}\right]\text{\hspace{1em}(3)}$$

2. logistic回归

Logistic Regression是监督学习的一种算法，适用于二分类法。所以我们上面辨别图片是否有小猫就是用了logistic算法。

这张图是吴恩达教授给的课件，详细的介绍了logistic算法的过程。现在我们根据上图来复现一遍。
$$\begin{gathered} 目的：给定特征向量x，获得y帽（即预测结果），且0<y帽<1,因为我们只要预测结果接近0和1 \\ 输入的特征向量：xϵR^{n_x},其中n_x指的是维度 \\ 训练集标签：yϵ(0or1) \\ 权重：wϵR^{n_x},其中nx指的是维度和输入的特征向量维度相同阈值：bϵR,b是一个实数 \\ 线性函数：z=w^{T}x+b,z的值会很可能会大于1，或者处于负数，不符合目的，因此单纯的线性函数无法满足二分分类 \\ 输出标签（y帽）：y帽=\sigma (w^{T}x+b)=\sigma (z)，这里\sigma 指的是sigmoid函数（如上图），因此y帽=\frac{1}{1+e^z} \\ 通过y帽=\frac{1}{1+e^z}和sigmoid函数图可得到以下结论 \\ 当z处于大值时，y帽=1 \\ 当z处于小值时，y帽=0 \\ 当z等于0时，y帽=0.5 \end{gathered}$$

3. logistic回归损失函数

3.1 损失函数（Loss function）

损失函数也被称为误差函数，是衡量单个样本的预测结果与实际结果之间的误差，所以说损失函数越小说明预测结果越准确。

上面两个式子都是为了计算损失函数，但是第一个式子呈现出来的函数图像是非凸型函数，第二个式子显示出来是凸型函数。注：这里的log指的是log_e,也就是ln。
非凸函数：

凸函数：

从上图可见，凸函数才存在全局最优解，而非凸函数仅有局部最优解，我们在训练过程中需要用到的梯度下降算法适用于凸函数模型，因此我们在计算损失函数时使用第二个式子。（这里不理解没事，接下来会继续讲解，记住损失函数使第二个式子就可以）
分析损失函数：
$$\begin{gathered} 注：以下的所有log指的是lo{g}_e,即ln \\ 如果y=1，则Loss=-y^{i}log(y{帽}^i) \\ 若y{帽}^i接近1，log(y{帽}^i)接近0，Loss接近0；若y{帽}^i接近0，log(y{帽}^i)为负无穷，Loss为正无穷 \\ 如果y=0，则Loss=-y^{i}log(1-y{帽}^i) \\ 若y{帽}^i接近1，log(1-y{帽}^i)为负无穷，Loss为正无穷；若y{帽}^i接近0，log(y{帽}^i)接近0，Loss接近0 \end{gathered}$$

3.2 成本函数（Cost function）

成本函数是衡量整个数据集的误差，其公式就是去每个样本损失函数总和的平均数。

4. 梯度下降法

4.1基本概念

在上面讲完成本函数后，我们可以发现决定成本函数大小的因素在于w和b两个参数，因此为了使成本函数达到一个最小值，我们必须找到最为合理的w和b，而寻找这两个参数的过程叫做梯度下降法。先看一张图片，这是一个凸函数，我们的目的就是为了找到图中的min，图中的x，y轴分别表示，w和b，z轴表示成本函数J(w,b)。在做梯度下降的过程中，要初始化w和b，在一般的情况下我们可以初始化为0或者任意数（logistic算法不初始化为0）。在图中，假设θ0为初始点，通过梯度下降法，会沿着梯度慢慢往下走，直到找到min。

4.2 参数更新的过程

为方便讲解，我们将原本可以是多维的w当做实数讲解。下面的横坐标指的是权值w，纵坐标指的是成本函数J(w)。如图这是一个凸函数。

参数更新的公式（以上图为例）
$$\begin{gathered} w:指权值；\alpha 指学习率，即梯度下降的步长；\frac{dJ(w)}{dw}指对J(w)对w求导，即梯度(在二维图中也叫斜率) \\ w:=w-\alpha \frac{dJ(w)}{dw} \end{gathered}$$
公式分析：
$$\begin{gathered} 请大家看图分析 \\ 当\frac{dJ(w)}{dw}>0时，最小值点在左边，通过公式w:=w-\alpha \frac{dJ(w)}{dw}可得w在减小，符合上图 \\ 当\frac{dJ(w)}{dw}<0时，最小值点在右边，通过公式w:=w-\alpha \frac{dJ(w)}{dw}可得w在增大，符合上图 \\ 当\frac{dJ(w)}{dw}=0时，达到图中的最小值点，w不再更新，即我们找到使成本函数最小时的权值w \end{gathered}$$
扩展：

当然，在正式计算时。不可能像上述一样只有w一个参数，还有b。所以最严谨的公式如下
$$\begin{gathered} \frac{\delta J(w,b)}{\delta w}是成本函数对w求偏导；\frac{\delta J(w,b)}{\delta b}是成本函数对b求偏导 \\ w:=w-\alpha \frac{\delta J(w,b)}{\delta w} \\ b:=b-\alpha \frac{\delta J(w,b)}{\delta b} \end{gathered}$$

5. logistic回归中的梯度下降法

梯度下降法中主要由正向传播和反向传播两个阶段来组成，其实就是一系列的计算图导数运算，所以在理解梯度下降法的过程中对数学是有一定的要求的，因此吴恩达教授在导数及计算图这方面有讲授了几节课，但这里我就不再讲解基础数学知识了，我们直接来看logistic回归中梯度下降法的全过程以及计算推导（其实有微积分或导数基础也不难理解）

5.1单个样本的梯度下降法

这里们假设一个样本它有两个特征x1和x2

正向传播
如上图所示，箭头的指向方向即正向传播的过程。分为几个部分

• 将输入加权求和得到线性函数
• 进行非线性函数计算
• 计算损失函数

反向传播
前面我们在介绍梯度下降法时，强调该算法的目的就是为了调整参数w和b，来使损失函数达到最小。因此在正向传播中最后会得到一个损失函数。而反向传播的目的就是为了更新w和b然后再次进行正向传播得到更小的损失函数。接下来我们进行反向传播的数学推导。（这里以w1为例，w2,b同理）
$$\begin{gathered} 目的：更新参数w_1和w_2和b来获得更小的损失函数，参数更新公式：w_1:=w_1-\alpha \frac{\delta L(w_1,b)}{\delta w_1} \\ w是初始化的值或是不断更新的值，\alpha 是自己给定的，因此我们需要获得的是\frac{\delta L(w_1,b)}{\delta w_1} \\ 正向传播后已知的数据：w_1，\alpha ，L(w_1,b) \\ 推导过程： \\ \frac{\delta L(w_1,b)}{\delta z}=\frac{\delta L(w_1,b)}{\delta a}\cdot \frac{\delta a}{\delta z}=(-\frac{y}{a}+\frac{1-y}{1-a})\cdot (1-a)\cdot a=a-y \\ \frac{\delta L(w_1,b)}{\delta w_1}=\frac{\delta L(w_1,b)}{\delta z}\cdot \frac{\delta z}{\delta w_1}=(a-y)\cdot x_1 \\ {w}_1:=w_1-\alpha \cdot (a-y)\cdot x_1 \end{gathered}$$
上述是整个大致求导的过程，为了更清楚，我把里面的细节求导也求一遍
$$\begin{gathered} \because xL(w_1,b)=-[ylna+(1-y)ln(1-a)]=-ylna-ln(1-a)+yln(1-a) \\ \therefore \frac{\delta L(w_1,b)}{\delta a}=-\frac{y}{a}+\frac{1}{1-a}-\frac{y}{1-a}=-\frac{y}{a}+\frac{1-y}{1-a} \\ \because a=\frac{1}{1+e^{-z}} \\ \therefore \frac{\delta a}{\delta z}=\frac{-(-e^{-z})}{(1+e^{-z}{)}^2}=\frac{e^{-z}}{(1+e^{-z}{)}^2}=\frac{1+e^{-z}-1}{(1+e^{-z}{)}^2} \\ =\frac{1}{1+e^{-z}}-\frac{1}{(1+e^{-z}{)}^2}=\frac{1}{1+e^{-z}}(1+\frac{1}{1+e^{-z}})=a(1-a) \end{gathered}$$

5.2 多个样本（数据集）的梯度下降法

和单个样本的梯度下降法的区别就是我们将上述的损失函数换成成本函数，虽然中间多了些步骤，但是大同小异。下面将整个梯度下降法的伪代码写一遍,这里用到了两个循环，分别是m个样本，和n个特征（x1和x2）
$$\begin{gathered} J=0；d{w}_1=0;d{w}_2=0;db=0;dz指\frac{\delta L(w,b)}{\delta z}=(a-y) \\ Fori=1tom(m指样本数) \\ {z}^{(i)}=w^T{x}^{(i)}+b \\ {a}^{(i)}=\sigma (z^{(i)}) \\ J+=-[y^{(i)}log{a}^{(i)}+(1-y)log(1-a{)}^{(i)}] \\ d{z}^{(i)}=a^{(i)}-y^{(i)} \\ d{w}_1+=x_1^{(i)}d{z}^{(i)} \\ d{w}_2+=x_2^{(i)}d{z}^{(i)} \\ db+=d{z}^{(i)} \\ 接着取平均值 \\ J=\frac{J}{m};d{w}_1=\frac{w_1}{m};d{w}_2=\frac{w_2}{m};db=\frac{b}{m} \\ 然后更新参数 \\ {w}_1:=w_1-\alpha d{w}_1; \\ {w}_2:=w_2-\alpha d{w}_2; \\ b:=b-\alpha b; \end{gathered}$$

6. 向量化

到了向量化这部分内容，其实主要就是给我们一种节省时间的编码思想。我们在上面多样本的梯度下降的伪代码中可以发现，我们用到了两个循环，而循环是耗时的。向量化的目的就是为了减小耗时，优化代码。

6.1 向量化与循环的代码差别

我们举两个例子来说明，通过下方例子可以看出向量化的代码简洁性。

**1. ** 将一个矩阵变换成e的指数的形式
$$\left[\begin{array}{c}{x}^1\\ x^2\\ .\\ .\\ .\\ .\\ x^n\end{array}\right]——————>\left[\begin{array}{c}{e}^{x^1}\\ e^{x^2}\\ .\\ .\\ .\\ .\\ e^{x^n}\end{array}\right]$$

import numpy
import math
#非向量化代码
u = np.zeros((n,1))
for i in range(n):
    u[i] = math.exp(v[i])
    
#向量化代码
u = n.exp(v)

2.
$$实现z=w^{T}x+b,w,x维度为n_x$$

import numpy
#非向量化代码
z = 0
w = np.zeros((n,1))
x = np.zeros((n,1))
for i in range(n_x):
    z += w[i].x[i]
z+=b
#向量化代码
z = np.dot(w,x) + b

6.2 向量化的优势

直接通过代码解释

import numpy as np
import time


#Vectorized version
#构建两个百万维的矩阵
a = np.random.rand(1000000)
b = np.random.rand(1000000)

tic = time.time()
c = np.dot(a,b)#将其矩阵相乘
toc = time.time()

print("result:",c)
print("Vectorized version:" + str(1000 * (toc - tic)) + "ms")

#Unvectorized version
c = 0
tic = time.time()
for i in range(1000000):
	c += a[i]*b[i]
toc = time.time()

print("result:",c)
print("For loop:" + str(1000 * (toc - tic)) + "ms") 

明显看出向量化版本的代码用时快了很多。

6.3 向量化logistic回归

这里也用伪代码表示，请与上面用循环表示的梯度下降的过程进行对比。
$$\begin{gathered} X指将所有数据集整合后的大矩阵，Y同理 \\ Z=w^{T}X+b=np.dot(w^T,X)+b \\ A=\sigma (Z) \\ dZ=A-Y \\ dw=\frac{1}{m}Xd{Z}^T \\ db=\frac{1}{m}np.sun(dZ) \\ w:=w-\alpha dw \\ b:=b-\alpha db \end{gathered}$$

7. python中的广播

我这里简单的举几个例子，大家根据例子自行理解（挺好理解的，有点类似复制）
$$\left[\begin{array}{c}1\\ 2\\ 3\\ 4\end{array}\right]+100=\left[\begin{array}{c}1\\ 2\\ 3\\ 4\end{array}\right]+\left[\begin{array}{c}100\\ 100\\ 100\\ 100\end{array}\right]=\left[\begin{array}{c}101\\ 102\\ 103\\ 104\end{array}\right]$$

$$\left[\begin{array}{ccc}1& 2& 3\\ 4& 5& 6\end{array}\right]+\left[\begin{array}{ccc}100& 200& 300\end{array}\right]=\left[\begin{array}{ccc}1& 2& 3\\ 4& 5& 6\end{array}\right]+\left[\begin{array}{ccc}100& 200& 300\\ 100& 200& 300\end{array}\right]=\left[\begin{array}{ccc}101& 202& 303\\ 104& 205& 306\end{array}\right]$$

$$\left[\begin{array}{ccc}1& 2& 3\\ 4& 5& 6\end{array}\right]+\left[\begin{array}{c}100\\ 200\end{array}\right]=\left[\begin{array}{ccc}1& 2& 3\\ 4& 5& 6\end{array}\right]+\left[\begin{array}{ccc}100& 100& 100\\ 200& 200& 200\end{array}\right]=\left[\begin{array}{ccc}101& 102& 103\\ 204& 205& 206\end{array}\right]$$

8. python/numpy vectors

a = np.random.randn(5)
print(a)
print(a.shape)

a = np.random.randn(5,1)
print(a)
print(a.shape)

a = a.reshape((1,5))
print(a)

9. 课后作业

• 1. 神经元节点计算什么？

  A. 神经元节点先计算激活函数，再计算线性函数(z = Wx + b)

  B. 神经元节点先计算线性函数（z = Wx + b），再计算激活。

  C. 神经元节点计算函数g，函数g计算(Wx + b)。

  D. 在 将输出应用于激活函数之前，神经元节点计算所有特征的平均值

• 2. 假设img是一个（32,32,3）数组，具有3个颜色通道：红色、绿色和蓝色的32x32像素的图像。 如何将其重新转换为列向量？

• 3.

  a = np.random.randn(2, 3) # a.shape = (2, 3)
  b = np.random.randn(2, 1) # b.shape = (2, 1)
  c = a + b
  #求c的维度
  

• 4.

  a = np.random.randn(3, 3)
  b = np.random.randn(3, 1)
  c = a * b
  #求c的维度
  

• 5.

  a = np.random.randn(12288, 150) # a.shape = (12288, 150)
  b = np.random.randn(150, 45) # b.shape = (150, 45)
  c = np.dot(a, b)
  #求c的维度
  

• 6.

  a = np.random.randn(3, 3)
  b = np.random.randn(3, 1)
  c = a * b
  #求c的维度
  

答案：

• 1. B，激活函数指类似sigmoid函数，Relu函数之类的函数

• 2.

  x = img.reshape((32 * 32 * 3, 1))
  

• 3. 根据广播机制，c的维度为（2,3）

• 4.“*”指矩阵元素间按照乘法来相乘，元素间相乘需要两个矩阵的维数相同。所以该题会报错，无法计算。

• 5. c的维度为（12288,45），简单的矩阵乘法。目的在于分清np.dot和“*”之间的区别

• 6. 根据广播机制，c的维度为（3,3），b先复制成（3,3）在进行元素间乘法