上一篇:【课程1 - 第二周测验】 ✌✌✌✌ 【目录】 ✌✌✌✌ 下一篇:【课程1 - 第三周测验】
首先说明一下,大学生一枚,最近在学习神经网络,写这篇文章只是记录自己的学习历程,起总结复习的作用,别无它意,本文参考了zsffuture的博客、布衣先生real的博客、孔小爽的博客、何宽的博客以及Github上fengdu78老师的文章进行学习
import numpy as np
import matplotlib.pyplot as plt
import h5py
from lr_utils import load_dataset
x_train,x_test,y_train,y_test,classes=load_dataset()
这里的数据维度应为4维,例 [ 20 , 32 , 32 , 3]
第一维表示有多少张图片,2维和3维表示图片的宽和高,而第4维的3代表像素,RGB红绿蓝
这里就是有20张图片,每张的图片为的32*32的彩色图片,如果是1则为黑白照片
print(x_test.shape)
print('训练集的数量:',x_train.shape[0])
print('测试集的数量:',x_test.shape[0])
print('训练集的数据维度:',x_train.shape)
print('测试集的数据维度:',x_test.shape)
print('训练集的标签维度:',y_train.shape)
print('测试集的标签维度:',y_test.shape)
print('图片的维度:',x_train[0].shape)
查看输出结果:
训练集的数量: 209
测试集的数量: 50
训练集的数据维度: (209, 64, 64, 3)
测试集的数据维度: (50, 64, 64, 3)
训练集的标签维度: (1, 209)
测试集的标签维度: (1, 50)
图片的维度: (64, 64, 3)
上面说到测试集的图片维度为 (50, 64, 64, 3),我们要将每个像素点提取出来作为1个特征,说白了就是将图片拉长,变成50行,64643列的矩阵
那么为什么要将其转置呢,正常来说不是行数代表样本量,列数代表特征数吗?
这是因为后面构建神经网络时,涉及到矩阵的运算,转置后计算会更方便一些,看到后面你就会get到这个点
x_train=x_train.reshape(x_train.shape[0],-1).T
x_test=x_test.reshape(x_test.shape[0],-1).T
print(x_train.shape)
print(x_test.shape)
查看输出结果:
(12288, 209)
(12288, 50)
在传统机器学习中,我们在将数据导入模型训练之前首先要将数据归一化,转化到0~1之间,为了消除量纲的影响和有利于模型的计算
而在图片也需要这点,但图片的处理方式会更容易一些,因为图片的每个像素是0~255之间的数字组成,所以我们只需要将该图片矩阵除255即可,就会将矩阵缩放到0-1之间
x_train=x_train/255
x_test=x_test/255
x_train[0,0:10]
查看第一张图片的前10个特征:
array([2.61437908e-04, 3.01422530e-03, 1.26105344e-03, 1.53787005e-05,
1.38408304e-04, 1.29181084e-03, 8.61207228e-04, 2.92195309e-04,
9.68858131e-04, 3.53710111e-04])
现在我们的准备工作已经做好了,接下来就是搭建神经网络
z = w . T ∗ X + b z=w.T*X+b z=w.T∗X+b
y = a = s i g m o i d ( z ) y=a=sigmoid(z) y=a=sigmoid(z)
单一样本的损失:
L ( y , a ) = − ( y ∗ l o g ( a ) + ( 1 − y ) ∗ l o g ( 1 − a ) ) L(y,a)=-(y*log(a)+(1-y)*log(1-a)) L(y,a)=−(y∗log(a)+(1−y)∗log(1−a))
计算所有样本的平均损失值:
J = 1 / m ∑ i = 0 m L ( y , a ) J=1/m\sum_{i=0}^mL(y,a) J=1/mi=0∑mL(y,a)
搭建神经网络的主要步骤是:
定义模型结构(例如输入特征的数量)
初始化模型的参数
不断迭代(调整参数):
3.1 计算当前损失(正向传播)
3.2 计算当前梯度(反向传播)
3.3 更新参数(梯度下降)
a = s i g m o i d ( z ) a=sigmoid(z) a=sigmoid(z)
s i g m o i d = 1 / ( 1 + e − x ) sigmoid=1/(1+e^-x) sigmoid=1/(1+e−x)
因为我们要做的是二分类问题,所以到最后要将其转化为概率,所以可以利用sigmoid函数的性质将其转化为0~1之间
def sigmoid(z):
"""
功能:激活函数,计算sigmoid的值
参数:
z - 任何维度的矩阵
返回:
s - sigmoid(z)
"""
s=1/(1+np.exp(-z))
return s
在进行梯度下降之前,要初始化w和b的值,我们为了简单都将其初始化为0
w的维度应为(特征数,1)
这里就验证了之前说到的特征转置
z = w . T ∗ X + b z=w.T*X+b z=w.T∗X+b
可以看到刚好对应矩阵的维度
b为一常数
def init_w_b(dim):
"""
功能:初始化w,b的维度和值
参数:
dim - w要初始化的行维度,就是特征数
返回:
w - 初始化好的(dim,1)维矩阵
b - 常数0
"""
# 将w初始化为列矩阵
w=np.zeros((dim,1))
b=0
return w,b
神经网络分为正向传播和反向传播
正向传播计算求出损失函数,然后反向计算各个梯度
然后进行梯度下降,更新参数
def propagate(w,b,X,Y):
"""
功能:正向传播和反向传播
计算损失函数,以及各权重w,偏置b的梯度
参数:
w - 初始化好的权重矩阵(特征数,1)维
b - 偏置b
X - 训练数据 (特征数,样本数)维
Y - 训练标签 (1,样本数)维
返回:
grads - 各权重和偏置的梯度
loss - 损失值
"""
# m:为样本数
m=X.shape[1]
# 正向传播计算损失
a=sigmoid(np.dot(w.T,X)+b)
loss=(-1/m)*np.sum(Y*np.log(a)+(1-Y)*np.log(1-a))
# 反向传播计算梯度
dw=(1/m)*np.dot(X,(a-Y).T)
db=(1/m)*np.sum(a-Y)
grads={
'dw':dw,'db':db}
return grads,loss
目标是通过最小化损失函数 J来学习 w 和 b 。对于参数 λ,更新规则是 w = w − λ ∗ d J / d w w=w-λ*dJ/dw w=w−λ∗dJ/dw b = b − λ ∗ d J / d b b=b-λ*dJ/db b=b−λ∗dJ/db,其中 λ 是学习率。
num_iter代表梯度下降时的迭代次数,就是w的改变次数,求取损失函数的最小值,即全局最优解,这里可能会产生局部最优解,会影响模型结果,这里不与阐述,可以选择其他较好的优化器
大多数优化器都是基于梯度下降这种方法,只不过具体的数学计算有些不同
def optimizer(w,b,X,Y,num_iter,lr,print_loss=False):
"""
功能:优化函数,进行梯度下降,不断更新权重值,求取最优解
参数:
w - 初始化好的权重矩阵(特征数,1)维
b - 偏置b
X - 训练数据 (特征数,样本数)维
Y - 训练标签 (1,样本数)维
num_iter - 梯度下降时的迭代次数
lr - 学习率 w=w-lr*dw
print_loss - 是否每100次迭代打印一次缺失值
返回:
params - 训练好后的w和b值
grads - 各权重和偏置的梯度
loss - 各迭代次数下的损失值
"""
# 不同迭代次数下的损失值
losses=[]
# 进行迭代
for i in range(num_iter):
# 开始传播,计算梯度
grads,loss=propagate(w,b,X,Y)
dw=grads['dw']
db=grads['db']
# 更新参数,梯度下降
w=w-lr*dw
b=b-lr*db
if i%100==0:
losses.append(loss)
if print_loss and i%100==0:
print('迭代次数:%d,误差值:%f'%(i+1,loss))
params={
'w':w,'b':b}
grads={
'dw':dw,'db':db}
return params,grads,losses
上面optimizer函数会输出已经训练好的w、b参数,我们可以利用它们进行预测新的样本集
进行预测两个步骤:
def predict(w,b,X):
"""
功能:利用优化好的w和b值进行预测
参数:
w - 初始化好的权重矩阵(特征数,1)维
b - 偏置b
X - 训练数据 (特征数,样本数)维
返回:
y_pred - 预测值(1,样本数)维
"""
# 样本数
m=X.shape[1]
# 将y_pred变成和标签同维度的举证
y_pred=np.zeros((1,m))
# 激活
a=sigmoid(np.dot(w.T,X)+b)
# 根据概率进行二分类判断
for i in range(m):
y_pred[0,i]=1 if a[0,i]>0.5 else 0
return y_pred
我们已经将所需要的所有函数已经封装好了,现在需要一个训练函数调用它们,完成模型的训练,model的作用就是如此
def model(x_train,x_test,y_train,y_test,num_iter,lr,print_loss=False):
"""
功能:利用前面封装好的函数进行训练
参数:
x_train - 训练数据(特征数,样本数)
x_test - 初始化好的权重矩阵(特征数,样本数)
y_train - 初始化好的权重矩阵(1,样本数)
y_test - 初始化好的权重矩阵(1,样本数)
num_iter - 梯度下降的迭代次数
lr - 学习率
print_loss - 是否每100次打印loss值
返回:
d - 预测结果以w,b等数据
"""
# 初始化参数w、b
w,b=init_w_b(x_train.shape[0])
# 开始梯度下降
params,grads,losses=optimizer(w,b,x_train,y_train,num_iter,lr,print_loss)
w,b=params['w'],params['b']
# 预测训练集和测试集
y_pred_train=predict(w,b,x_train)
y_pred_test=predict(w,b,x_test)
# 计算准确率
print('训练集的准确性:%.3f'%((y_pred_train==y_train).sum()/y_train.shape[1]*100),'%')
print('测试集的准确性:%.3f'%((y_pred_test==y_test).sum()/y_test.shape[1]*100),'%')
d = {
"losses" : losses,
"y_pred_train" : y_pred_train,
"y_pred_test" : y_pred_test,
"w" : w,
"b" : b,
"learning_rate" :lr,
"num_iter" : num_iter }
return d
我们将我们处理好的训练测试集传入,测试下模型的效果,并每迭代100次打印下损失函数的值,观察模型效果是否得到了优化
print("====================测试model====================")
d = model(x_train,x_test,y_train,y_test,2000,0.003,True)
查看输出结果:
====================测试model====================
迭代次数:1,误差值:0.693147
迭代次数:101,误差值:0.686231
迭代次数:201,误差值:0.680305
迭代次数:301,误差值:0.675226
迭代次数:401,误差值:0.670873
迭代次数:501,误差值:0.667139
迭代次数:601,误差值:0.663935
迭代次数:701,误差值:0.661184
迭代次数:801,误差值:0.658821
迭代次数:901,误差值:0.656790
迭代次数:1001,误差值:0.655043
迭代次数:1101,误差值:0.653539
迭代次数:1201,误差值:0.652244
迭代次数:1301,误差值:0.651129
迭代次数:1401,误差值:0.650167
迭代次数:1501,误差值:0.649337
迭代次数:1601,误差值:0.648620
迭代次数:1701,误差值:0.648002
迭代次数:1801,误差值:0.647467
迭代次数:1901,误差值:0.647004
训练集的准确性:65.550 %
测试集的准确性:34.000 %
这里我们可以看到随着迭代次数的增加,模型的损失函数越来越小,这都是梯度下降所起到的作用,说明我们的w、b等值更新的正确,朝着全局最优解的方向进行
losses=d['losses']
# 横坐标为迭代次数*100 ,纵坐标为损失值
plt.plot(range(1,len(losses)+1),losses)
plt.title('l r=0.003')
plt.xlabel('iters(*100)')
plt.ylabel('losses')
plt.show()
上面我们看到当学习率为0.03时模型效果并不是很好,可能是梯度下降时影响了参数的变化速率及值的变化,所以我们可以画学习曲线去观察不同学习率的模型评估效果
lr=[0.01,0.001,0.0001,0.00001]
models={
}
for i in lr:
print('learning rate is :',i)
models[str(i)]=model(x_train,x_test,y_train,y_test,2000,i)
print('\n'+"----------------------------------------")
for i in lr:
plt.plot(range(1,len(models[str(i)]['losses'])+1),models[str(i)]['losses'],label=str(i))
plt.xlabel('iter(*100)')
plt.ylabel('losses')
plt.legend(loc='upper right')
plt.show()
查看输出结果:
learning rate is : 0.01
训练集的准确性:99.522 %
测试集的准确性:70.000 %
----------------------------------------
learning rate is : 0.001
训练集的准确性:91.388 %
测试集的准确性:68.000 %
----------------------------------------
learning rate is : 0.0001
训练集的准确性:71.292 %
测试集的准确性:40.000 %
----------------------------------------
learning rate is : 1e-05
训练集的准确性:65.550 %
测试集的准确性:34.000 %
----------------------------------------