deeplearning.ai课程C1W2

神经网络的计算过程分为两步：

• 前向传播（forward propagation）：计算预测值（和代价函数）
• 后向传播（backward propagation）：计算导数（链式法则），更新参数

下面以逻辑回归为例，说明该计算过程。

二分类（binary classification）

• 例如，一张图片中是否有猫，二分类的结果就是0（没有）或者1（有）。
• 二分类的目的是训练一个分类器，以图片的特征向量作为输入，输出则是判断有猫或者没有。一般图片都是用RGB三通道表示，所以片的特征向量可以是三个通道的像素值组成的向量。

符号约定

• $x$：一个$n_x$维的向量，表示输入数据，维度是 ${(n_x, 1)}$
• $y$：表示输出结果，二分类中的取值是$(0, 1)$
• $\hat{y}$：表示预测值
• ${(x^{(i)}, y^{(i)})}$：表示第$i$组数据，默认是训练数据
• ${X = [x^{(1)}, x^{(2)},..., x^{(m)}]}$：表示训练数据集，维度是$(n_x, m)$，$m$是样本数
• ${Y = [y^{(1)}, y^{(2)},..., y^{(m)}]}$：表示训练数据集对应的输出值集合，维度是$(1, m)$

逻辑回归（logistic regression）

• 逻辑回归是一个用于二分类的算法。按照上述符号约定，逻辑回归可以表述为：
  Given $x$，want $\hat{y}$ = ${P(y=1 | x)}$ = $\sigma$(${w^{T}x+b}$)
• 上述线性组合计算出得取值范围太大，使用sigmoid函数($\sigma$)可以把值约束在[0, 1]之内。sigmoid函数的波形如下：

逻辑回归的代价函数（cost function）

• 损失函数（Loss function），也就是误差函数。逻辑回归中使用以下函数：${L(y, \hat{y}) = -ylog(\hat{y}) - (1-y)log(1-\hat{y})}$
  
  • 如果$y=0$, ${L(y, \hat{y}) = -log(1-\hat{y})}$。$\hat{y}$接近0，损失函数才会接近0。
  • 如果$y=1$, ${L(y, \hat{y}) = -log(\hat{y})}$。$\hat{y}$接近1，损失函数才会接近0。
• 代价函数就是m个样本的损失函数求和取均值，$J(w, b) = \frac{1}{m}{\sum_{i=0}^{m}L(y^{(i)}, \hat{y}^{(i)}) = \frac{1}{m}\sum_{i=0}^{m}(-y^{(i)}log(\hat{y}^{(i)}) - (1-y^{(i)})log(1-\hat{y}^{(i)}))}$
• 损失函数只适用于像这样的单个训练样本，而代价函数是参数的总代价，所以在训练逻辑回归模型时候，我们需要找到合适的$w$和$b$，来让代价函数 $J$ 的总代价降到最低。

梯度下降法（Gradient descent）

• 梯度下降法的思路很简单：沿着梯度下降的方向更新参数，直至收敛到最小点。

• 以代价函数为例：
  ${w = w - \alpha\frac{\partial J(w, b)}{\partial w}}$
  ${b = b - \alpha\frac{\partial J(w, b)}{\partial b}}$

• 其中，$\alpha$是学习速率，控制梯度下降的速率。

• 符号约定：$d[var] = \frac{d[FinalOutputVar]}{d[var]}$，$d[var]$表示最终的输出FinalOutputVar（通常是代价函数）对变量var的导数

计算图（Computation Graph）

• 计算图可以辅助正向传播和反向传播的计算。
• 以函数 ${J = 3(a+bc)}$ 为例，计算图如下，顺着蓝色箭头可以计算出正向传播的输出。反之，顺着橙色箭头，可以计算反向传播。
  
  • 假设 $a=5, b=3, c=2$
  • 正向传播：$u=6, v=11, J=33$
  • 反向传播（求导的链式法则）：$dv=3, du=1*dv=3, da=1*dv=3,db=c*du=6,dc=b*du=9$

逻辑回归中的梯度下降

• 回顾一下逻辑回归的计算过程，暂时只考虑一个样本的情况：
  $z = w^{T}x+b$
  $a = \hat{y} = \sigma(z)$
  $L(a, y) = -ylog(a)-(1-y)log(1-a)$
• 假设输入只有2个特征，$x$和$w$只有两个元素，逻辑回归的计算图如下：

• 计算反向传播的过程：
  $da = \frac{dL(a, y)}{da} = -\frac{y}{a}+\frac{1-y}{1-a}$
  $dz = \frac{dL(a, y)}{dz} = \frac{dL(a, y)}{da}\frac{da}{dz} = (-\frac{y}{a}+\frac{1-y}{1-a})*(a(1-a)) = a-y$
  $dw_1 = \frac{\partial L(a, y)}{\partial w_1} = x_1 * dz = x_1 * (a-y)$
  $dw_2 = \frac{\partial L(a, y)}{\partial w_2} = x_2 * dz = x_2 * (a-y)$
  $db = dz = a-y$
• 更新参数：
  $w_1 = w_1 - \alpha * dw_1 = \alpha * x_1 * (a - y)$
  $w_2 = w_1 - \alpha * dw_2 = \alpha * x_2 * (a - y)$
  $b = w_1 - \alpha * db = \alpha * (a - y)$
• 扩展到m个样本的逻辑回归：
  $J(w, b) = \frac{1}{m}\sum_{i=0}^{m}L(a^{(i)}, y^{(i)})$
  $a^{(i)} = \hat{y^{(i)}} = \sigma(z^{(i)})$
  $z^{(i)} = w^{T}x^{(i)}+b$
  $dw_1 = \frac{\partial J(w, b)}{\partial w_1} = \frac{1}{m}\sum_{i=0}^{m}\frac{\partial L(a^{(i)}, y^{(i)})}{\partial w_1} = \frac{1}{m}\sum_{i=0}^{m}x_1^{(i)}*(a^{(i)}-y^{(i)})$
  $dw_2 = \frac{\partial J(w, b)}{\partial w_2} = \frac{1}{m}\sum_{i=0}^{m}\frac{\partial L(a^{(i)}, y^{(i)})}{\partial w_2} = \frac{1}{m}\sum_{i=0}^{m}x_2^{(i)}*(a^{(i)}-y^{(i)})$
  $db = \frac{\partial J(w, b)}{\partial b} = \frac{1}{m}\sum_{i=0}^{m}\frac{\partial L(a^{(i)}, y^{(i)})}{\partial b} = \frac{1}{m}\sum_{i=0}^{m}(a^{(i)}-y^{(i)})$
• 上述过程可以用一下算法实现：
  $J=0; dw_1=0, dw_2=0; db=0$
  $For　i=1　to　m$
  　　$z^{(i)} = w^{T}x^{(i)}+b$
  　　$a^{(i)} = \sigma(z^{(i)})$
  　　$J += -y^{(i)}log(a^{(i)}) - (1-y^{(i)})log(1-a^{(i)})$
  　　$dz^{(i)} = a^{(i)} - y^{(i)}$
  　　$dw_1 += x_1^{(i)}dz^{(i)}$
  　　$dw_2 += x_2^{(i)}dz^{(i)}$
  　　$db += dz^{(i)}$
  $J = \frac{J}{m}$
  $dw_1 = \frac{dw_1}{m}; dw_2 = \frac{dw_2}{m}; db = \frac{db}{m}$
  $w_1 = w_1 - \alpha dw_1$
  $w_2 = w_2 - \alpha dw_2$
  $b = b - \alpha db$
• 上述算法只考虑了两个特征，事实上很容易扩展到$n_x$个特征，在此不做赘述。
• 上述算法在计算的时候会出现多个循环：$n_x$个特征、$m$个样本、以及若干次的迭代，这会导致算法计算耗时太长，性能堪忧，通常用向量化来减少循环。

向量化

• python中的numpy提供了很高效的矩阵运算操作，所谓的向量化就是把循环操作转换为矩阵运算，提高计算效率。
• 下面的例子比较了循环运算和numpy中矩阵运算的性能。

import numpy as np
import time

a = np.random.rand(1000000)
b = np.random.rand(1000000)

tic = time.time()
c = np.dot(a, b)
toc = time.time()

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

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

print(c)
print("for loop: " + str(1000*(toc-tic)) + " ms")

249937.82455119357
Vectorized version: 1.0001659393310547 ms
249937.82455119127
for loop: 479.9354076385498 ms

逻辑回归的向量化

• 对于$m$各样本的逻辑回归，把$m$个样本横向扩展为一个矩阵：
  $X = [x^{(1)}, x^{(2)},..., x^{(m)}]$
  $Z = [z^{(1)}, z^{(2)},..., z^{(m)}] = w^{T}X+b = np.dot(w.T, X)+b$
  $A = [a^{(1)}, a^{(2)},..., a^{(m)}] = \sigma(Z)$
• 这样，一次逻辑回归的向量化形式可以表示为：
  $Z = w^{T}X+b = np.dot(w.T, X)+b$
  $A = \sigma(Z)$
  $dZ = A-Y$
  $dw = \frac{1}{m}*X*dZ^{T}$
  $db = \frac{1}{m}*np.sum(dZ)$
  $w = w - \alpha*dw$
  $b = b - \alpha*db$