DeepLearning.AI笔记：二、神经网络编程基础

神经网络编程基础

2.1 二分类(Binary Classification)

假设有一张图片作为输入，1(cat) vs 0(not cat)

在计算机中保存一张图片需要RBG三种颜色的矩阵通道，如果图片像素为$64\ast 64$，那么总的向量$x$的维度就是$n_x=64\ast 64\ast 3=12288$，这就是一张图片的输入$input$，最后再预测是$0or1$。
一些符号定义：

$x=(x_1,...,x_{n_x}{)}^T$：表示一个$n_x$维数据，作为输入,即$n_x$维的一个列向量，
$y$：表示输出，取值是$(0,1)$，
$(x^{(i)},y^{(i)})$：表示第$i$个input，
$X=[x^{(1)},...,x^{(n)}{]}_{(n_x,m)}$：表示总的input数据，维度为$n_x\ast m$，
$Y=[y^{(1)},...,y^{(n)}{]}_{(1,m)}$：表示所有数据的$Label$，是一个$m$维的行向量。

在python中可以用.shape()来查看某个矩阵的形状

x = [[1,4,6],[6,2,6],[5,5,4]]
x.shape()

2.2逻辑回归(Logistic Regression)

$GivenX,\hat{y}=P(y=1|x),0\le \hat{y}\le 1$
$x\in {\mathbb{R}}^{n_x}$
$\omega \in {\mathbb{R}}^{n_x},b\in \mathbb{R}.$
$Output:\hat{y}=\sigma ({\omega }^{T}x+b)$

对于$\sigma (z)=\frac{1}{1+e^{-z}}$函数如果$Z$越小，$\sigma (z)$就越接近0， $Z$越大，$\sigma (z)$就越接近1.
其中，z定义为：$z^{(i)}={\omega }^T{x}^{(i)}+b$，上标$(i)$表示input训练列向量的第$i$个

2.3逻辑回归的代价函数(Cost Function of Logistic Regression)

${\hat{y}}^{(i)}=\sigma ({\omega }^T{x}^{(i)}+b),\sigma (z)=\frac{1}{1+e-z}$
我们希望模型的预测值接近目标实际值：${\hat{y}}^{(i)}\approx y^{(i)}$，由此引出损失函数
损失函数（误差函数）：
可以用${\hat{y}}^{(i)}$与$y^{(i)}$之间的平方差或者绝对值，但是在逻辑回归中通常不用它们，因为在学习逻辑回归参数的时候，很多情况下优化目标不是凸优化的，可能有很多个局部的极值点，梯度下降算法很可能找不到全局最优解。
在逻辑回归中用到的损失函数为：
$$L(\hat{y},y)=-yln(\hat{y})-(1-y)ln(1-\hat{y})$$

• 当$y=1$时，损失函数$L=-ln(\hat{y})$.
  如果希望$L$尽可能小，那么$\hat{y}$就要尽可能大，又$\hat{y}$的取值为$[0,1]$，那么$\hat{y}$就需要尽可能接近$1$.
• 当$y=0$时，损失函数$L=-ln(1-\hat{y})$
  如果希望$L$尽可能小，那么$\hat{y}$就要尽可能小，又$\hat{y}$的取值为$[0,1]$，那么$\hat{y}$就需要尽可能接近$0$.

那么当我们有$m$个个体的数据，就需要对$m$个损失函数求和然后除以$m$：
$$J(\omega ,b)=\frac{1}{m}\sum _{i=1}^{m}L({\hat{y}}^{(i)},y^{(i)})=\frac{1}{m}\sum _{i=1}^m(-y^{(i)}ln({\hat{y}}^{(i)})-(1-y^{(i)})ln(1-{\hat{y}}^{(i)}))$$

2.4 梯度下降(Gradient Descent)

$GradientDesent:$
$Recap:\hat{y}=\sigma ({\omega }^{T}x+b),\sigma (z)=\frac{1}{1+e-z}$
$J(\omega ,b)=\frac{1}{m}{\sum }_{i=1}^{m}L({\hat{y}}^{(i)},y^{(i)})=\frac{1}{m}{\sum }_{i=1}^m\left(-y^{(i)}ln({\hat{y}}^{(i)})-(1-y^{(i)})ln(1-{\hat{y}}^{(i)})\right)$

1.如下图所示，随机初识化$w$
2.沿着梯度下降最快的地方一直走可以达到全局最低点

• $w$的更新权值公式：
  $$\omega :=\omega -\alpha \frac{dJ(\omega )}{d\omega }$$
  $\alpha$：表示学习率，
  $\frac{dJ(\omega )}{d\omega }$：表示$J(w,b)$对$w$的导数
  
  在二维平面的情况下：
  
  该公式的更新会使J(w)逐渐向最低点逼近。
• 同理，$b$的权值更新公式：
  $$b:=b-\alpha \frac{\partial J(w,b)}{\partial b}$$

2.5 计算图(Computation Graph)

设有$J(a,b,c)=3(a+bc)$,其中$a=5,b=3,c=2$
令:
$u=bc$
$v=a+u$
则$J=3v$

计算J的导数

$\frac{dJ}{dv}=3$
$\frac{dJ}{du}=\frac{dJ}{dv}\frac{dv}{du}=3\ast 1$,
$\frac{dJ}{da}=\frac{dJ}{dv}\frac{dv}{da}=3\ast 1$,
$\frac{dJ}{db}=\frac{dJ}{du}\frac{du}{db}=3\ast 2=6$
$\frac{dJ}{dc}=\frac{dJ}{du}\frac{du}{dc}=3\ast 3=9$

反向传播

结合2.9中可以有形象理解

2.9 逻辑回归中的梯度下降(Logistic Regression Gradient Descent)

如图：在这个公式的外侧画上长方形。然后计算： $\hat{y}=a=\sigma (z)$也就是计算图的下一 步。最后计算损失函数$L(a,y)$。 有了计算图，我就不需要再写出公式了。因此，为了使得 逻辑回归中最小化代价函数$L(a,y)$，我们需要做的仅仅是修改参数$w$和$b$的值。

现在让我们来讨论通过反向计算 出导数。 因为我们想要计算出的代价函数$L(a,y)$的导数，首先我们需要反向计算出代价函 数$L(a,y)$关于$a$的导数，在编写代码时，你只需要用$da$来表示$\frac{dL(a,y)}{da}$。 通过微积分得到：
$$\frac{dL(a,y)}{da}=-\frac{y}{a}+\frac{1-y}{1-a}=a-y\widehat{=}da\text{\hspace{1em}(1)}$$
$$dz\widehat{=}\frac{\text{d}L}{\text{d}z}=\frac{\text{d}L}{\text{d}a}\cdot \frac{\text{d}a}{\text{d}z}\text{\hspace{1em}(2)}$$
$$\frac{\text{d}a}{\text{d}z}=a\cdot (1-a)\text{\hspace{1em}(3)}$$
将$(3)$式代入$(2)$式,有：
$$\frac{\text{d}L}{\text{d}z}=a-y\text{\hspace{1em}(4)}$$
最后计算$w$和$b$对代价函数$J$的影响：
$$d{\omega }_1\widehat{=}\frac{dL}{d{\omega }_1}=\frac{1}{m}\sum _i^m{x}_1^{(i)}(a^{(i)}-y^{(i)})\text{\hspace{1em}(5)}$$
$$d{\omega }_2\widehat{=}\frac{dL}{d{\omega }_2}=\frac{1}{m}\sum _i^m{x}_2^{(i)}(a^{(i)}-y^{(i)})\text{\hspace{1em}(6)}$$
$$db\widehat{=}\frac{dL}{db}=\frac{1}{m}\sum _i^m(a^{(i)}-y^{(i)})\text{\hspace{1em}(7)}$$

最后更新权值：
$$w_1=w_1-\alpha \frac{dL}{d{w}_1}=w_1-\alpha \cdot d{w}_1\text{\hspace{1em}(8)}$$
$$w_2=w_2-\alpha \frac{dL}{d{w}_2}=w_2-\alpha \cdot d{w}_2\text{\hspace{1em}(9)}$$
$$b=b-\alpha \frac{dL}{db}=b-\alpha \cdot db\text{\hspace{1em}(10)}$$

2.10 Logistic Regression on m examples代码流程

首先初始化$J=0,d{w}_1=0,d{w}_2=0,db=0$
代码流（非正式代码）：

for i in range(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)  #计算dL/dz
	dw1 += x1(i) * dz(i) #计算dL/dw1
	dw2 += x2(i) * dz(i) #计算dL/dw2
	db += dz(i)          #计算dL/db
J /= m
dw1 /= m
dw2 /= m
db /= m
w = w - alpha*dw
b = b - alpha*db

以上只应用了一步梯度下降，因此需要重复上面很多次。
但这种计算中有两个缺点，也就是说应用此方法在逻辑回归上你需要编写两个for循环。第一个 for 循环是一个小循环遍历m个训练样本，第二个 for 循环是一个遍历所有特征的 for 循环。这个例子中我们只有 2 个特征，所以$n$等于 2 并且$n_x$ 等于 2。 但如果你有更多特征， 你开始编写你的因此$d{w}_1$，$d{w}_2$，相似的计算一直下去到$d{w}_{n_x}$。所以看来你需要一 个 for 循环遍历所有n个特征。

2.11向量化表达(Vectorization)

假设有这么一个python的$for$循环

z=0
for i in range(n_x):
 	z+=w[i]*x[i] 
 	z+=b

这样计算会很慢,但是用向量化表达则计算会很快

import numpy as np
import time
n = 1000000
w = np.random.rand(n).reshape(n,1)
x = np.random.rand(n).reshape(n,1)#通过 round 随机得到两个一百万维度的数组

z=0
t1 = time.time()
for i in range(n_x):
   z+=w[i]*x[i]
   
t2 = time.time()
print(z,'using time "%s"ms.'%((t2-t1)*1000))

[ 249835.28710158] using time "4013.7579441070557"ms.

t3 = time.time()
zz = np.dot(w.T,x) #使用向量化表达之后
t4 = time.time()
print(zz,'using time "%s"ms.'%((t4-t3)*1000))

[[ 249835.28710159]] using time "0.8718967437744141"ms.

2.13向量化逻辑回归(Vectorizing Logistic Regression)

• 首先我们回顾一下逻辑回归的前向传播步骤:
  如果你有 $m$ 个训
  练样本，然后对第一个样本进行预测,计算 $z$，公式$z^{(1)}=w^T{x}^1+b$。然后计算激活函数 $a^{(1)}=\sigma (z^{(1)})$，计算第一个样本的预测值 ${\hat{y}}^{(1)}$。 然后对第二个样本进行预测，需要计算$z^{(2)}=w^T{x}^2+b$ ，$a^{(2)}=\sigma (z^{(2)})$ 。然后对第三个样本进行预测，需要计算 $z^{(3)}=w^T{x}^3+b$ ， $a^{(3)}=\sigma (z^{(3)})$ ，依次类推。如 果你有 m 个训练样本，则需要这样做 m 次，这样太耗时。

• 下面介绍向量化的编程方法：
  
  核心思想是：向量化赋值，向量化运算
  第$i$个个体的属性值构成的列向量：
  $$x^{(i)}=\left(\begin{array}{c}{x}_{(1)}^{(i)}\\ x_{(2)}^{(i)}\\ ⋮\\ x_{(n_x)}^{(i)}\end{array}\right)\text{\hspace{1em}(2.13.1)}$$
  m个$x^{(i)}$构成X矩阵：
  $$\text{X}={\left(\begin{array}{c}{x}^{(1)},x^{(2)},\dots ,x^{(m)}\end{array}\right)}_{(n_x,m)}\text{\hspace{1em}(2.13.2)}$$
  参数向量$w$是一列$n_x$维的列向量：
  $$w={\left(\begin{array}{c}{w}_1\\ w_2\\ ⋮\\ w_m\end{array}\right)}_{(n_x,1)}\text{\hspace{1em}(2.13.3)}$$
  $$z^{(i)}=w^T{x}^{(i)}+b\text{\hspace{1em}(2.13.4)}$$
  m个$z^{(i)}$构成的行向量：
  $$Z=\left(\begin{array}{c}{z}^{(1)},z^{(2)},\cdots ,z^{(m)}\end{array}\right)\text{\hspace{1em}(2.13.5)}$$
  求$Z$只需要一行代码：Z = np.dot(w.T,b)
  A为$\sigma (Z)$是一个m维的行向量：
  $$A=\sigma (Z)=\left(\begin{array}{c}{a}^{(1)},a^{(2)},\cdots ,a^{(m)}\end{array}\right)\text{\hspace{1em}(2.13.5)}$$

2.14 向量化Logistic回归的梯度(Vectorizing Logistic Regression’s Gradient)

第一个个体的损失函数$L^{(1)}$对$z^{(1)}$的偏导数： $\frac{d{L}^{(1)}}{d{z}^{(1)}}=a^{(1)}-y^{(1)}\widehat{=}d{z}^{(1)}$
第二个个体的损失函数$L^{(2)}$对$z^{(2)}$的偏导数： $\frac{d{L}^{(2)}}{d{z}^{(2)}}=a^{(2)}-y^{(2)}\widehat{=}d{z}^{(2)}$
$\dots$
第m个个体的损失函数$L^{(m)}$对$z^{(m)}$的偏导数： $\frac{d{L}^{(m)}}{d{z}^{(m)}}=a^{(m)}-y^{(m)}\widehat{=}d{z}^{(m)}$
$Y=(y^{(1)},y^{(2)},\cdots ,y^{(m)})$
$dZ$是一个m维的行向量，
$$dZ=A-Y=(d{z}^{(1)},d{z}^{(2)},\cdots ,d{z}^{(m)})$$

$$dw=\frac{1}{m}\cdot X\cdot (dZ{)}^T$$

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

$dZ,dw,db$的定义沿用2.9节中所述。
则向量化的一次梯度更新的python代码流程为：

Z = np.dot(w.T, X) + b
A = sigma(Z)
dZ = A - Y
dw = (1/m)*X*(dZ).T
db = (1/m)*np.sum(dZ)
w = w - a * dw
b = b - a * db

最后在此基础上来个for循环m次，作m次梯度更新。

2.18 Logistic损失函数的来由(Explanation of Logistic Regression cost function)（待深入探究）

在逻辑回归中，需要预测的结果$\hat{y}$可以表示为$\hat{y}=\sigma (w^{T}x+b)$,$\sigma$是我们熟悉的S型曲线$\sigma (z)=\sigma (w^{T}x+b)=\frac{1}{1+e^{-z}}$。约定$\hat{y}=p(y=1|x)$，即算法的输出$\hat{y}$是给定训练样本个体$x$条件下$y=1$的概率。即：
如果$y=1$，在给定训练个体$x$条件下算出的概率为$\hat{y}$:

$$Ify=1:p(y|x)=\hat{y}\text{\hspace{1em}(2.18.1)}$$
如果$y=0$，在给定训练个体$x$的条件下算出的概率为$1-\hat{y}$:
$$Ify=0:p(y|x)=1-\hat{y}\text{\hspace{1em}(2.18.2)}$$
整合$(2.18.1)$和$(2.18.2)$两个式子得：
$$P(y|x)={\hat{y}}^y\cdot (1-\hat{y}{)}^{1-y}\text{\hspace{1em}(2.18.3)}$$

两边同时取对数：
$$LnP(y|x)=yln\hat{y}+(1-y)ln(1-\hat{y})\text{\hspace{1em}(2.18.4)}$$
由于log函数是严格单调递增的，最大化$lnP(y|x)$等价于最大化$P(y|x)$并且计算$P(y|x)$的对数，就是计算$lnP(y|x)$，即$(2.18.4)$式。
$(2.18.4)$就是前文提到的损失函数的负数，即$-L(\hat{y},y)$。有个负号的原因是，当我们训练学习算法时要以最大的概率预测这个值，然而在逻辑回归中我们需要最小化损失函数。