01.神经网络和深度学习 W2.神经网络基础

文章目录

1. 二分类
2. 逻辑回归
3. 逻辑回归损失函数
4. 梯度下降
5. 导数
6. 计算图导数计算
7. 逻辑回归中的梯度下降
8. m个样本的梯度下降
9. 向量化
10. 向量化的更多例子
11. 向量化 logistic 回归
12. 向量化 logistic 回归梯度输出
13. numpy 广播机制
14. 关于 python / numpy 向量的说明
作业

参考：
吴恩达视频课
深度学习笔记

1. 二分类

判断图片中动物是猫？不是猫？特征向量是 3通道的RGB矩阵展平

2. 逻辑回归

3. 逻辑回归损失函数

几种常见的损失函数

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

代价函数：

所有的样本的损失函数的平均值
J(w,b)=1m∑i=1mL(y^(i),y(i))=−1m∑i=1m[y(i)log⁡(y^(i))+(1−y(i))log⁡(1−y^(i))]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]J(w,b)=m1i=1∑mL(y^(i),y(i))=−m1i=1∑m[y(i)log(y^(i))+(1−y(i))log(1−y^(i))]

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

4. 梯度下降

如何寻找合适的 w，bw，bw，b 使得代价函数最小呢？

迭代的过程中，不断的在各参数的偏导数方向上更新参数值，α\alphaα 是学习率
w:=w−α∂J(w,b)∂wb:=b−α∂J(w,b)∂b\begin{array}{l}w:=w-\alpha \frac{\partial J(w, b)}{\partial w} \\ \\ b:=b-\alpha \frac{\partial J(w, b)}{\partial b}\end{array}w:=w−α∂w∂J(w,b)b:=b−α∂b∂J(w,b)

5. 导数

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

6. 计算图导数计算

链式求导法则：

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

z=wTx+by^=a=σ(z)L(a,y)=−(ylog⁡(a)+(1−y)log⁡(1−a))\begin{array}{l}z=w^{T} x+b \\ \hat{y}=a=\sigma(z) \\ \mathcal{L}(a, y)=-(y \log (a)+(1-y) \log (1-a))\end{array}z=wTx+by^=a=σ(z)L(a,y)=−(ylog(a)+(1−y)log(1−a))

sigmoid 函数：f(z)=11+e−zf(z)=\frac{1}{1+e^{-z}}f(z)=1+e−z1
sigmoid 求导：
∂f(z)∂z=−1∗−1∗e−z(1+e−z)2=e−z(1+e−z)2=1+e−z−1(1+e−z)2=11+e−z−1(1+e−z)2=11+e−z(1−11+e−z)=f(z)(1−f(z))\begin{aligned} \frac{\partial f(z)}{\partial z} &=\frac{-1 *-1 * 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{aligned}∂z∂f(z)=(1+e−z)2−1∗−1∗e−z=(1+e−z)2e−z=(1+e−z)21+e−z−1=1+e−z1−(1+e−z)21=1+e−z1(1−1+e−z1)=f(z)(1−f(z))

∂L∂a=−ya+1−y1−a∂L∂z=∂L∂a∂a∂z=(−ya+1−y1−a)∗a(1−a)=a−y∂L∂w1=∂L∂z∂z∂w1=x1(a−y)nameddw1∂L∂w2=∂L∂z∂z∂w2=x2(a−y)nameddw2∂L∂b=∂L∂z∂z∂b=a−ynameddb\begin{aligned} \frac{\partial\mathcal{L}}{\partial a} &= -\frac{y}{a}+\frac{1-y}{1-a}\\ \frac{\partial\mathcal{L}}{\partial z} &= \frac{\partial\mathcal{L}}{\partial a}\frac{\partial{a}}{\partial z} = \bigg(-\frac{y}{a}+\frac{1-y}{1-a}\bigg)*a(1-a)=a-y\\ \frac{\partial\mathcal{L}}{\partial w_1} &=\frac{\partial\mathcal{L}}{\partial z}\frac{\partial{z}}{\partial w_1} = x_1(a-y) \quad named \quad dw_1\\ \frac{\partial\mathcal{L}}{\partial w_2} &=\frac{\partial\mathcal{L}}{\partial z}\frac{\partial{z}}{\partial w_2} = x_2(a-y) \quad named \quad dw_2\\ \frac{\partial\mathcal{L}}{\partial b} &=\frac{\partial\mathcal{L}}{\partial z}\frac{\partial{z}}{\partial b} = a-y \quad\quad\quad named \quad db\\ \end{aligned} ∂a∂L∂z∂L∂w1∂L∂w2∂L∂b∂L=−ay+1−a1−y=∂a∂L∂z∂a=(−ay+1−a1−y)∗a(1−a)=a−y=∂z∂L∂w1∂z=x1(a−y)nameddw1=∂z∂L∂w2∂z=x2(a−y)nameddw2=∂z∂L∂b∂z=a−ynameddb

w1:=w1−α∗dw1w2:=w2−α∗dw2b:=b−α∗db\begin{array}{l}w_1:=w_1-\alpha *dw_1 \\ w_2 :=w_2-\alpha *dw_2 \\ b:=b-\alpha* db\end{array}w1:=w1−α∗dw1w2:=w2−α∗dw2b:=b−α∗db

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 mz(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 mz(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

这样就把内层的 dw1,... dwn 的计算使用向量化了，只用1层 for 循环，还可以做的更好，往下看

11. 向量化 logistic 回归

逻辑回归前向传播步骤：

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

可以使用 numpy 来计算：

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

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

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

Z=wTX+b=np.dot(w.T,X)+bA=σ(Z)dZ=A−Ydw=1m∗X∗dZTdb=1m∗np.sum(dZ)w:=w−a∗dwb:=b−a∗db\begin{array}{l}Z=w^{T} X+b=n p . d o t(w . T, X)+b \\ A=\sigma(Z) \\ d Z=A-Y \\ d w=\frac{1}{m} * X * d Z^{T} \\ d b=\frac{1}{m} * n p . sum(d Z) \\ w:=w-a * d w \\ b:=b-a * d b\end{array}Z=wTX+b=np.dot(w.T,X)+bA=σ(Z)dZ=A−Ydw=m1∗X∗dZTdb=m1∗np.sum(dZ)w:=w−a∗dwb:=b−a∗db

非向量化、向量化对比：

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

13. numpy 广播机制

import numpy as npA = 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 操作

作业

01.神经网络和深度学习 W2.神经网络基础（作业 - 逻辑回归图片识别）