深入剖析神经网络的运行机理及实现.docx
《深入剖析神经网络的运行机理及实现.docx》由会员分享，可在线阅读，更多相关《深入剖析神经网络的运行机理及实现.docx（18页珍藏版）》请在冰豆网上搜索。
深入剖析神经网络的运行机理及实现
深入剖析神经网络的运行机理及实现
随着大数据和机器硬件水平的提升，神经网络特别是深度神经网络现在是大火特火。
因为目前的深度学习模型都是基于神经网络进行的改进和加深，所以要想对深度学习有一些较深入的研究，先熟悉和了解人工神经网络是非常有帮助的。
本文基于神经网络实现一个手写体数字识别模型，此处使用的数据集为sklearn自带的digit数据，只要装了sklearn就可以直接获得。
1、手写体人工神经网络模型
神经网络是一个判别模型，它会利用训练集学到一个从输入到输出的映射关系，结构上可以分为输入层、隐藏层和输出层，如上图。
输入层用于接收数据的输入，通过隐藏层的处理，最后经输出层转换得到输出。
上图为基于mnist数据集画的一个神经网络模型，因为mnist一张图片为28*28=784，故输入层有784个神经元。
而digit的图片为8*8=64，故digit数据集的输入层有64个神经元，也就是说我们将要实现的神经网络输入层有64个神经元，要简单很多。
神经网络的性能如何，隐层的设计非常关键，隐藏层是设计用来自动学习特征的，通过这些学到的特征来进行最后一层的分类任务，那它会学到什么东西呢？
在手写体数字识别中，大概会学到这样的特征：
有了隐层学到的这些东西，那么对它进行组合判断就很容易得到输出了，例如发现上面的四个特征均被激活，则如我们所知，其有很大的概率表示数字0。
2、运行机理及实现
在有监督学习中，模型会分为训练阶段和预测阶段，在训练阶段将模型中的待定参数学习出来，然后用在预测阶段，就好像我们初中求解带参方程ax+b=y一样，首先通过已知条件把方程中的参数给求解出来，然后再利用求出来的参数计算给定x下的y值。
在神经网络的训练阶段，主要包括以下几步：
（1）加载训练集；
（2）前向传导，将信息传递给输出层；
（3）利用标注信息和代价函数来计算代价；
（4）通过反向传播代价函数梯度来更新每一层中的参数
其简单实现的整体代码如下：
#coding=utf-8
'''
CreatedonJul20,2016
'''
importnumpyasnp
importrandom
fromsklearnimportdatasets
classNetwork（object）:
def__init__（self,sizes）:
'''
parameters:
sizes中保存了神经网络各层神经元个数
functions:
对神经网络层与层之间的连接参数进行初始化
'''
#权重矩阵
self.weights=[np.random.randn（y,x）forx,yinzip（sizes[:
-1],sizes[1:
]）]
#偏置矩阵
self.biases=[np.random.randn（x）forxinsizes[1:
]]
definit_parameters（self,parameters）:
'''
functions:
初始化模型参数
parameters主要包括:
epochs:
迭代次数
mini_batch_size:
批处理大小
eta:
学习率
nnLayers_size:
神经网络层数
'''
self.epochs=parameters.get（"epochs"）
self.mini_batch_size=parameters.get（"mini_batch_size"）
self.eta=parameters.get（"eta"）
self.nnLayers_size=parameters.get（"nnLayers_size"）
defload_data（self）:
'''
functions:
加载数据集，这里使用的是sklearn自带的digit手写体数据集
'''
digits=datasets.load_digits（）
returndigits.data,digits.target
deffeed_forword（self,data）:
'''
parameters:
data:
输入的图片表示数据，是一个一维向量
functions:
前向传导，将输入传递给输出，y=w*x+b
return:
传递到输出层的结果
'''
forw,binzip（self.weights,self.biases）:
z=np.dot（w,data）+b
data=self.sigmoid（z）
returndata
defsigmoid（self,z）:
'''
functions:
sigmoid函数
'''
return1.0/（1.0+np.exp（-z））
defcrossEntrop（self,a,y）:
'''
parameters:
a:
预测值
y:
真实值
functions:
交叉熵代价函数f=sigma（y*log（1/a））
'''
returnnp.sum（np.nan_to_num（-y*np.log（a）-（1-y）*np.log（1-a）））
defdelta_crossEntrop（self,z,a,y）:
'''
parameters:
z:
激活函数变量
a:
预测值
y:
真实值
'''
returnself.sigmoid（z）-y
defSGD（self,data）:
'''
function:
随即梯度下降算法来对参数进行更新
parameters:
data:
数据集
'''
#数据集大小
data_len=len（list（data））
for_inrange（self.epochs）:
#将数据集按照指定大小划分成小的batch进行梯度训练，mini_batchs中的每个元素相当于一个小的样本集
mini_batchs=[data[k:
k+self.mini_batch_size]forkinrange（0,data_len,self.mini_batch_size）]
formini_batchinmini_batchs:
#batch中的每个样本都会被用来更新参数
self.update_parameter_by_mini_batch（mini_batch）
defupdate_parameter_by_mini_batch（self,mini_batch）:
'''
functions:
按照梯度下降法批量对参数更新
'''
#首先初始化每个参数的偏导数
nabla_w=[np.zeros（w.shape）forwinself.weights]
nabla_b=[np.zeros（b.shape）forbinself.biases]
#将每个样本计算得到的参数偏导数进行累加
formini_x,mini_yinmini_batch:
#每个样本通过后向传播得到两个导数张量，表示对w，b的导数
delta_nabla_w,delta_nabla_b=self.derivative_by_backpropagate（mini_x,mini_y）
nabla_w=[nw+dnwfornw,dnwinzip（nabla_w,delta_nabla_w）]
nabla_b=[nb+dnbfornb,dnbinzip（nabla_b,delta_nabla_b）]
self.weights=[w-self.eta*nwforw,nwinzip（self.weights,nabla_w）]
self.biases=[b-self.eta*nbforb,nbinzip（self.biases,nabla_b）]
defderivative_by_backpropagate（self,x,y）:
'''
functions:
通过后向传播算法来计算每个参数的梯度值
'''
#首先初始化每个参数的偏导数
nabla_w=[np.zeros（w.shape）forwinself.weights]
nabla_b=[np.zeros（b.shape）forbinself.biases]
#激活值列表，元素为经过神经元后的激活输出，也即下一层的输入，此处记录下来用于计算梯度
activations=[x]
#线性组合值列表，元素为未经过神经元前的线性组合,z=w*x+b
zs=[]
#初始输入
activation=x
#首先通过循环得到求导所需要的中间值
forw,binzip（self.weights,self.biases）:
z=np.dot（w,activation）+b
zs.append（z）
activation=self.sigmoid（z）
activations.append（activation）
#倒数第一层的导数计算，有交叉熵求导得来
delta=self.delta_crossEntrop（zs[-1],activations[-1],y）
nabla_w[-1]=np.dot（delta.reshape（len（delta）,1）,activations[-2].reshape（1,len（activations[-2]）））
nabla_b[-1]=delta
#倒数第二层至正数第一层间的导数计算，有sigmoid函数求导得来
foriinrange（2,self.nnLayers_size）:
z=zs[-i]
delta=np.dot（self.weights[-i+1].transpose（）,delta.reshape（len（delta）,1））
delta_z=self.derivative_sigmoid（z）
delta=np.multiply（delta,delta_z.reshape（len（delta_z）,1））
nabla_w[-i]=np.dot（np.transpose（delta）,activations[-i].reshape（len（activations[-i]）,1））
delta=delta.reshape（len（delta））
nabla_b[-i]=delta
return（nabla_w,nabla_b）
defderivative_sigmoid（self,z）:
'''
functions:
对sigmoid求导的结果
'''
returnself.sigmoid（z）*（1-self.sigmoid（z））
defevaluation（self,data）:
'''
functions:
性能评估函数
'''
result=[]
right=0
for（x,y）indata:
output=self.feed_forword（x）
result.append（（np.argmax（output）,np.argmax（y）））
fori,jinresult:
if（i==j）:
right+=1
print（"testdata'ssize:
",len（data））
print（"countofrightprediction",right）
print（"theaccuracy:
",right/len（result））
returnright/len（result）
defsuffle（self,data）:
'''
parameters:
data:
元组数据
functions:
对数据进行打乱重组
'''
new_data=list（data）
random.shuffle（new_data）
returnnp.array（new_data）
deftransLabelToList（self,data_y）:
'''
functions:
将digit数据集中的标签转换成一个10维的列表，方便做交叉熵求导的计算
'''
data=[]
foryindata_y:
item=[0,0,0,0,0,0,0,0,0,0]
item[y]=1
data.append（item）
returndata
if__name__=="__main__":
#神经网络的层数及各层神经元
nnLayers=[64,15,10]
nn=Network（nnLayers）
parameters={"epochs":
50,"mini_batch_size":
10,"eta":
0.01,"nnLayers_size":
len（nnLayers）}
nn.init_parameters（parameters）
#加载数据集
data_x,data_y=nn.load_data（）
#将标签转换成一个10维列表表示，如1表示成[0,1,0,0,0,0,0,0,0,0]
data_y=nn.transLabelToList（data_y）
#将数据打包成元组形式
data=zip（data_x,data_y）
#将有序数据打乱
data=nn.suffle（data）
#将数据集划分为训练集和测试集
train_data=data[:
1500]
test_data=data[1500:
]
nn.SGD（train_data）
print（nn.evaluation（test_data））
接下来，我们会按照神经网络的实现过程来对神经网络进行分析。
第一步，初始化一个神经网络模型
#nnLayers表示神经网络有三层结构，每层的神经元个数分别为64，15，10
nnLayers=[64,15,10]
nn=Network（nnLayers）
#参数词典
parameters={"epochs":
50,"mini_batch_size":
10,"eta":
0.01,"nnLayers_size":
len（nnLayers）}
#初始化参数函数
nn.init_parameters（parameters）
definit_parameters（self,parameters）:
'''
functions:
初始化模型参数
parameters主要包括:
epochs:
迭代次数
mini_batch_size:
批处理大小
eta:
学习率
nnLayers_size:
神经网络层数
'''
self.epochs=parameters.get（"epochs"）
self.mini_batch_size=parameters.get（"mini_batch_size"）
self.eta=parameters.get（"eta"）
self.nnLayers_size=parameters.get（"nnLayers_size"）
我们还要对神经网络中所有的边的权值进行初始化，如下：
def__init__（self,sizes）:
'''
parameters:
sizes中保存了神经网络各层神经元个数
functions:
对神经网络层与层之间的连接参数进行初始化
'''
#权重矩阵
self.weights=[np.random.randn（y,x）forx,yinzip（sizes[:
-1],sizes[1:
]）]
#偏置矩阵
self.biases=[np.random.randn（x）forxinsizes[1:
]]
第二步，加载数据集
要想训练一个模型，数据集是肯定少不了的。
手写体数字识别最出名的数据集当属Lecun提供的mnist数据集，但其数据集不能直接拿来用，且我们只是打算训练一个最简单的三层神经网络，所以使用sklearn自带的digit数据集就非常合适。
加载数据集函数如下：
#加载数据集
data_x,data_y=nn.load_data（）
#将标签转换成一个10维列表表示，如1表示成[0,1,0,0,0,0,0,0,0,0]
data_y=nn.transLabelToList（data_y）
#将数据打包成元组形式
data=zip（data_x,data_y）
#将有序数据打乱
data=nn.suffle（data）
#将数据集划分为训练集和测试集
train_data=data[:
1500]
test_data=data[1500:
]
defload_data（self）:
'''
functions:
加载数据集，这里使用的是sklearn自带的digit手写体数据集
'''
digits=datasets.load_digits（）
returndigits.data,digits.target
该函数返回两个list，分别保存每张手写体的数字化表示和对应的标签。
deftransLabelToList（self,data_y）:
'''
functions:
将digit数据集中的标签转换成一个10维的列表，方便做交叉熵求导的计算
'''
data=[]
foryindata_y:
item=[0,0,0,0,0,0,0,0,0,0]
item[y]=1
data.append（item）
returndata
该函数把原数据集中的标签进行了改写，以方便后续使用。
defsuffle（self,data）:
'''
parameters:
data:
元组数据
functions:
对数据进行打乱重组
'''
new_data=list（data）
random.shuffle（new_data）
returnnp.array（new_data）
因为直接加载后的数据集是按照0-9顺序存放的，我们要通过suffle函数将数据集打乱，并划分为训练集和测试集。
第三步，训练模型参数
这一步是模型的关键，我们需要通过训练集把模型中的参数训练出来，因为里面夹杂了很多矩阵运算和求导运算，为方便说明，这里给出一个简单的三层神经网络，并将里面的参数和变量标注出来，该图如下：
训练直接从调用SGD函数开始，
nn.SGD（train_data）
defSGD（self,data）:
'''
function:
随即梯度下降算法来对参数进行更新
ameters:
data:
数据集
'''
#数据集大小
data_len=len（list（data））
for_inrange（self.epochs）:
#将数据集按照指定大小划分成小的batch进行梯度训练，mini_batchs中的每个元素相当于一个小的样本集
mini_batchs=[data[k:
k+self.mini_batch_size]forkinrange（0,data_len,self.mini_batch_size）]
formini_batchinmini_batchs:
#batch中的每个样本都会被用来更新参数
self.update_parameter_by_mini_batch（mini_batch）
为了加快训练速度，在神经网络中并不是一次将全部数据都拿来训练，而是通过批处理进行逐步更新参数的。
所以在SGD函数中，首先将训练数据集划分成小块数据送update_parameter_by_mini_batch函数进行参数更新操作。
defupdate_parameter_by_mini_batch（self,mini_batch）:
'''
functions:
按照梯度下降法批量对参数更新
'''
#首先初始化每个参数的偏导数
nabla_w=[np.zeros（w.shape）forwinself.weights]
nabla_b=[np.zeros（b.shape）forbinself.biases]
#将每个样本计算得到的参数偏导数进行累加
formini_x,mini_yinmini_batch:
#每个样本通过后向传播得到两个导数张量，表示对w，b的导数
delta_nabla_w,delta_nabla_b=self.derivative_by_backpropagate（mini_x,mini_y）
nabla_w=[nw+dnwfornw,dnwinzip（nabla_w,delta_nabla_w）]
nabla_b=[nb+dnbfornb,dnbinzip（nabla_b,delta_nabla_b）]
#梯度下降法更新参数
self.weights=[w-self.eta*nwforw,nwinzip（self.weights,nabla_w）]
self.biases=[b-self.eta*nbforb,nbinzip（self.biases,nabla_b）]
在该函数中，我们会通过反向传播代价来更新参数，在mini_batch中，我们会把batch中每对样本对各参数的偏导数进行累加作为梯度下降法中的梯度，它不需要每个样本过来都要使用梯度下降法计算一次，这也是使用mini_batch速度能够加快速度的原因。
在上面的函数中，用到了derivative_by_backpropagate来进行反向传播，这个函数是整个模型的关键。
defderivative_by_backpropagate（self,x,y）:
'''
functions:
通过后向传播算法来计算每个参数的梯度值
'''
#首先初始化每个参数的偏导数
nabla_w=[np.zeros（w.shape）forwinself.weights]
nabla_b=[np.zeros（b.shape）forbinself.biases]
#激活值列表，元素为经过神经元后的激活输出，也即下一层的输入，此处记录下来用于计算梯度
activations=[x]
#线性组合值列表，元素为未经过神经元前的线性组合,z=w*x+b
zs=[]
#初始输入
activation=x
#首先通过循环得到求导所需要的中间值
forw,bi
升级会员 