吴恩达神经网络与深度学习章节笔记（一）——逻辑回归

视频课程链接：
https://www.bilibili.com/video/BV1FT4y1E74V?
笔记参考链接：
https://blog.csdn.net/weixin_36815313/article/details/105728919
课程作业链接：
https://download.csdn.net/download/baoli8425/19821557?spm=1001.2014.3001.5503

1. 二元分类 (Binary Classification)

逻辑回归是一个用于二元分类(binary classification)的算法。以一张图片作为输入，如果识别为猫，则输出标签1。如果识别到不是猫，那么输出标签0。现在我们用字母$y$来表示输出的结果。

一张图片在计算机中的表示方式类似于上图。一张图片由红、绿、蓝（RGB）三种颜色通道的矩阵构成，如果你的图片大小为$64\times 64$像素，那么你就有三个规模为$64\times 64$的矩阵，分别对应图片中红、绿、蓝三种像素的强度值。为简单起见，上图只用了规模为$5\times 4$的矩阵表示。

为了把这些像素值转换为特征向量$x$，首先定义一个特征向量$x$来表示这张图片，我们把所有的像素都取出来，例如255、231等等，直到取完所有红色通道的像素，接着最后是255、134、…、255、134等等，直到得到一个特征向量，把图片中所有的红、绿、蓝像素值都列出来。如果图片的大小为$64\times 64$像素，那么向量$x$的总维度将是$n=n_x=64\times 64\times 3=12288$，即三个像素矩阵中像素的总量。
所以在二元分类问题中，我们的目标就是得到一个分类器，它以图片的特征向量作为输入，然后预测输出结果$y\text{y}y$为1还是0，也就是预测图片中是否有猫。

2. Logistic回归 (Logistic Regression)

对于二元分类问题来讲，给定一个输入特征向量$X$，它可能对应一张图片，你想识别这张图片识别看它是否是一只猫或者不是一只猫的图片，你想要一个算法能够输出预测，你只能称之为$\hat{y}$，也就是你对实际值$y$的估计。
$X$是一个$n_x$维的向量（相当于有$n_x$个特征的特征向量）。我们用$w$表示逻辑回归的参数，这也是一个$n_x$维向量（因为$w$实际上是特征权重，维度与特征向量相同），参数里面还有$b$，这是一个实数，表示偏差。因此给出输入$x$以及参数$w$和$b$之后，我们可以使用$\hat{y}=w^{T}x+b$表达预测值。

但是这对于二元分类问题来讲不是一个非常好的算法，因为你想让$\hat{y}$表示实际值$y$等于1的机率的话，$\hat{y}\text{y^}\hat{y}$应该在0到1之间。这是一个需要解决的问题，因为$w^{T}x+b$可能比1要大得多，或者甚至为一个负值。对于你想要的在0和1之间的概率来说它是没有意义的，因此在逻辑回归中，我们的输出$\hat{y}$应该是等于由上面得到的线性函数式子作为自变量的sigmoid函数中，公式如上图最下面所示，将线性函数转换为非线性函数。
下图是sigmoid函数的图像，如果我把水平轴作为z轴，那么关于$z$的sigmoid函数是这样的，它是平滑地从0走向1，曲线与纵轴相交的截距是0.5，这就是关于的sigmoid函数的图像。我们通常都使用z来表示$w^{T}x+b$的值。

在这里$z$是一个实数，这里要说明一些要注意的事情，如果$z$非常大那么$e^{-z}$将会接近于0，关于$z$的sigmoid函数将会近似等于1除以1加上某个非常接近于0的项，因为$e$的指数如果是个绝对值很大的负数的话，这项将会接近于0，所以如果$z$很大的话那么关于$z$的sigmoid函数会非常接近1。相反地，如果$z$非常小或者说是一个绝对值很大的负数，那么关于$e^{-z}$这项会变成一个很大的数，你可以认为这是1除以1加上一个非常非常大的数，所以这个就接近于0。实际上你看到当z变成一个绝对值很大的负数，关于$z$的sigmoid函数就会非常接近于0。因此当你实现逻辑回归时，你的工作就是去让机器学习参数$w$以及$b$这样才使得$\hat{y}$成为对$y=1$这一情况的概率的一个很好的估计。
为了训练逻辑回归模型的参数$w\text{w}w$和参数$b\text{b}b$ ，我们需要一个代价函数，通过训练代价函数来得到参数$w\text{w}w$和参数$b\text{b}b$。

3. Logistic回归损失函数 (Logistic Regression Cost Function)

为了让模型通过学习调整参数，你需要给予一个$m$样本的训练集，这会让你在训练集上找到参数$w$和参数$b$，来得到你的输出。对训练集的预测值$\hat{y}\text{y^}\hat{y}$，我们更希望它会接近于训练集中的$y\text{y}y$值。 训练样本$i$所对应的预测值是$y(i)$，是用训练样本的然后通过sigmoid函数来得到，也可以定义为$z$，我们将使用这个符号$(i)$注解，上标$(i)$来指明数据表示$x$或者$y$或者$z$或者其他数据的第$i$个训练样本，这就是上标$(i)$的含义。
损失函数又叫做误差函数，用来衡量预测输出值和实际值有多接近，Loss function：$L(\hat{y},y)$。一般我们用预测值和实际值的平方差或者它们平方差的一半，但是通常在逻辑回归中我们不这么做，因为当我们在学习逻辑回归参数的时候，会发现我们的优化目标不是凸优化，只能找到多个局部最优值，梯度下降法很可能找不到全局最优值。
我们在逻辑回归中用到的损失函数是：

（1）当$y$ = 1时损失函数 $L=-log(\hat{y})$，如果想要损失函数$L$尽可能得小，那么$\hat{y}$就要尽可能大，因为sigmoid函数取值[0,1]，所以$\hat{y}$会无限接近于1。
（2）当$y$ = 0时损失函数 $L=-log(1-\hat{y})$，如果想要损失函数$L$尽可能得小，那么$\hat{y}$就要尽可能小，因为sigmoid函数取值[0,1]，所以$\hat{y}$会无限接近于0。
损失函数是在单个训练样本中定义的，它衡量的是算法在单个训练样本中表现如何，为了衡量算法在全部训练样本上的表现如何，我们需要定义一个算法的代价函数，算法的代价函数是对$m\text{m}m$个样本的损失函数求和然后除以$m\text{m}m$:

损失函数只适用于像这样的单个训练样本，而代价函数是参数的总代价，所以在训练逻辑回归模型时候，我们需要找到合适的$w\text{w}w$和$b\text{b}b$，来让代价函数$J\text{J}J$的总代价降到最低。根据我们对逻辑回归算法的推导及对单个样本的损失函数的推导和针对算法所选用参数的总代价函数的推导，结果表明逻辑回归可以看做是一个非常小的神经网络。

4. 梯度下降法 (Gradient Descent)

4.1 多维空间

在这个图中，横轴表示空间参数$w$和$b$，实际上，$w$可以是更高的维度，但是为了更好地绘图，我们定义$w$和$b$，都是单一实数，代价函数(成本函数)$J(w,b)$是在水平轴$w$和$b$上的曲面，因此曲面的高度就是$J(w,b)$在某一点的函数值。我们所要做的就是找到使得代价函数(成本函数)$J(w,b)\text{J(w,b)}J(w,b)$函数值是最小值，对应的参数$w\text{w}w$和$b\text{b}b$。

如上图，代价函数(成本函数)$J(w,b)$是一个凸函数(convex function)。

如上图，它是非凸的并且有很多不同的局部最小值。由于逻辑回归的代价函数(成本函数)$J(w,b)$特性，我们必须定义代价函数(成本函数)$J(w,b)\text{J(w,b)}J(w,b)$为凸函数。
通过以下的三个步骤我们可以找到全局最优解，也就是代价函数(成本函数)$J(w,b)$这个凸函数的最小值点。
（1）初始化参数$w\text{w}w$和$b\text{b}b$，可以采用随机初始化的方法。对于逻辑回归几乎所有的初始化方法都有效，因为函数是凸函数；
（2）朝最陡的下坡方向走一步，我们可能停在这里也有可能继续朝最陡的下坡方向再走一步；
（3）直到走到全局最优解或者接近全局最优解的地方。

4.2 二维空间

假设代价函数(成本函数)$J(w)$只有一个参数$w$，即用一维曲线代替多维曲线。$$w:=w-\alpha \frac{dJ(w)}{dw}$$其中:=表示更新参数，$\alpha$表示学习率（learning rate），用来控制步长（step），则向下走一步的长度$\frac{dJ(w)}{dw}$，就是函数$J(w)$对$w$求导（derivative），在Python代码中我们会使用$dw$表示这个结果。

对于导数更加形象化的理解就是斜率（slope），如上图该点的导数就是这个点相切于$J(w)$的小三角形的高除宽。假设我们以如图点为初始化点，该点处的斜率的符号是正的，即$\frac{dJ(w)}{dw}>0$，因此根据公式$w$会逐步递减，即向左走一步。

如上图，整个梯度下降法的迭代过程就是不断地向左走，直至逼近最小值点。

假设我们以上图中的点为初始化点，该点处的斜率的符号是负的，即$\frac{dJ(w)}{dw}<0$，因此根据公式$w$会逐步递增，即向右走一步。

如上图，整个梯度下降法的迭代过程就是不断地向右走，即朝着最小值点方向走。
因此扩展到两个参数的情况下，逻辑回归的代价函数(成本函数)$J(w,b)$：

其中，$\partial$表示求偏导符号，可以读作$round$，$\frac{\partial J(w,b)}{\partial w}$就是函数$J(w,b)$对$w$求偏导，在代码中我们会使用$dw$表示这个结果；$\frac{\partial J(w,b)}{\partial b}$就是函数$J(w,b)$对$b$求偏导，在代码中我们会使用$db$表示这个结果。
小写字母$d$用在求导数（derivative），即函数只有一个参数， 偏导数符号$\partial$用在求偏导（partial derivative），即函数含有两个以上的参数。

5. 计算图 (Computation Graph)

可以说，一个神经网络的计算，都是按照前向或反向传播过程组织的。首先我们计算出一个新的网络的输出（前向过程），紧接着进行一个反向传输操作。后者我们用来计算出对应的梯度或导数。计算图解释了为什么我们用这种方式组织这些计算过程。
举例说明，我们尝试计算函数$J(a,b,c)=3\ast (a+b\ast c)$，这个函数由三个变量$a,b,c$组成。计算这个函数实际上有三个不同的步骤：
（1）首先是计算$u=b\ast c$；
（2）然后计算$v=a+u$；
（3）最后输出$J=3\ast v$，这就是要计算的函数$J$。
我们可以把这三步画成如下的计算图。

6. 计算图的导数计算 (Derivatives with a Computation Graph)

6.1 导数计算

为了计算导数，从右到左（红色箭头）的过程是用于计算导数最自然的方式。

根据导数计算可知$\frac{dJ}{dv}=3$，这样我们就完成了第一步反向传播。

对于第二个方框中的$a$和$u$，可对其求导得到$\frac{dv}{da}=1$， $\frac{dv}{du}=1$。根据多元微积分计算的链式法则，可得$\frac{dJ}{du}=\frac{dJ}{dv}\ast \frac{dv}{du}=3\ast 1=3$，$\frac{dJ}{da}=\frac{dJ}{dv}\ast \frac{dv}{da}=3\ast 1=3$，这样就完成了另一个反向传播。

对于第三个方框中的$b$和$c$，对其求导可得$\frac{du}{db}=c=2$，$\frac{dv}{dc}=b=3$，因此根据链式法则可得$\frac{dJ}{db}=\frac{dJ}{dv}\ast \frac{dv}{du}\ast \frac{du}{db}=3\ast 1\ast 2=6$，$\frac{dJ}{dc}=\frac{dJ}{dv}\ast \frac{dv}{du}\ast \frac{du}{dc}=3\ast 1\ast 3=9$，这样就完成了最后两个反向传播。

6.2 符号约定

在Python中，可用变量名$dFinalOutputvar\_dvar$来表示导数$\frac{dFinalOutputvar}{dvar}$，但这样子变量名太长。由于在反向传播计算中，始终是对最终输出变量$FinalOutputvar$求导，因此可以简化使用变量名$dvar$，来表示那个量。
在上述例子中，可作如下定义：

• Python代码中的变量名$dv$，代表$\frac{dJ}{dv}$。
• Python代码中的变量名$du$，代表$\frac{dJ}{du}$。
• Python代码中的变量名$da$，代表$\frac{dJ}{da}$。
• Python代码中的变量名$db$，代表$\frac{dJ}{db}$。
• Python代码中的变量名$dc$，代表$\frac{dJ}{dc}$。

7. Logistic回归的梯度下降法 (Logistic Regression Gradient Descent)

7.1 前向过程

假设样本只有两个特征$x_1$和$x_2$，为了计算$z$，我们需要输入参数$w_1$、$w_2$和$b$，除此之外还有特征值$x_1$和$x_2$。因此$z$的计算公式为：$$z=w_1{x}_1+w_2{x}_2+b$$逻辑回归的公式定义如下：$$\hat{y}=a=\sigma (z)$$其中$z=w^T+b$，$\sigma (z)=\frac{1}{1+e^{-z}}$
因此损失函数：$$L({\hat{y}}^{(i)},y^{(i)})=-y^{(i)}\log {\hat{y}}^{(i)}-(1-y^{(i)})\log (1-{\hat{y}}^{(i)})$$代价函数：$$J(w,b)=\frac{1}{m}\sum _i^{m}L({\hat{y}}^{(i)},y^{(i)})$$假设现在只考虑单个样本的情况，单个样本的损失函数定义如下：$$L(a,y)=-(y\log (a)+(1-y)\log (1-a))$$其中$a$是逻辑回归的输出，$y$是样本的标签值。现在让我们画出表示这个计算的计算图。

因此，为了使得逻辑回归中最小化代价函数$L(a,y)$，我们需要做的仅仅是修改参数$w$和$b$的值。

7.2 反向过程

首先我们需要反向计算出代价函数$L(a,y)$关于$a$的导数，根据微积分计算可得：$$da=\frac{dL(a,y)}{da}=\frac{-y}{a}+\frac{1-y}{1-a}$$接下来再反向一步，计算代价函数$L$关于$z$的导数$\frac{dL(a,y)}{dz}$，根据微积分计算可得：$$dz=\frac{dL(a,y)}{dz}=\frac{dL}{dz}=(\frac{dL}{da})\cdot (\frac{da}{dz})=(\frac{-y}{a}+\frac{1-y}{1-a})\cdot a(1-a)=a-y$$现在进行最后一步反向推导，也就是计算$w$和$b$变化对代价函数$L$的影响。其中，$$d{w}_1=\frac{\partial L}{\partial w_1}=(\frac{\partial L}{\partial a})\cdot (\frac{\partial a}{\partial z})\cdot (\frac{\partial z}{\partial w_1})=x_1\cdot dz$$ $$d{w}_2=\frac{\partial L}{\partial w_2}=(\frac{\partial L}{\partial a})\cdot (\frac{\partial a}{\partial z})\cdot (\frac{\partial z}{\partial w_2})=x_2\cdot dz$$ $$db=dz$$ 因此，对于单个样本的梯度下降算法，需要做如下事情：

1. 根据公式$dz=(a-y)\cdot dz=(a-y)$计算$dz$，根据公式$d{w}_1=x_1\cdot dz$计算$d{w}_1$， 根据公式$d{w}_2=x_2\cdot dz$计算$d{w}_2$，根据$db=dz$计算$db$；
2. 更新$w_1=w_1-\alpha \cdot d{w}_1$，更新$w_2=w_2-\alpha \cdot d{w}_2$，更新$b=b-\alpha \cdot db$；

这就是关于单个样本实例的梯度下降算法中参数更新一次的步骤。

8. $m$个样本的梯度下降 (Gradient Descent on $m$ examples)

在上一节中已经了解了怎样计算导数，并且实现针对单个训练样本的逻辑回归的梯度下降算法，但是训练逻辑回归模型不仅仅只有一个训练样本，而是有$m$个训练样本的整个训练集。
首先回顾一下算法的代价函数$J(w,b)$的定义：$$J(w,b)=\frac{1}{m}\sum _{i=1}^{m}L(a^{(i)},y^{(i)})$$带有求和的全局代价函数，实际上是从1到$m$项的各个损失函数的平均，它表明全局代价函数对$w_1$的微分也同样是各项损失函数对$w_1$微分的平均。$$d{w}_1=\frac{\partial L}{\partial w_1}=x_1\cdot dz=\frac{1}{m}\sum _i^m{x}_1^{(i)}(a^{(i)}-y^{(i)})$$$$d{w}_2=\frac{\partial L}{\partial w_2}=x_2\cdot dz=\frac{1}{m}\sum _i^m{x}_2^{(i)}(a^{(i)}-y^{(i)})$$$$db=dz=\frac{1}{m}\sum _i^m(a^{(i)}-y^{(i)})$$ 伪代码实现流程：

# 变量初始化
J=0
dw1=0
dw2=0
db=0
# 遍历m个训练样本
for i = 1 to m:
	# 逻辑回归的计算
    z(i) = wx(i)+b
    a(i) = sigmoid(z(i))
    J += -[y(i)log(a(i))+(1-y(i))log(1-a(i))]
    # 逻辑回归的梯度计算
    dz(i) = a(i)-y(i)
    # 遍历n个特征
	for j = 1 to n:
		dwj += xj(i)*dz(i)
    db += dz(i)
J/= m
dw1/= m
dw2/= m
db/= m
w1 = w1-alpha*dw1
w2 = w2-alpha*dw2
b = b-alpha*db

但这种计算中有两个缺点，也就是说应用此方法在逻辑回归上需要编写两个for循环。第一个for循环是循环遍历所有$m\text{m}m$个训练样本，第二个for循环是遍历所有$n\text{n}n$个特征。
当你应用深度学习算法，你会发现在代码中显式地使用for循环会使你的算法很低效，同时在深度学习领域会有越来越大的数据集。所以能够应用你的算法且没有显式的for循环是重要的，并且会帮助你适用于更大的数据集。所以这里采用向量化的技术，它可以允许你的代码摆脱这些显式的for循环。

9. 向量化 (Vectorization)

9.1 向量化Logistic回归

Logistic回归的向量化实现流程如下：
(1) 创建一个$n_x\times m$的矩阵$X=[x^{(1)},x^{(2)},\cdots \cdots ,x^{(m)}]$作为训练输入，即$X$是一个$n_x$行$m$列的矩阵$R^{n_x\times m}$。
(2) 创建一个$n_x\times m$的矩阵$Z=[z^{(1)},z^{(2)},\cdots \cdots ,z^{(m)}]=w^{T}X+[b,b,\cdots \cdots ,b]=[w^T{x}^{(1)}+b,w^T{x}^{(2)}+b,\cdots \cdots ,w^T{x}^{(m)}+b]$计算所有的$z$，这里的$b$是一个实数，或者可以说是一个$1\times 1$的矩阵，当你将这个向量加上这个实数时，Python自动把这个实数$b$扩展成一个$n_x\times m$的行向量，这在Python中被称作广播(Broadcasting)。
(3) 计算所有的激活函数$A=[a^{(1)},a^{(2)},\cdots \cdots ,a^{(m)}]=\sigma (Z)$。
Python代码实现($n_x=2,m=2$)：

import numpy as np

w = np.array([[2,2],[2,2]])
b = np.array([[1,1],[1,1]])
X = np.array([[2,6],[4,8]])

Z = np.dot(w.T,X)+b
A = 1 / (1 + np.exp(Z))
print(Z)
print(A)

输出结果：

这样就利用向量化在同一时间内高效地完成所有$m$个训练样本的前向传播计算，得到所有的激活函数$a$。

9.2 向量化Logistic回归的梯度输出

前面已经计算得到$A=[a^{(1)},a^{(2)},\cdots \cdots ,a^{(m)}]$，我们需要找到这样一个行向量$Y=[y^{(1)},y^{(2)},\cdots \cdots ,y^{(m)}]$，由此可以计算$$dZ=[d{z}^{(1)},d{z}^{(2)},\cdots \cdots ,d{z}^{(m)}]=[a^{(1)}-y^{(1)},a^{(2)}-y^{(2)},\cdots \cdots ,a^{(m)}-y^{(m)}]=A-Y$$Python代码实现：

dZ = A - Y

对于$db$和$dW$，前面已经推导出$$db=\frac{1}{m}\sum _i^{m}d{z}^{(i)}$$ $$dW=\frac{1}{m}\ast dZ\ast X^T=\frac{1}{m}\ast (x^{(1)}d{z}^{(1)}+x^{(2)}d{z}^{(2)}+\cdots \cdots +x^{(m)}d{z}^{(m)})$$ Python代码实现：

db = np.sum(dZ) / m
dW = np.dot(dZ, X.T) / m

这样就利用向量化高效地完成反向传播的计算并以此来计算梯度。

10. Logistic损失函数的解释 (Explanation of Logistic Regression Cost Function)

10.1 单个训练样本的损失函数

在逻辑回归中，需要预测的结果$\hat{y}$可以表示为$\hat{y}=\sigma (w^{T}x+b)=\frac{1}{1+e^{-z}}$。我们约定$\hat{y}=p(y=1|x)$，即算法的输出$\hat{y}$是给定训练样本$x$条件下$y$等于1的概率。
$$\{\begin{array}{ll}y=1:& p(y|x)=\hat{y}\\ y=0:& p(y|x)=1-\hat{y}\end{array}$$上述的两个条件概率公式可以合并成如下公式：$$p(y|x)={\hat{y}}^y(1-\hat{y}{)}^{1-y}$$由于$\log$函数是严格单调递增的函数，因此最大化$\log (p(y|x))$等价于最大化$p(y|x)$。计算$p(y|x)$的$\log$对数，即计算$\log ({\hat{y}}^y(1-\hat{y}{)}^{1-y})$，根据对数函数的性质可化简为：$$\log (p(y|x))=\log ({\hat{y}}^y(1-\hat{y}{)}^{1-y})=ylog\hat{y}+(1-y)log(1-\hat{y})$$而这就是我们前面提到的损失函数的负数$-L(\hat{y},y)$，前面有一个负号的原因是当你训练深度学习算法时，需要算法输出值的概率是最大的(以最大的概率预测这个值)，然而在逻辑回归中我们需要最小化损失函数，因此将最小化损失函数与最大化条件概率的对数$\log (p(y|x))$关联起来，这就是单个训练样本的损失函数表达式。

10.2 $m$个训练样本的损失函数

假设所有的训练样本服从同一分布且相互独立，即独立同分布的，所有这些样本的联合概率就是每个样本概率的乘积：
$$P(labelsintrainingset)=\prod _{i=1}^{m}P(y^{(i)}\mid x^{(x)})$$令这个概率最大化等价于令其对数最大化，对等式两边取对数：
$$P(labelsintrainingset)=\log \prod _{i=1}^{m}P(y^{(i)}\mid x^{(x)})=\sum _{i=1}^m\log P(y^{(i)}\mid x^{(x)})=\sum _{i=1}^m-L({\hat{y}}^{(i)},y^{(i)})$$计算这个式子的最大值，可以将负号移到求和符号的外面，即$-{\sum }_{i=1}^{m}L({\hat{y}}^{(i)},y^{(i)})$，这样我们就推导出了前面给出的logistic回归的损失函数(成本函数)$J(w,b)={\sum }_{i=1}^{m}L({\hat{y}}^{(i)},y^{(i)})$，并且计算$J(w,b)$的最小值。
最后为了方便，可以对损失函数(成本函数)进行适当的缩放，因此就在前面加一个额外的常数因子$\frac{1}{m}$，即：$$J(w,b)=\frac{1}{m}\sum _{i=1}^{m}L({\hat{y}}^{(i)},y^{(i)})$$