第二周：神经网络基础

本文是神经网络和深度学习课程的笔记。

2.1 二分分类

• Logistic Regression
• 目的：属于A，还是不属于A
• 记号：
  • 输入一个三通道的彩色图片：$n_x=3\ast 64\ast 64$输入单个样本向量的维度
    $$\left[\begin{array}{c}{x}_1\\ ⋮\\ x_{n_x}\end{array}\right]$$
  • $m_{train}$训练样本个数，有时候简记为m。每个样本（向量）为$x^i$。
  • $m_{test}$测试集样本个数
  • 记$X\in {\mathbb{R}}^{n_x\times m}=\left[\begin{array}{ccc}{x}^1& \dots & x^{m_{train}}\end{array}\right]$
  • 记$Y\in {\mathbb{R}}^{1\times m_{train}}=\left[\begin{array}{ccc}{y}^1& \dots & y^{m_{train}}\end{array}\right]$

2.2 Logistic Regression

• 目的:
  • 给定x，期望输出$\hat{y}=\mathbb{P}(y=1|x),x\in {\mathbb{R}}^{n_x}$
  • 参数:$w\in {\mathbb{R}}^{n_x},b\in \mathbb{R}$,这里是把常数项分开，这样方便编写代码。
• 一个简单的想法：
  • $\hat{y}=w^{T}x+b$
  • 这个不行，因为我们希望$\hat{y}$是一个0到1中的概率
• 因此，我们加了一个sigmoid函数，将值域映射到0到1中。
  • $\hat{y}=\sigma (w^{T}x+b)$其中$\sigma (z)=\frac{1}{1+e^{-z}}$

2.2 Logistic Regression cost function

• 目的：
  • $min(\hat{y},y)$
  • ${\hat{y}}^{(i)}=\sigma (w^T{x}^{(i)}+b)$其中$\sigma (z^{(i)})=\frac{1}{1+e^{-z^{(i)}}}$
  • i表示第i个样本

损失函数(Loss function): L

• 对于逻辑回归，为了将最终的问题变成一个凸的问题，以方便进行梯度下降，我们不再使用传统的MSE损失，而选择交叉熵损失函数：⚠️ 损失函数是对于一个样本而言的。
  $$L(\hat{y},y)=-(y\times log(\hat{y})+(1-y)\times log(1-\hat{y}))$$
  • 一个简单的分析： （为什么最小化L可以实现$min(\hat{y},y)$）
  • y=1：$L(\hat{y},y)=-log(\hat{y})$，我们希望损失函数越小越好，所以$\hat{y}$越大越好。鉴于sigmoid函数的值域为[0,1] 。所以$\hat{y}$为1。
  • y=0：$L(\hat{y},y)=-log(1-\hat{y})$，我们希望损失函数越小越好，所以$\hat{y}$越小越好。鉴于sigmoid函数的值域为[0,1] 。所以$\hat{y}$为0。

成本函数(Cost function): J

$$J(w,b)=\frac{1}{m_{train}}\sum _{i=1}^{m_{train}}L({\hat{y}}^{(i)},y^{(i)})=-\frac{1}{m_{train}}\sum _{i=1}^{m_{train}}[y^{(i)}log({\hat{y}}^{(i)})+(1-y^{(i)})log(1-{\hat{y}}^{(i)})]$$
它是作用在整个数据集上的，我们的目的是最小化J。

2.4 Gradient Descent

• Recap
  • $J(w,b)=-\frac{1}{m}{\sum }_{i=1}^m[y^{(i)}log({\hat{y}}^{(i)})+(1-y^{(i)})log(1-{\hat{y}}^{(i)})]$
  • $\hat{y}=\sigma (w^{T}x+b),\sigma (z)=\frac{1}{1+e^{-z}}$
  • 因为J是Convex，所以无论初始化在哪都可以找到最小值。
• 参数更新:
  • $w=w-\alpha \times dw$其中$dw=\frac{\partial J(w,b)}{\partial w}$
  • $b=b-\alpha \times db$其中$db=\frac{\partial J(w,b)}{\partial b}$

2.7/2.8 Computation Graph 计算图及其导数计算

• 例子：$J(a,b,c)=3\times (a+bc)$

• $\frac{dJ}{dv}=3$
• $\frac{dJ}{da}=3$
• 感觉是⚠️ ⚠️ $上一层梯度\times \frac{\partial 上一层变量}{\partial 当前层变量}$
• $\frac{dFinalOutputVar}{dvar}$在程序里，我们用"dvar"表示
  

2.9 Logistic Regression Gradient Descent

• Recap:
  $z=w^{T}x+b$
  $\hat{y}=a=\sigma (z)$
  $L(a,y)=-(ylog(a)+(1-y)log(1-a))$
  对于一个参数的更新，看Loss Function $L$，其实有上标(i)。
  

2.10 Logistic regression on $m$ examples

这里我们给出一种用for循环的，比较低效的方法。

对于m个样本权重的更新，我们需要考虑Cost Function $J$。

• Recap:
  $J(w,b)=\frac{1}{m}{\sum }_{i=1}^{m}L(a^{(i)},y^{(i)})$，其中$a=\hat{y}$

• 依旧使用梯度下降:
  $\frac{\partial J(\mathbf{w},b)}{\partial w_1}=\frac{1}{m}{\sum }_{i=1}^m\frac{\partial L(a^{(i)},y^{(i)})}{\partial w_1^{(i)}}$，注意到求和里面的每一项就是我们前面的$dw1=({\hat{y}}^{(i)}-y^{(i)})\times x_1^{(i)}$,所以可以用上面的公式依次求出来。

• ⚠️具体的算法:
  

• Rq:

1. 这里成本比较麻烦，因为如果我们有n个特征，需要手动输入$d{w}_1,...,d{w}_n$。
   Sol：向量化计算，用来摆脱for循环。

2.11 向量化

我们可以证明，如果使用向量乘法，要比普通的用for循环的速度更加快。

import numpy as np
import time
a = np.random.rand(10000000)
b = np.random.rand(10000000)

t0 = time.time()
c = np.dot(a,b);
t1 = time.time()
print(c)
print(f"Vectorization Version:{1000*(t1-t0)} ms")

t0 = time.time()
c=0
for i in range(len(a)):
    c+=a[i]*b[i]
t1 = time.time()
print(c)
print(f"For Loop Version:{1000*(t1-t0)} ms")

输出：

2499542.3991724537
Vectorization Version:9.550094604492188 ms
2499542.3991726325
For Loop Version:8469.129085540771 ms

• jupyter notebook上只用CPU
• GPU和CPU都有并行化指令(parallelization instructions),SIMD(Single Instruction Multiple Data，单指令流多数据流)。

2.12 More Vectorization Examples

• $\mathbf{u}=\mathbf{A}\mathbf{v}$
• np.exp(),np.abs(),np.maximum(),v**2【对于逐个元素计算】
• 想法：numpy中的函数都有优化，能用numpy中的函数就不要用for loop。

对于Logistic Regression的初步Vectorization，见ipad，可以直接改上面那幅图。

2.13 / 2.14 Vectorizing Logistic Regression

正向传播向量化

• Recap:
  $z^{(1)}=w^T{x}^{(1)}+b,z^{(2)}=w^T{x}^{(2)}+b,z^{(3)}=w^T{x}^{(3)}+b$
  $a^{(1)}=\sigma (z^{(1)}),a^{(2)}=\sigma (z^{(2)}),a^{(3)}=\sigma (z^{(3)})$
• 向量化：
  • 引入$\mathbf{X}=[x^{(1)},\dots ,x^{(m)}]\in {\mathbb{R}}^{n_x\times m}$其中有m个样本,每个样本有$n_x$个特征。
  • $w\in {\mathbb{R}}^{n_x\times 1}$
  • $\mathbf{Z}=[z^{(1)},\dots ,z^{(m)}]$,$\mathbf{Z}=w^T\mathbf{X}+b$
  • $\mathbf{A}=[a^{(1)},\dots ,a^{(m)}]=\sigma (\mathbf{Z})$
• 具体实现：(利用了python里面的broadcasting)

 z = np.dot(w.T,x)+b // Brodcasting,因为b是一个实数

反向传播向量化

• Recap:
  • $d{z}^{(1)}=a^{(1)}-y^{(1)},\dots ,d{z}^{(m)}=a^{(m)}-y^{(m)}$
  • $dw\in {\mathbb{R}}^{n_x\times 1}$:
    • $dw+=x^{(1)}d{z}^{(1)},...,dw+=x^{(m)}d{z}^{(m)}$
    • $dw/=m$
  • $db$:
    • $db+=d{z}^{(1)},...,db+=d{z}^{(m)}$
    • $db/=m$
• 向量化：
  • 在正向传播中，我们已经计算了 $\mathbf{A}=[a^{(1)},\dots ,a^{(m)}]=\sigma (\mathbf{Z})$
  • 我们又已知$\mathbf{Y}=[y^{(1)},...,y^{(m)}]$是m个样本对应的目的的标签
  • 所以，通过引入⚠️ $dz=[d{z}^{(1)},\dots ,d{z}^{(m)}]=\mathbf{A}-\mathbf{Y}\in {\mathbb{R}}^{m\times 1}$
  • 因此 ⚠️ $db=np.sum(dz)/m$
  • ⚠️ $dw=\frac{1}{m}\mathbf{X}d{z}^T$
  • $$dw=\frac{1}{m}\left[\begin{array}{ccc}{x}^{(1)}& \dots & x^{(m)}\end{array}\right]\left[\begin{array}{c}d{z}^{(1)}\\ ⋮\\ d{z}^{(m)}\end{array}\right]=\frac{1}{m}[x^{(1)}d{z}^{(1)}+\cdots +x^{(m)}d{z}^{(m)}]\in {\mathbb{R}}^{n_x\times 1}$$

具体实现：

• 对于n次梯度下降还是得外部加一个循环。

#参数
eta=0.1 #学习率
# 对于np.array可以直接运行的sigmoid函数
def sigmoid(t):
    return 1/1+np.exp(-t)
    
#对于m个样本
Z = np.dot(w.T,X)+b
A = sigmoid(Z)
dz = A-Y
dw = np.dot(X,dz.T)/m
db = np.sum(dz)/m
w = w - dw*eta
b = b - db*eta

2.15 Broadcasting in Python

• 例子:

tmp1 = 
 [[1 2 3]
 [4 5 6]]
tmp2 = 
 [[100 200 300]]
tmp1 + tmp2 = 
 [[101 202 303]
 [104 205 306]]

tmp1 = 
[[1 2 3]
[4 5 6]]
tmp2 = 
[[100]
[200]]
tmp1 + tmp2 = 
[[101 102 103]
[204 205 206]]

• 规则：
  (m,n) + (1,n): 水平复制m次 -> 得到(m,n)
  (m,n) + (m,1): 竖直复制n次 -> 得到(m,n)

2.16 A note on python / numpy vectors

• 不要用(5,)矩阵，因为它们在做外积的时候有可能会得到奇怪的结果
• 解决方案：
  • .reshape()
  • assert(a.shape==(5,1)): 运行速度比较快，如果shape不对会报错AssertionError。
• 例子：

a = np.random.randn(5)
print(a)
# (5,)是秩为1的矩阵，它既不是行向量，也不是列向量
print(a.shape)
assert(a.shape==(5,1)) #这里会报错
print(a.T) #这里只有一个括号
print(np.dot(a,a.T)) #是一个数字！！
# 解决方案 (或者reshape)
a = np.random.randn(5,1)
print(a.shape)
print(a.T) #这里有2个括号
print(np.dot(a,a.T)) #不是一个数字！！

2.17 Explanation of logistic regression cost function

Loss Function的由来

实际上我们有一定取巧的成分，因为是二分类问题，所以我们令两个类别对应的值为0和1。
-如果 y=1: $p(y|x)=\hat{y}$
-如果 y=0: $p(y|x)=1-\hat{y}$
换句话说我们估计的参数就是$\hat{y}$。如果在指定样本下，我们计算出$\hat{y}=0.75$，则y=1的概率越高。

• 因此，在样本x，预计标签y的前提下，$$p(y|x)={\hat{y}}^y\times (1-\hat{y}{)}^{(1-y)}$$即当y=1，预测成功概率为$p(y=1|x)=\hat{y}$。所以上式给出了预测正确的概率。我们希望它越大越好。
• 为此，我们考虑$$L(\hat{y},y)=-log(p(y|x))=-(ylog(\hat{y})+(1-y)log(1-\hat{y}))$$也就是我们常见的交叉熵损失函数。

Cost Function的由来

如果考虑m个样本，则m个样本都预测正确的概率
$$\mathbb{P}={\Pi }_{i=1}^{m}p(y^{(i)}|x^{(i)})$$
同样，引入对数似然之后，我们得到了Cost Function
$$J(w,b)=\frac{1}{m}\sum _{i=1}^{m}L({\hat{y}}^{(i)},y^{(i)})$$
正如我们希望损失函数越小越好，我们的目的是最小化Cost Function。

测验中要点：

1. 区别np.dot和*。

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)
d = a*b #会报错