第一门课：神经网络和深度学习（第二周）——神经网络的编程基础

1. 二分类

• 什么是二分类问题呢——举个栗子，给你一张图片，判断图片中动物是不是猫？
  

对于图像处理问题，每个图片由很多像素点组成。所以图片的特征向量是3通道的RGB矩阵，我们将其展平作为一个特征输入向量$x$。

约定一些符号：
$x$：表示一个$n_x$维数据，为输入数据，维度为($n_x$，1)；
$y$：表示输出结果，取值为(0，1)；
($x^i$，$y^i$)：表示第 $i$ 组数据，可能是训练数据，也可能是测试数据，此处默认为训练数据；

$X=[x^{(1)},x^{(2)},...,x^{(m)}]$：表示所有的训练数据集的输入值，放在一个 $n_x\times m$的矩阵中，其中$m$表示样本数目;
$Y=[y^{(1)},y^{(2)},...,y^{(m)}]$：对应表示所有训练数据集的输出值，维度为$1\times m$。

2. 逻辑回归

对于二元分类问题来讲，给定一个输入特征向量$X$，它可能对应一张图片，你想识别图片内容是否为一只猫，你需要算法能够输出预测$\hat{y}$，$\hat{y}$ 表示 $y$ 等于1的一种可能性或者是概率。

前提条件给定了输入特征$X$，$X$是一个$n_x$维的向量（相当于有$n_x$个特征的特征向量）。我们用$w$来表示逻辑回归的参数，这也是一个$n_x$维向量（因为$w$是特征权重，维度与特征向量相同），参数里面还有$b$，这是一个表示偏差的实数。

所以给出输入$x$以及参数$w$和$b$之后，我们怎样产生输出预测值$\hat{y}$?
$\hat{y}=w^{T}x+b$ 这样么? 答案是否定的。

我们需要借助sigmoid函数，令 $\hat{y}=\sigma \left(z\right)=\frac{1}{1+e^{-z}}$，其中$z=w^{T}x+b$。
我认为此定义原因如下：1. 为了便于解释$\hat{y}$存在的意义，以概率形式出现更易于接受；2. 为了便于接下来代价函数的提出和理解。

3. 逻辑回归的代价函数

为了衡量一个算法在模型上的表现并以此作为优化的依据，我们需要一个代价函数。在逻辑回归中，我们需要通过训练代价函数来得到优化后的参数$w$和参数$b$。

Loss function：$L\left(\hat{y},y\right)=-(y\log (\hat{y})+(1-y)\log (1-\hat{y}))$，交叉熵损失函数，常用于二分类问题。

• 所有的样本的损失函数的平均值
  $$J(w,b)=\frac{1}{m}\sum _{i=1}^{m}L\left({\hat{y}}^{(i)},y^{(i)}\right)=-\frac{1}{m}\sum _{i=1}^m\left[y^{(i)}\log \left({\hat{y}}^{(i)}\right)+\left(1-y^{(i)}\right)\log \left(1-{\hat{y}}^{(i)}\right)\right]$$

目标就是找到合适的参数，使得代价函数最小化

4. 梯度下降法

如何寻找合适的 $w,b$ 使得代价函数最小呢?
迭代的过程中，不断的在各参数的偏导数方向上更新参数值, $\alpha$ 是学习率
$$\begin{array}{rl}& w:=w-\alpha \frac{\partial J(w,b)}{\partial w}\\ & b:=b-\alpha \frac{\partial J(w,b)}{\partial b}\end{array}$$

5. 导数

导数定义：函数在某一点的斜率，在不同的点，斜率可能是不同的。

6. 计算图的导数计算

链式求导法则：

7. 逻辑回归中的梯度下降(※)

假设函数和损失函数：
$$\begin{array}{rl}& z=w^{T}x+b\\ & \hat{y}=a=\sigma (z)\\ & \mathcal{L}(a,y)=-(y\log (a)+(1-y)\log (1-a))\end{array}$$
sigmoid 函数： $f(z)=\frac{1}{1+e^{-z}}$
sigmoid 求导:
$$\begin{array}{rl}f(z{)}^{{}^{\prime }}=\frac{\partial f(z)}{\partial z}& =\frac{-1\ast -1\ast e^{-z}}{{\left(1+e^{-z}\right)}^2}\\ & =\frac{e^{-z}}{{\left(1+e^{-z}\right)}^2}\\ & =\frac{1+e^{-z}-1}{{\left(1+e^{-z}\right)}^2}\\ & =\frac{1}{1+e^{-z}}-\frac{1}{{\left(1+e^{-z}\right)}^2}\\ & =\frac{1}{1+e^{-z}}\left(1-\frac{1}{1+e^{-z}}\right)\\ & =f(z)(1-f(z))\end{array}$$

求导过程：
$$\begin{array}{rl}\frac{\partial \mathcal{L}}{\partial a}& =-\frac{y}{a}+\frac{1-y}{1-a}\text{ named }"da"\\ \frac{\partial \mathcal{L}}{\partial z}& =\frac{\partial \mathcal{L}}{\partial a}\frac{\partial a}{\partial z}=\left(-\frac{y}{a}+\frac{1-y}{1-a}\right)\ast a(1-a)=a-y\text{ named }"dz"\\ \frac{\partial \mathcal{L}}{\partial w_1}& =\frac{\partial \mathcal{L}}{\partial z}\frac{\partial z}{\partial w_1}=x_1(a-y)\text{ named }"d{w}_1"\\ \frac{\partial \mathcal{L}}{\partial w_2}& =\frac{\partial \mathcal{L}}{\partial z}\frac{\partial z}{\partial w_2}=x_2(a-y)\text{ named }"d{w}_2"\\ \frac{\partial \mathcal{L}}{\partial b}& =\frac{\partial \mathcal{L}}{\partial z}\frac{\partial z}{\partial b}=a-y\text{ named }"db"\end{array}$$
迭代更新：
$$\begin{array}{rl}{w}_1:& =w_1-\alpha \ast d{w}_1\\ w_2:& =w_2-\alpha \ast d{w}_2\\ b:& =b-\alpha \ast db\end{array}$$

8. m个样本的梯度下降

假设有m个样本，每个样本有2个特征

// 伪代码 from http://www.ai-start.com/dl2017/html/lesson1-week2.html
J=0; dw1=0; dw2=0; db=0;
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);
    dw1 += x1(i)dz(i); // 全部样本的梯度累加
    dw2 += x2(i)dz(i);
    db += dz(i);
    
// 求平均值
J /= m;
dw1 /= m;
dw2 /= m;
db /= m;

// 更新参数 w, b
w = w - alpha*dw
b = b - alpha*db

显式的使用 for 循环是很低效的，要使用向量化技术加速计算速度。

9. 向量化

使用 numpy 等库实现向量化计算，效率更高

import numpy as np #导入numpy库
a = np.array([1,2,3,4]) #创建一个数据a
print(a)
# [1 2 3 4]
import time #导入时间库
a = np.random.rand(1000000)
b = np.random.rand(1000000) #通过round随机得到两个一百万维度的数组

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')#打印for循环的版本的时间

上面例子，向量化计算快了600多倍

250241.79388712568
Vectorized version:0.9975433349609375ms
250241.7938871326
For loop:687.734842300415ms

10. 向量化的更多例子

J=0; db=0;
dw = np.zeros((nx,1)) // numpy向量化
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);
    dw += x(i)dz(i); // 向量化，全部样本的梯度累加
    db += dz(i);
    
// 求平均值
J /= m;
dw /= m;// 向量化
db /= m;

// 更新参数 w, b
w = w - alpha*dw
b = b - alpha*db

这样就把内层的 $d{w}_1,...d{w}_n$ 的计算使用向量化了，只用1层 for 循环，还可以做的更好，往下看。

11. 向量化 logistic 回归

逻辑回归前向传播步骤：

• 对每个样本进行计算
  $$z^{(1)}=w^T{x}^{(1)}+b$$
• 计算激活函数，得到预测值$\hat{y}$
  $$a^{(1)}=\sigma (z^{(1)})$$
  

可以使用 numpy 来计算：

• $Z=np.dot(w^T,X)+b$，+ b 会对每个元素操作，是 numpy 的广播机制。
• $A=\left[a^{(1)}{a}^{(2)}\dots a^{(m)}\right]=\sigma (Z)$

这样就没有显式使用 for 循环，计算非常高效。

12. 向量化 logistic 回归梯度输出

$$\begin{array}{rl}Z& =w^{T}X+b=np\cdot \mathrm{dot}(w.T,X)+b\\ A& =\sigma (Z)\\ dZ& =A-Y\\ dw& =\frac{1}{m}\ast X\ast d{Z}^T\\ db& =\frac{1}{m}\ast np.\mathrm{sum}(dZ)\\ w:& =w-a\ast dw\\ b:& =b-a\ast db\end{array}$$

非向量化、向量化对比：

这样就向量化的计算，完成了逻辑回归的 1 次迭代，要完成 n_iter 次迭代就在外层加一层 for 循环，这个 for 是省不了的。

13. numpy 广播机制

import numpy as np

A = np.array([
    [56, 0, 4.4, 68],
    [1.2, 104, 52, 8],
    [1.8, 135, 99, 0.9]
])

cal = A.sum(axis=0)  # 按列求和
print(cal)

percentage = 100 * A / cal.reshape(1, 4)
print(percentage)

[ 59.  239.  155.4  76.9]
[[94.91525424  0.          2.83140283 88.42652796]
 [ 2.03389831 43.51464435 33.46203346 10.40312094]
 [ 3.05084746 56.48535565 63.70656371  1.17035111]]

注：axis指明运算 沿着哪个轴执行，在numpy中，0轴是垂直的，也就是列，而1轴是水平的，也就是行。

• 例1

A = np.array([[1, 2, 3, 4]])
b = 100
print(A+b)

[[101 102 103 104]]

• 例2

A = np.array([[1, 2, 3],
              [4, 5, 6]])
B = np.array([100, 200, 300])
print(A+B)

[[101 202 303]
 [104 205 306]]

• 例3

A = np.array([[1, 2, 3],
              [4, 5, 6]])
B = np.array([[100], [200]])
print(A + B)

[[101 102 103]
 [204 205 206]]

• 广播机制与执行的运算种类无关
  

14. 关于 python / numpy 向量的说明

• 总是使用 nx1 维矩阵（列向量），或者 1xn 维矩阵（行向量）；
• 为了确保所需要的维数时，不要羞于 reshape 操作。