神经网络与深度学习课程学习笔记(第二章)

第二章 神经网络基础

自学Andrew Ng老师的神经网络公开课,作一些笔记,老师讲的非常详细,通俗易懂,感觉不需要做第一章的笔记,所以没有

文章目录

  • 第二章 神经网络基础
    • 2.1 二分分类
    • 2.2 logistic回归
    • 2.3 代价函数
    • 2.4 梯度下降法
    • 2.5 导数
    • 2.6 更多导数例子
    • 2.7 计算图
    • 2.8 计算图的导数计算
    • 2.9 logistic回归中的梯度下降法
    • 2.10 向量化
    • 2.11 向量化的更多例子
    • 2.12 向量化的logistics回归
    • 2.13 向量化logistics回归的反向传播算法
    • 2.14 Python中的广播
    • 2.15 关于Python/numpy中向量的说明
    • 2.16 ipython笔记本
    • 2.17 (选修)logistics损失函数的解释

2.1 二分分类

什么是二分分类问题,用图像中是否有小猫的例子来说明,图像的颜色像素数值是算法的输入,是否有小猫是算法的输出。
在logistic回归和神经网络中需要用到的关键符号,以及它们的表示方法。比如对于所有的训练样本,要写成一个大的矩阵,矩阵的每一列是一个训练样本输入,多个样本就横着写,训练样本的输出也是这样写,每一列是一个训练样本输出。

2.2 logistic回归

Logistic回归是一种监督学习算法,用来输出估计状态集合为0,1的学习结果。
我们的目的是输出估计的0或1,或者说,输出估计值为1的概率,如果采用线性函数:wx+b,无法输出两个状态,则我们使用sigmod函数,从而 y = s ( w x + b ) y=s(wx+b) y=s(wx+b) z = w x + b z=wx+b z=wx+b y = s ( z ) y=s(z) y=s(z)sigmod函数可以在z为非常大时输出1,在z为非常小时输出0。
对于参数,一种写法时theta,theta0表示b,也就是x^0的参数,theta其他值对应w,教程中不使用theta而是使用w和b,更容易理解。

2.3 代价函数

右上角带括号的角标是指第i个样本,统一写法。
如何训练参数w和b,我们的目的是让y/hat与y的差距尽可能小,设计一个损失函数(误差函数),
L ( y ^ , y ) L(\hat y, y) L(y^,y)
这个函数可以是欧几里得距离,但是会在下一步梯度下降法时出现很多局部最优解,从而这里设计
L ( y ^ , y ) = − y l o g y − ( 1 − y ) l o g ( 1 − y ) L(\hat y, y) = -ylogy-(1-y)log(1-y) L(y^,y)=ylogy(1y)log(1y)
这个公式也能做到损失函数的要求,还能够避免梯度下降法的局部最优解。
将所有的训练样本的损失函数求均值后,得到的值为代价函数
J ( w , b ) = 1 m ∑ i L ( y ^ i , y i ) J(w,b)=\frac {1}{m}\sum_i{L(\hat y^{i}, y^{i})} J(w,b)=m1iL(y^i,yi)
损失函数是针对单个训练样本,代价函数是所有训练样本损失函数的均值,用来控制整个模型的训练程度,我们的训练就是针对代价函数。

2.4 梯度下降法

本节就讲了上一节提出的代价函数,如何取得能够使代价函数最小的w和b的值,用到的方法就是梯度下降法。梯度下降法就是重复的更新w和b,每次更新的步长就是 α d w \alpha dw αdw α d b \alpha db αdb α \alpha α是学习率,值越大,步长越大。然后后边还讲了导数和偏导数的概念,还好学过高数,不难。

2.5 导数

这节直接跳过

2.6 更多导数例子

这节就是讲导数会变的情况,讲的是真的细啊

2.7 计算图

介绍了计算图的概念,就是把一个公式拆分成多个子公式,形成一个图的形式。

2.8 计算图的导数计算

这节通过反向计算计算图的导数,分别求代价函数J相对于各个项的导数,引出了反向计算。反向计算是为了得到代价函数中的每一个参数的导数,从而通过导数结合前边的梯度下降法,就可以按梯度的方向去更新参数,最终寻找到代价函数的最小值。

2.9 logistic回归中的梯度下降法

这一节是将前几节的梯度下降法,logistic回归公式,还有反向计算结合起来,举例
z = w 1 x 1 + w 2 x 2 + b z=w^1x^1+w^2x^2+b z=w1x1+w2x2+b

y ^ = a = s i g m o d ( z ) \hat y = a = sigmod(z) y^=a=sigmod(z)

L ( y ^ , y ) = L ( a , y ) = − ( y l o g ( a ) + ( 1 − y ) l o g ( 1 − a ) ) L(\hat y, y) = L(a, y) = -(ylog(a)+(1-y)log(1-a)) L(y^,y)=L(a,y)=(ylog(a)+(1y)log(1a))

这几个公式,然后反向计算 d a − > d z − > d w 1 − > d w 2 − > d b da->dz->dw^1->dw^2->db da>dz>dw1>dw2>db关于参数 w 1 , w 2 , b w^1, w^2, b w1,w2,b的导数,就可以用到梯度下降法中了。本节讲的是单个样本的例子。
计算出来的
d a = d L ( a , y ) d a = − y a + 1 − y 1 − a da=\frac{dL(a,y)}{da} = -\frac{y}{a}+\frac{1-y}{1-a} da=dadL(a,y)=ay+1a1y

d z = d L ( a , y ) d a ∗ d a d z = d a ∗ ( a ( 1 − a ) ) = a − y dz=\frac{dL(a,y)}{da}*\frac{da}{dz}=da*(a(1-a))=a-y dz=dadL(a,y)dzda=da(a(1a))=ay

d w = x ∗ d z dw=x*dz dw=xdz

d b = d z db=dz db=dz

2.10 向量化

本节介绍了python中用向量来代替循环实现向量运算的好处,就是快,老师用一个例子来演示了,向量 n p . d o t ( x , y ) np.dot(x,y) np.dot(x,y)用1.5ms,用循环需要500ms,这还是小数据,大数据下计算速率差别更大。所以建议能用向量运算的时候就去用,尽量不要用循环单个元素的乘。

2.11 向量化的更多例子

本节前半段介绍了除了计算两个向量的乘法可以使用向量化的方法以外,对于计算向量的指数、对数、倒数、绝对值等等数学运算,也可以用向量化方法取代循环依次计算每一个项的方法。
后边介绍了对于logistics回归算法中,可以将所有的参数写成一个向量,然后里边关于依次计算参数倒数和更新参数倒数的步骤就可以使用向量化的方法来取代。

2.12 向量化的logistics回归

使用向量化可以替代循环实现对激活函数的计算,首先 z = w x + b z=wx+b z=wx+b其次 a = s i g m o d ( z ) a=sigmod(z) a=sigmod(z)其中 z z z a a a看作是向量,写作 Z Z Z A A A,可以用 Z = n p . d o t ( W T , X ) + b Z=np.dot(W^T, X)+b Z=np.dot(WT,X)+b A = s i g m o d ( Z ) A=sigmod(Z) A=sigmod(Z)来计算。

2.13 向量化logistics回归的反向传播算法

d z = a − y dz=a-y dz=ay是怎么来的?和 z = w x + b z=wx+b z=wx+b的关系是啥?
本节讲了如何将整个logistics回归算法用向量化的方式来替代,logistics回归的循环版本需要每次循环每个样本,对每个样本进行计算和迭代,向量化的版本取代了这个循环。
Z = W T ∗ X + b Z = W^T * X + b Z=WTX+b

A = s i g m o d ( Z ) A = sigmod(Z) A=sigmod(Z)

d Z = A − Y dZ = A - Y dZ=AY

d W + = 1 m ( X ∗ d Z T ) dW += \frac{1}{m} (X * dZ^T) dW+=m1(XdZT)

d B + = 1 m n p . s u m ( d Z ) dB += \frac{1}{m} np.sum(dZ) dB+=m1np.sum(dZ)

W : = W − α ∗ d W W := W - \alpha * dW W:=WαdW

B : = B − α ∗ d B B := B - \alpha * dB B:=BαdB

2.14 Python中的广播

这次讲的是Python中的broadcasting,我不知道这里翻译成广播对不对,反正意思就是Python可以在矩阵运算中,将不符合行列数量匹配的矩阵之间进行运算,会将较小的那个矩阵扩展成较大的那个的行列数。同理也适用于矩阵与向量和实数做的运算。

上文公式中我们使用了 B B B d B dB dB来表示常数参数矩阵,然而在神经网络中这个量是向量,这里就用到了Python广播,将向量的 b b b d b db db扩展成 B B B d B dB dB

2.15 关于Python/numpy中向量的说明

这个问题我以前经常会遇到,之前没有总结过。
当使用Python做科学运算时,总会使用到numpy,但要注意数据结构的问题,区分开数组和矩阵的区别。使用

a=np.random.randn(5)

生成的a是一个数组,数组的转置依然是这个数组,不满足矩阵的运算;使用

a=np.random.randn(5,1)

生成的a是一个矩阵,矩阵满足矩阵运算。如果将两个a求sharp,第一个得到的是(5,)这样一个结果,第二个得到的是(5,1)这样一个结果。
经常会有一些问题是因为这里数据结构区别导致的,要多加注意,老师建议总是去使用矩阵,而不是数组,如果有数组,就使用reshape将其变为矩阵。另外,多的使用assert去检查a.shape是否满足要求,可以避免难以调试的bug。

2.16 ipython笔记本

这节讲怎么用ipython笔记本调试代码和提交作业。

2.17 (选修)logistics损失函数的解释

本节讲的明显比前边的复杂一些,分两部分。
首先是解释logistics中损失函数
L ( y ^ , y ) = − ( y l o g y + ( 1 − y ) l o g ( 1 − y ) ) L(\hat y, y) = -(ylogy + (1-y)log(1-y)) L(y^,y)=(ylogy+(1y)log(1y))
是怎么推导出来的,这个式子是首先由:
p ( y ∣ x ) = { y ^ y=1 1 − y ^ y=0 p(y|x)={ \begin{cases} \hat y& \text{y=1} \\ 1- \hat y& \text{y=0} \\ \end{cases} } p(yx)={ y^1y^y=1y=0
将这两个式子合并:
p ( y ∣ x ) = y ^ y ∗ ( 1 − y ^ ) ( 1 − y ) p(y|x) = \hat y^y * (1-\hat y)^{(1-y)} p(yx)=y^y(1y^)(1y)
另外老师说对 l o g ( p ( y ∣ x ) log(p(y|x) log(p(yx)求最大值等效于求 p ( y ∣ x ) p(y|x) p(yx)的最大值,所以
l o g ( p ( y ∣ x ) ) = y l o g ( y ^ ) + ( 1 − y ) l o g ( 1 − y ^ ) log(p(y|x)) = ylog(\hat y)+(1-y)log(1-\hat y) log(p(yx))=ylog(y^)+(1y)log(1y^)
之后对整个式子加负号,是因为计算损失函数的最小值,所以将计算log函数的最大值取负数,最后
L ( y ^ , y ) = − ( y l o g ( y ^ ) + ( 1 − y ) l o g ( 1 − y ^ ) ) L(\hat y, y) = -(ylog(\hat y) + (1-y)log(1-\hat y)) L(y^,y)=(ylog(y^)+(1y)log(1y^))
这个公式就是损失函数。
然后介绍代价函数
J ( w , b ) = 1 m ∑ ( L ( y ^ , y ) ) J(w,b) = \frac {1}{m}\sum(L(\hat y, y)) J(w,b)=m1(L(y^,y))
是怎么来的。直观的理解其实就是把所有的损失函数求均值,不过推导依然是使用log函数。所有样本的估计概率的联合分布 P ( … ) P(…) P(),求 l o g ( P ( … ) ) log(P(…)) log(P())后,计算最大值,而 P ( … ) P(…) P()本身根据联合概率分布,假设各样本是独立同分布的,所以 P ( … ) P(…) P()等于各个样本自身概率的乘积,
P ( … ) = ∏ ( p ( y i ∣ x i ) ) , i = ( 1 … n ) P(…)=\prod(p(y^i|x^i)), i=(1…n) P()=(p(yixi)),i=(1n)
求对数后
l o g P ( … ) = ∑ ( l o g ( p ( y i ∣ x i ) ) ) = ∑ ( − L ( y ^ i , y i ) ) logP(…)=\sum(log(p(y^i|x^i))) = \sum(-L(\hat y^i, y^i)) logP()=(log(p(yixi)))=(L(y^i,yi))
依据最大似然估计,可以计算出最优参数。为了缩小尺度,代价函数中加了个除m的参数,所以
J ( w , b ) = 1 m ∑ ( L ( y ^ i , y i ) ) J(w,b) = \frac {1}{m} \sum(L(\hat y^i, y^i)) J(w,b)=m1(L(y^i,yi))
去掉了负号,可能觉得没用了。

你可能感兴趣的:(学习笔记,机器学习,神经网络,Andrew,Ng)