Ng深度学习笔记 神经网络编程基础
神经网络编程基础
二分类(Binary Classification)
一张图片在计算机中的表示:
三个矩阵,分别对应图片中的红、绿、蓝三种颜色通道,如果图片大小为64x64像素,那么就有三个规模为64x64的矩阵。
为了便于表示,画了三规模为5x4的矩阵
如何将训练样本(输入向量 X X X的集合)表示为一个矩阵
把像素值放到一个特征向量
x
x
x中:
64乘以64乘以3=12288,这是三个像素矩阵中像素的总量,
n
x
=
12
,
288
n_x=12,288
nx=12,288,预测输出结果
y
y
y为1还是0。
符号定义 :
x x x:表示一个 n x n_x nx维数据,为输入数据,维度为 ( n x , 1 ) (n_x,1) (nx,1);
y y y:表示输出结果,取值为 ( 0 , 1 ) (0,1) (0,1);
( x ( i ) , y ( i ) ) (x^{(i)},y^{(i)}) (x(i),y(i)):表示第 i i i组数据,可能是训练数据,也可能是测试数据,此处默认为训练数据;
X = [ x ( 1 ) , x ( 2 ) , . . . , x ( m ) ] X=[x^{(1)},x^{(2)},...,x^{(m)}] X=[x(1),x(2),...,x(m)]:表示所有的训练数据集的输入值,放在一个 n x × m n_x×m nx×m的矩阵中,其中 m m m表示样本数目;
Y = [ y ( 1 ) , y ( 2 ) , . . . , y ( m ) ] Y=[y^{(1)},y^{(2)},...,y^{(m)}] Y=[y(1),y(2),...,y(m)]:对应表示所有训练数据集的输出值,维度为 1 × m 1×m 1×m。
定义一个矩阵用大写
X
X
X的表示,它由输入向量
x
(
1
)
x^{(1)}
x(1)、
x
(
2
)
x^{(2)}
x(2)等组成,把
x
(
1
)
x^{(1)}
x(1)作为第一列放在矩阵中,
x
(
2
)
x^{(2)}
x(2)作为第二列,
x
(
m
)
x^{(m)}
x(m)放到第
m
m
m列,然后我们就得到了训练集矩阵
X
X
X。
这个矩阵有
m
m
m列,
m
m
m是训练集的样本数量,矩阵的高度记为
n
x
n_x
nx。
X X X是一个规模为 n x n_x nx乘以 m m m的矩阵,即X.shape等于 ( n x , m ) (n_x,m) (nx,m), X X X是一个规模为 n x n_x nx乘以 m m m的矩阵。所以综上所述,这就是如何将训练样本(输入向量 X X X的集合)表示为一个矩阵。
输出标签
y
y
y同理。Y.shape等于
(
1
,
m
)
(1,m)
(1,m),表示这是一个规模为1乘以
m
m
m的矩阵。
逻辑回归
逻辑回归学习算法适用于二分类问题
Hypothesis Function(假设函数)。
产生输出预测值
y
^
\hat{y}
y^:
1、
y
^
=
w
T
x
+
b
\hat{y}={{w}^{T}}x+b
y^=wTx+b
2、sigmoid=
σ
(
z
)
=
1
1
+
e
−
z
\sigma \left( z \right)=\frac{1}{1+{{e}^{-z}}}
σ(z)=1+e−z1
代价函数
逻辑回归中的损失函数: L ( y ^ , y ) = − y log ( y ^ ) − ( 1 − y ) log ( 1 − y ^ ) L\left( \hat{y},y \right)=-y\log(\hat{y})-(1-y)\log (1-\hat{y}) L(y^,y)=−ylog(y^)−(1−y)log(1−y^)
在这门课中有很多的函数效果和现在这个类似,就是如果
y
y
y等于1,我们就尽可能让
y
^
\hat{y}
y^变大,如果
y
y
y等于0,我们就尽可能让
y
^
\hat{y}
y^ 变小。
损失函数----单个训练样本
代价函数----全部训练样本:对
m
m
m个样本的损失函数求和然后除以
m
m
m:
J
(
w
,
b
)
=
1
m
∑
i
=
1
m
L
(
y
^
(
i
)
,
y
(
i
)
)
=
1
m
∑
i
=
1
m
(
−
y
(
i
)
log
y
^
(
i
)
−
(
1
−
y
(
i
)
)
log
(
1
−
y
^
(
i
)
)
)
J\left( w,b \right)=\frac{1}{m}\sum\limits_{i=1}^{m}{L\left( {{{\hat{y}}}^{(i)}},{{y}^{(i)}} \right)}=\frac{1}{m}\sum\limits_{i=1}^{m}{\left( -{{y}^{(i)}}\log {{{\hat{y}}}^{(i)}}-(1-{{y}^{(i)}})\log (1-{{{\hat{y}}}^{(i)}}) \right)}
J(w,b)=m1i=1∑mL(y^(i),y(i))=m1i=1∑m(−y(i)logy^(i)−(1−y(i))log(1−y^(i)))
梯度下降法(Gradient Descent)
梯度下降法:通过最小化代价函数(成本函数)
J
(
w
,
b
)
J(w,b)
J(w,b)来训练的参数
w
w
w和
b
b
b
细节化说明:
逻辑回归中的梯度下降(Logistic Regression Gradient Descent)
单个样本,两个特征
d
L
(
a
,
y
)
d
a
=
−
y
/
a
+
(
1
−
y
)
/
(
1
−
a
)
\frac{dL(a,y)}{da}=-y/a+(1-y)/(1-a)
dadL(a,y)=−y/a+(1−y)/(1−a)
d
L
(
a
,
y
)
d
z
=
d
L
d
z
=
(
d
L
d
a
)
⋅
(
d
a
d
z
)
\frac{dL(a,y)}{dz}=\frac{dL}{dz}=(\frac{dL}{da})\cdot (\frac{da}{dz})
dzdL(a,y)=dzdL=(dadL)⋅(dzda) 并且
d
a
d
z
=
a
⋅
(
1
−
a
)
\frac{da}{dz}=a\cdot (1-a)
dzda=a⋅(1−a), 而
d
L
d
a
=
(
−
y
a
+
(
1
−
y
)
(
1
−
a
)
)
\frac{dL}{da}=(-\frac{y}{a}+\frac{(1-y)}{(1-a)})
dadL=(−ay+(1−a)(1−y)),因此将这两项相乘,得到:
d z = d L ( a , y ) d z = d L d z = ( d L d a ) ⋅ ( d a d z ) = ( − y a + ( 1 − y ) ( 1 − a ) ) ⋅ a ( 1 − a ) = a − y {dz} = \frac{{dL}(a,y)}{{dz}} = \frac{{dL}}{{dz}} = \left( \frac{{dL}}{{da}} \right) \cdot \left(\frac{{da}}{{dz}} \right) = ( - \frac{y}{a} + \frac{(1 - y)}{(1 - a)})\cdot a(1 - a) = a - y dz=dzdL(a,y)=dzdL=(dadL)⋅(dzda)=(−ay+(1−a)(1−y))⋅a(1−a)=a−y
d
w
1
=
1
m
∑
i
m
x
1
(
i
)
(
a
(
i
)
−
y
(
i
)
)
d{{w}{1}}=\frac{1}{m}\sum\limits{i}^{m}{x_{1}^{(i)}}({{a}^{(i)}}-{{y}^{(i)}})
dw1=m1∑imx1(i)(a(i)−y(i))
d
w
2
=
1
m
∑
i
m
x
2
(
i
)
(
a
(
i
)
−
y
(
i
)
)
d{{w}{2}}=\frac{1}{m}\sum\limits{i}^{m}{x_{2}^{(i)}}({{a}^{(i)}}-{{y}^{(i)}})
dw2=m1∑imx2(i)(a(i)−y(i))
d
b
=
1
m
∑
i
m
(
a
(
i
)
−
y
(
i
)
)
db=\frac{1}{m}\sum\limits_{i}^{m}{({{a}^{(i)}}-{{y}^{(i)}})}
db=m1i∑m(a(i)−y(i)) 视频中,
d
w
1
d{{w}{1}}
dw1 表示
∂
L
∂
w
1
=
x
1
⋅
d
z
\frac{\partial L}{\partial {{w}{1}}}={{x}{1}}\cdot dz
∂w1∂L=x1⋅dz,
d
w
2
d{{w}{\text{2}}}
dw2 表示
∂
L
∂
w
2
=
x
2
⋅
d
z
\frac{\partial L}{\partial {{w}{2}}}={{x}{2}}\cdot dz
∂w2∂L=x2⋅dz,
d
b
=
d
z
db=dz
db=dz。
因此,关于单个样本的梯度下降算法,你所需要做的就是如下的事情: 使用公式
d
z
=
(
a
−
y
)
dz=(a-y)
dz=(a−y)计算
d
z
dz
dz, 使用
d
w
1
=
x
1
⋅
d
z
d{{w}{1}}={{x}{1}}\cdot dz
dw1=x1⋅dz 计算
d
w
1
d{{w}{1}}
dw1,
d
w
2
=
x
2
⋅
d
z
d{{w}{2}}={{x}{2}}\cdot dz
dw2=x2⋅dz计算
d
w
2
d{{w}{2}}
dw2,
d
b
=
d
z
db=dz
db=dz 来计算
d
b
db
db, 然后: 更新
w
1
=
w
1
−
a
d
w
1
{{w}{1}}={{w}{1}}-a d{{w}{1}}
w1=w1−adw1, 更新
w
2
=
w
2
−
a
d
w
2
{{w}{2}}={{w}{2}}-a d{{w}{2}}
w2=w2−adw2, 更新
b
=
b
−
α
d
b
b=b-\alpha db
b=b−αdb。
m 个样本的梯度下降(Gradient Descent on m Examples)
向量化逻辑回归
z=np.dot(w,x)+b
输入矩阵 X X X : n x n_x nx 行 m m m 列。写为Python numpy的形式 ( n x , m ) (n_{x},m) (nx,m) 这只是表示 X X X 是一个 n x n_x nx 乘以 m m m 的矩阵 R n x × m R^{n_x \times m} Rnx×m
为了计算
W
T
X
+
[
b
b
.
.
.
b
]
W^{T}X+[b b ... b]
WTX+[bb...b] ,numpy命令是
Z
=
n
p
.
d
o
t
(
w
.
T
,
X
)
+
b
Z=np.dot(w.T,X)+b
Z=np.dot(w.T,X)+bPython中广播(brosdcasting):
b
b
b 是一个实数,但是当将这个向量加上这个实数时,Python自动把这个实数
b
b
b 扩展成一个
1
×
m
1\times m
1×m 的行向量。
A = [ a ( 1 ) a ( 2 ) . . . a ( m ) ] = σ ( Z ) A=[a^{(1)} a^{(2)} ... a^{(m)}]=\sigma (Z) A=[a(1)a(2)...a(m)]=σ(Z)
向量化 logistic 回归的梯度输出(Vectorizing Logistic Regression’s Gradient)
注:本节中大写字母代表向量,小写字母代表元素
如何同时计算 m m m 个数据的梯度,并且实现一个非常高效的逻辑回归算法**(Logistic Regression**)。
向量化dw,db的迭代
首先我们来看 d b db db,不难发现 d b = 1 m ∑ i = 1 m d z ( i ) db=\frac{1}{m}\sum_{i=1}^{m}dz^{(i)} db=m1i=1∑mdz(i) , 之前的讲解中,我们知道所有的 d z i ) dz^{i)} dzi)已经组成一个行向量 d Z dZ dZ了,所以在Python中,我们很容易地想到 d b = 1 m n p . s u m ( d Z ) db=\frac{1}{m}np.sum(dZ) db=m1np.sum(dZ);接下来看 d w dw dw,我们先写出它的公式 d w = 1 m X d z T dw=\frac{1}{m}Xdz^{T} dw=m1XdzT 其中, X X X 是一个行向量。因此展开后 d w = 1 m ( x ( 1 ) d z ( 1 ) + x ( 2 ) d z ( 2 ) + . . . + x m d z m ) dw=\frac{1}{m}(x^{(1)}dz^{(1)}+x^{(2)}dz^{(2)}+...+x^{m}dz^{m}) dw=m1(x(1)dz(1)+x(2)dz(2)+...+xmdzm) 。因此我们可以仅用两行代码进行计算: d b = 1 m ∗ n p . s u m ( d Z ) db=\frac{1}{m}*np.sum(dZ) db=m1∗np.sum(dZ), d w = 1 m X d z T dw=\frac{1}{m}Xdz^{T} dw=m1XdzT。这样,我们就避免了在训练集上使用for循环。
现在,让我们回顾一下,看看我们之前怎么实现的逻辑回归,可以发现,没有向量化是非常低效的,如下图所示代码:
我们的目标是不使用for循环,而是向量,我们可以这么做:
Z = w T X + b = n p . d o t ( w . T , X ) + b Z = w^{T}X + b = np.dot( w.T,X)+b Z=wTX+b=np.dot(w.T,X)+b
A = σ ( Z ) A = \sigma( Z ) A=σ(Z)
d Z = A − Y dZ = A - Y dZ=A−Y
d w = 1 m X d z T {{dw} = \frac{1}{m}Xdz^{T}\ } dw=m1XdzT
d b = 1 m ∗ n p . s u m ( d Z ) db= \frac{1}{m}*np.sum( dZ) db=m1∗np.sum(dZ)
w : = w − a ∗ d w w: = w - a*dw w:=w−a∗dw
b : = b − a ∗ d b b: = b - a*db b:=b−a∗db
如果希望多次迭代进行梯度下降,那么仍然需要for循环。