神经网络——反向传播BP算法应用案例

案例应用（一）——20个样本的两层（单隐藏层）神经网络

知识点：

1、tolist()

链接：http://blog.csdn.net/akagi_/article/details/76382918

2、axis=0：第0轴表示沿着行垂直向下（列）

axis=1：第1轴表示沿着列的水平方向延伸（行）

3、数据标准化（Normalization）的三种方法：

4、python中列表、数组和矩阵的.sum()函数使用区别

链接：http://blog.csdn.net/zhuzuwei/article/details/77766173

（1）列表使用sum, 对1维列表和二维列表，numpy.sum(a)都能将列表a中的所有元素求和并返回，

a.sum()用法是非法的。

对于1维列表，sum(a)和numpy.sum(a)效果相同，对于二维列表，sum(a)会报错，用法非法。

（2）在数组和矩阵中使用sum: 对数组b和矩阵c,代码 b.sum()，np.sum(b),c.sum(),np.sum(c) 都能将b、c中的所有元素求和并返回单个数值。

但是对于二维数组b，代码b.sum(axis=0)指定对数组b对每列求和，b.sum(axis=1)是对每行求和，

返回的都是一维数组（维度降了一维）。

而对应矩阵c，c.sum(axis=0)和c.sum(axis=1)也能实现对列和行的求和，但是返回结果仍是二维矩阵。

#!/usr/bin/env python
# -*- coding:utf-8 -*-
# Author:ZhengzhengLiu#BP算法案例（2层神经网络，单隐藏层）——输入样本特征3维，输出二分类，样本20个import numpy as np
import matplotlib.pyplot as plt#人数(单位：万人)
population=[20.55,22.44,25.37,27.13,29.45,30.10,30.96,34.06,36.42,38.09,39.13,39.99,41.93,44.59,47.30,52.89,55.73,56.76,59.17,60.63]
#机动车数(单位：万辆)
vehicle=[0.6,0.75,0.85,0.9,1.05,1.35,1.45,1.6,1.7,1.85,2.15,2.2,2.25,2.35,2.5,2.6,2.7,2.85,2.95,3.1]
#公路面积(单位：万平方公里)
roadarea=[0.09,0.11,0.11,0.14,0.20,0.23,0.23,0.32,0.32,0.34,0.36,0.36,0.38,0.49,0.56,0.59,0.59,0.67,0.69,0.79]
#公路客运量(单位：万人)
passengertraffic=[5126,6217,7730,9145,10460,11387,12353,15750,18304,19836,21024,19490,20433,22598,25107,33442,36836,40548,42927,43462]
#公路货运量(单位：万吨)
freighttraffic=[1237,1379,1385,1399,1663,1714,1834,4322,8132,8936,11099,11203,10524,11115,13320,16762,18673,20724,20803,21804]# In[9]:samplein = np.mat([population,vehicle,roadarea])    #3*20维矩阵
'''
[[ 20.55  22.44  25.37  27.13  29.45  30.1   30.96  34.06  36.42  38.0939.13  39.99  41.93  44.59  47.3   52.89  55.73  56.76  59.17  60.63][  0.6    0.75   0.85   0.9    1.05   1.35   1.45   1.6    1.7    1.852.15   2.2    2.25   2.35   2.5    2.6    2.7    2.85   2.95   3.1 ][  0.09   0.11   0.11   0.14   0.2    0.23   0.23   0.32   0.32   0.340.36   0.36   0.38   0.49   0.56   0.59   0.59   0.67   0.69   0.79]]
'''
sampleinminmax = np.array([samplein.min(axis=1).T.tolist()[0],samplein.max(axis=1).T.tolist()[0]]).transpose() #3*2，对应最大值最小值
'''
[[ 20.55  60.63][  0.6    3.1 ][  0.09   0.79]]
'''sampleout = np.mat([passengertraffic,freighttraffic])  #2*20
sampleoutminmax = np.array([sampleout.min(axis=1).T.tolist()[0],sampleout.max(axis=1).T.tolist()[0]]).transpose()#2*2，对应最大值最小值#
#标准化——规范化方法  （x-min)/(max-min）
#3*20
sampleinnorm = (2*(np.array(samplein.T)-sampleinminmax.T[0])/(sampleinminmax.T[1]-sampleinminmax.T[0])-1).transpose()
'''
[[-1.         -0.90568862 -0.75948104 -0.67165669 -0.55588822 -0.52345309-0.48053892 -0.3258483  -0.20808383 -0.1247505  -0.07285429 -0.029940120.06686627  0.1996008   0.33483034  0.61377246  0.75548902  0.806886230.92714571  1.        ][-1.         -0.88       -0.8        -0.76       -0.64       -0.4        -0.32-0.2        -0.12        0.          0.24        0.28        0.32        0.40.52        0.6         0.68        0.8         0.88        1.        ][-1.         -0.94285714 -0.94285714 -0.85714286 -0.68571429 -0.6        -0.6-0.34285714 -0.34285714 -0.28571429 -0.22857143 -0.22857143 -0.171428570.14285714  0.34285714  0.42857143  0.42857143  0.65714286  0.714285711.        ]]
'''
#2*20
sampleoutnorm = (2*(np.array(sampleout.T)-sampleoutminmax.T[0])/(sampleoutminmax.T[1]-sampleoutminmax.T[0])-1).transpose()#给输出样本添加噪音
noise = 0.03*np.random.rand(sampleoutnorm.shape[0],sampleoutnorm.shape[1])
sampleoutnorm += noise#超参数
maxepochs = 60000   #最大迭代次数
learnrate = 0.035   #学习率
errorfinal = 0.65*10**(-3)  #最终迭代误差
samnum = 20  #样本数目
indim = 3   #输入特征维度
outdim = 2  #输出特征维度
hiddenunitnum = 8   #隐藏层单元或节点的数目# 网络参数设计
w1 = 0.5*np.random.rand(hiddenunitnum,indim)-0.1    #8*3维
b1 = 0.5*np.random.rand(hiddenunitnum,1)-0.1        #8*1维
w2 = 0.5*np.random.rand(outdim,hiddenunitnum)-0.1   #2*8维
b2 = 0.5*np.random.rand(outdim,1)-0.1               #2*1维#激活函数
def logsig(x):return 1/(1+np.exp(-x))errhistory = []# hiddenout = logsig(np.dot(w1,sampleinnorm)+b1)
# networkout = np.dot(w2, hiddenout) + b2
# err = sampleoutnorm - networkout
# sse = 1/20*np.sum(1/2*err**2)
# dw2 = 1/20*np.dot(err,hiddenout.transpose()) #2*8维
# db2 = 1/20*np.dot(err,np.ones((samnum,1)))
# db3 = 1/20*np.sum(err,axis=1,keepdims=True)# BP算法遍历
for i in range(maxepochs):#前向传播forward propogation#隐藏层输出(二维数组/矩阵点积转置与不转置结果相同)hiddenout = logsig(np.dot(w1,sampleinnorm)+b1)  #8*20维# hiddenout = logsig((np.dot(w1,sampleinnorm).transpose()+b1.transpose())).transpose()# 输出层输出networkout = np.dot(w2, hiddenout) + b2     #2*20维# networkout = (np.dot(w2,hiddenout).transpose()+b2.transpose()).transpose()# 误差err = sampleoutnorm - networkout    #2*20维#sse = sum(sum(err**2))     #这句等价于下面一句sse = 1/20*np.sum(1/2*err**2)    #目标函数（cost function）sum对数组里面的所有数据求和，变为一个实数errhistory.append(sse)if sse < errorfinal:break#反向传播  backpropogationdz2 = errdz1 = np.dot(w2.transpose(),dz2)*hiddenout*(1-hiddenout)dw2 = 1/20*np.dot(dz2,hiddenout.transpose()) #2*8维db2 = 1 / 20 * np.sum(dz2, axis=1, keepdims=True)   #dz2是2*20维，而db2是2*1维，需要做维度转换，按行求和# db2 = 1/20*np.dot(err,np.ones((samnum,1)))        #这句与上面一句等价dw1 = 1/20*np.dot(dz1,sampleinnorm.transpose())db1 = 1/20*np.sum(dz1,axis=1,keepdims=True)#db1 = np.dot(dz1,np.ones((samnum,1)))w2 += learnrate*dw2b2 += learnrate*db2w1 += learnrate*dw1b1 += learnrate*db1# 误差曲线图
errhistory10 = np.log10(errhistory)
minerr = min(errhistory10)
plt.plot(errhistory10)
plt.plot(range(0,i+1000,1000),[minerr]*len(range(0,i+1000,1000)))ax=plt.gca()
ax.set_yticks([-2,-1,0,1,2,minerr])
ax.set_yticklabels([u'$10^{-2}$',u'$10^{-1}$',u'$1$',u'$10^{1}$',u'$10^{2}$',str(('%.4f'%np.power(10,minerr)))])
ax.set_xlabel('iteration')
ax.set_ylabel('error')
ax.set_title('Error History')
#plt.savefig('errorhistory.png',dpi=700)
plt.show()# 仿真输出和实际输出对比图
hiddenout = logsig((np.dot(w1,sampleinnorm).transpose()+b1.transpose())).transpose()
networkout = (np.dot(w2,hiddenout).transpose()+b2.transpose()).transpose()
diff = sampleoutminmax[:,1]-sampleoutminmax[:,0]
networkout2 = (networkout+1)/2
networkout2[0] = networkout2[0]*diff[0]+sampleoutminmax[0][0]
networkout2[1] = networkout2[1]*diff[1]+sampleoutminmax[1][0]sampleout = np.array(sampleout)fig,axes = plt.subplots(nrows=2,ncols=1,figsize=(12,10))
line1, =axes[0].plot(networkout2[0],'k',marker = u'$\circ$')
line2, = axes[0].plot(sampleout[0],'r',markeredgecolor='b',marker = u'$\star$',markersize=9)axes[0].legend((line1,line2),('simulation output','real output'),loc = 'upper left')yticks = [0,20000,40000,60000]
ytickslabel = [u'$0$',u'$2$',u'$4$',u'$6$']
axes[0].set_yticks(yticks)
axes[0].set_yticklabels(ytickslabel)
axes[0].set_ylabel(u'passenger traffic$(10^4)$')xticks = range(0,20,2)
xtickslabel = range(1990,2010,2)
axes[0].set_xticks(xticks)
axes[0].set_xticklabels(xtickslabel)
axes[0].set_xlabel(u'year')
axes[0].set_title('Passenger Traffic Simulation')line3, = axes[1].plot(networkout2[1],'k',marker = u'$\circ$')
line4, = axes[1].plot(sampleout[1],'r',markeredgecolor='b',marker = u'$\star$',markersize=9)
axes[1].legend((line3,line4),('simulation output','real output'),loc = 'upper left')
yticks = [0,10000,20000,30000]
ytickslabel = [u'$0$',u'$1$',u'$2$',u'$3$']
axes[1].set_yticks(yticks)
axes[1].set_yticklabels(ytickslabel)
axes[1].set_ylabel(u'freight traffic$(10^4)$')xticks = range(0,20,2)
xtickslabel = range(1990,2010,2)
axes[1].set_xticks(xticks)
axes[1].set_xticklabels(xtickslabel)
axes[1].set_xlabel(u'year')
axes[1].set_title('Freight Traffic Simulation')#fig.savefig('simulation.png',dpi=500,bbox_inches='tight')
plt.show()

案例应用（二）——神经网络实现线性回归（应用tensorflow）
知识点：

1、tf.Variable 变量（一种特殊数据，在图中有固定位置，不像普通张量可以流动，如w、b等）

2、tf.random_uniform

3、tf.reduce_mean()

4、优化器Optimizer

详细见链接：http://blog.csdn.net/xierhacker/article/details/53174558

深度学习常见的是对于梯度的优化，也就是说，优化器最后其实就是各种对于梯度下降算法的优化。

5、tf.global_variables_initializer()——初始化所有变量

#!/usr/bin/env python
# -*- coding:utf-8 -*-
# Author:ZhengzhengLiu#神经网络实现线性回归（应用tensorflow）import tensorflow as tf
import numpy as np
import matplotlib.pyplot as plt#随即生成1000个点，围绕在直线y=0.1x+0.3范围num_points = 1000
vectors_set = []
for i in range(num_points):x1 = np.random.normal(0.0,0.55)     #生成均值为0.0，方差为0.55的高斯分布y1 = x1*0.1+0.3+np.random.normal(0.0,0.03)  #添加一些抖动vectors_set.append([x1,y1])#生成这些样本并画图
x_data = [v[0] for v in vectors_set]
y_data = [v[1] for v in vectors_set]#由这1000个点逆推线性回归中y=wx+b中的w和b的值
# tf.Variable  变量（一种特殊数据，在图中有固定位置，不像普通张量可以流动，如w、b等）#生成只有一个元素的w一阶张量，取值是[-1,1]之间的随机数
W = tf.Variable(tf.random_uniform([1],-1.0,1.0),name="W")#生成只有一个元素的b一阶张量,初始值是0
b = tf.Variable(tf.zeros([1]),name="b")#前向传播过程——FP
#经过计算得到预估值
y = W * x_data+b#下面操作完成BP过程
#以预估值y与实际值y_data之间的均方差作为损失值
loss = tf.reduce_mean(tf.square(y-y_data),name="loss")
#采用梯度下降来优化参数，学习率为0.5
optimizer= tf.train.GradientDescentOptimizer(0.5)
#训练过程就是最小化这个误差值
train = optimizer.minimize(loss,name="train")#建立会话机制
sess = tf.Session()
#初始化所有变量
init = tf.global_variables_initializer()
sess.run(init)
#打印初始化的W和b
print("==========初始化的W和b==========")
print("W=",sess.run(W),"b=",sess.run(b),"loss=",sess.run(loss))#执行100次训练
for step in range(100):sess.run(train)#输出每次训练好的W和b的值print("第%d次训练"%step,"W=",sess.run(W),"b=",sess.run(b),"loss=",sess.run(loss))#画图
plt.scatter(x_data,y_data,c="r")
plt.plot(x_data,sess.run(W)*x_data+sess.run(b))
plt.show()

案例应用（三）——神经网络实现softmax回归手写数字（MNIST）识别案例（应用tensorflow）

1、数据集MNIST

input.py文件具体代码为：

#!/usr/bin/env python
# -*- coding:utf-8 -*-
# Author:ZhengzhengLiufrom __future__ import absolute_import
from __future__ import division
from __future__ import print_functionimport gzip
import os
import tempfileimport numpy
from six.moves import urllib
from six.moves import xrange  # pylint: disable=redefined-builtin
import tensorflow as tf
from tensorflow.contrib.learn.python.learn.datasets.mnist import read_data_sets

2、softmax回归

3、模型实现

4、epoch、iteration和batchsize的概念及关系

（1）batchsize：批大小。每次训练在训练集中采取batchsize个样本来训练

（2）iteration：使用batchsize个样本训练一次

（3）epoch：使用训练集中全部样本训练一次

举例：1000个样本，m=1000.假设batchsize=10，则要100次迭代，即：iteration=100

1次epoch。

总结：iteration = m（样本数目）/batchsize

1次epoch遍历，训练样本重复迭代iteration次。

#!/usr/bin/env python
# -*- coding:utf-8 -*-
# Author:ZhengzhengLiu#神经网络实现softmax回归手写数字识别案例（应用tensorflow）import tensorflow as tf
import numpy as np
import matplotlib.pyplot as plt
import input_data   #引入MNIST手写数字库#1、读取数据文件
minist = input_data.read_data_sets("MNIST_data/",one_hot=True)  #标签数据采用独热编码
print(minist)#下载下来的数据集被分三个子集：
#5.5W行的训练数据集（mnist.train），
#5千行的验证数据集（mnist.validation)
#1W行的测试数据集（mnist.test）。
#每张图片为28x28的黑白图片，所以每行为784维的向量train_img = minist.train.images
train_label = minist.train.labelstest_img = minist.test.images
test_label = minist.test.labelsprint("训练集图片维度:",train_img.shape)
print("训练集标签维度:",train_label.shape)
print("测试集图片维度:",test_img.shape)
print("测试集标签维度:",test_label.shape)
print(minist.train.next_batch)#2、实现softmax回归模型
#placeholder:占位符，MNIST图像每一张784维行向量，None表示任意多维度
x = tf.placeholder("float",[None,784])  #输入值
y = tf.placeholder("float",[None,10])   #输出值（真实值）
#Variable:可修改的张量，可用于计算输入可在计算中被修改,模型的参数可用Variable表示
#用全为零的张量来初始化参数W和b的值
W = tf.Variable(tf.zeros([784,10]),name="W") #想用784维的图片向量乘以W得到一个10维的向量
b = tf.Variable(tf.zeros([1,10]),name="b")    #b  [10]表示10分类
#softmax
#正向传播FP
actv = tf.nn.softmax(tf.matmul(x,W)+b)#3、模型训练——反向传播BP
#成本函数用采用交叉熵，y和actv的维度都为[None,10]，reduction_indices表示按行（样本数目）求和
cost = tf.reduce_mean(-tf.reduce_sum(y*tf.log(actv),reduction_indices=1))
#学习率
learn_rate = 0.01
#使用梯度下降最小化成本函数，训练参数W和b
optm = tf.train.GradientDescentOptimizer(learn_rate).minimize(cost)#4、模型评估
#tf.arg_max:按行或者按列求出最大值所在的索引值，1：表示按行求最大值
#tf.equal：比较矩阵是否相等，相等返回True，反之，则为false
pred = tf.equal(tf.arg_max(y,1),tf.arg_max(actv,1))
#正确率
accr = tf.reduce_mean(tf.cast(pred,"float"))    #将布尔型的预测转换成float类型# 运行迭代之前，初始化所有变量
init = tf.initialize_all_variables()#session会话机制，启动模型
sess = tf.Session()
sess.run(init)#5、训练迭代
#epochs次数,一个epochs是：使用训练机全部样本训练一次
training_epochs = 50
#批尺寸
batch_size = 100
#全部样本迭代多少次（每隔display_step个epoch）后显示目前状态
display_step = 5#mini_batch(小批量梯度下降):一次epoch遍历，训练重复迭代iteration次
#举例：1000个样本，batchsize=10,100次迭代iteration，1次epoch
for epoch in range(training_epochs):#平均误差avg_cost = 0.#一个iteration：使用batch_size个样本训练一次，整个数据集要迭代多少次   55000/100iteration = int(minist.train.num_examples/batch_size)for i in range(iteration):# 获取数据集 next_batch获取下一批的数据batch_xs,batch_ys = minist.train.next_batch(batch_size)#模型训练# feeds = {x: batch_xs, y: batch_ys}# sess.run(optm, feed_dict=feeds)sess.run(optm,feed_dict={x:batch_xs,y:batch_ys})avg_cost += sess.run(cost,feed_dict={x:batch_xs,y:batch_ys})/iteration#全部样本迭代display_step次进行一次显示当前的损失以及准确率if epoch % display_step == 0:feeds_train = {x:batch_xs,y:batch_ys}feeds_test = {x:minist.test.images,y:minist.test.labels}#输出正确率train_accr = sess.run(accr,feed_dict=feeds_train)test_accr = sess.run(accr,feed_dict=feeds_test)print("Epoch:%03d/%03d cost:%.9f train_accr:%.3f test_accr:%.3f"%(epoch,training_epochs,avg_cost,train_accr,test_accr))print("W:", sess.run(W))print("b:", sess.run(b))print("*"*20)
print("DONE")#运行结果：
Extracting MNIST_data/train-images-idx3-ubyte.gz
Extracting MNIST_data/train-labels-idx1-ubyte.gz
Extracting MNIST_data/t10k-images-idx3-ubyte.gz
Extracting MNIST_data/t10k-labels-idx1-ubyte.gz
Datasets(train=<tensorflow.contrib.learn.python.learn.datasets.mnist.DataSet object at 0x00000000011ED7B8>, validation=<tensorflow.contrib.learn.python.learn.datasets.mnist.DataSet object at 0x000000000C0798D0>, test=<tensorflow.contrib.learn.python.learn.datasets.mnist.DataSet object at 0x000000000C079978>)
训练集图片维度: (55000, 784)
训练集标签维度: (55000, 10)
测试集图片维度: (10000, 784)
测试集标签维度: (10000, 10)
Epoch:000/050 cost:1.176831373 train_accr:0.750 test_accr:0.853
W: [[ 0.  0.  0. ...,  0.  0.  0.][ 0.  0.  0. ...,  0.  0.  0.][ 0.  0.  0. ...,  0.  0.  0.]..., [ 0.  0.  0. ...,  0.  0.  0.][ 0.  0.  0. ...,  0.  0.  0.][ 0.  0.  0. ...,  0.  0.  0.]]
b: [[-0.03770958  0.08092883 -0.02169059 -0.02095913  0.01895759  0.03047678-0.00933352  0.03237541 -0.067066   -0.00597981]]
********************
Epoch:005/050 cost:0.441020201 train_accr:0.920 test_accr:0.895
W: [[ 0.  0.  0. ...,  0.  0.  0.][ 0.  0.  0. ...,  0.  0.  0.][ 0.  0.  0. ...,  0.  0.  0.]..., [ 0.  0.  0. ...,  0.  0.  0.][ 0.  0.  0. ...,  0.  0.  0.][ 0.  0.  0. ...,  0.  0.  0.]]
b: [[-0.08280824  0.17163301 -0.0378321  -0.06216912  0.04958322  0.17499715-0.01772536  0.11357884 -0.26959965 -0.03965827]]
********************
Epoch:010/050 cost:0.383393081 train_accr:0.940 test_accr:0.905
W: [[ 0.  0.  0. ...,  0.  0.  0.][ 0.  0.  0. ...,  0.  0.  0.][ 0.  0.  0. ...,  0.  0.  0.]..., [ 0.  0.  0. ...,  0.  0.  0.][ 0.  0.  0. ...,  0.  0.  0.][ 0.  0.  0. ...,  0.  0.  0.]]
b: [[-0.11012979  0.20967351 -0.03563696 -0.08677705  0.0589775   0.29126397-0.02297049  0.16979647 -0.41462633 -0.05957233]]
********************
Epoch:015/050 cost:0.357317106 train_accr:0.900 test_accr:0.909
W: [[ 0.  0.  0. ...,  0.  0.  0.][ 0.  0.  0. ...,  0.  0.  0.][ 0.  0.  0. ...,  0.  0.  0.]..., [ 0.  0.  0. ...,  0.  0.  0.][ 0.  0.  0. ...,  0.  0.  0.][ 0.  0.  0. ...,  0.  0.  0.]]
b: [[-0.13363008  0.23510975 -0.0297463  -0.10593367  0.06084103  0.39166909-0.02738102  0.21704797 -0.53100455 -0.07697465]]
********************
Epoch:020/050 cost:0.341451609 train_accr:0.860 test_accr:0.912
W: [[ 0.  0.  0. ...,  0.  0.  0.][ 0.  0.  0. ...,  0.  0.  0.][ 0.  0.  0. ...,  0.  0.  0.]..., [ 0.  0.  0. ...,  0.  0.  0.][ 0.  0.  0. ...,  0.  0.  0.][ 0.  0.  0. ...,  0.  0.  0.]]
b: [[-0.15468769  0.25476453 -0.02259419 -0.12311506  0.06071635  0.48368892-0.03233586  0.25885972 -0.63206619 -0.09323484]]
********************
Epoch:025/050 cost:0.330557310 train_accr:0.930 test_accr:0.914
W: [[ 0.  0.  0. ...,  0.  0.  0.][ 0.  0.  0. ...,  0.  0.  0.][ 0.  0.  0. ...,  0.  0.  0.]..., [ 0.  0.  0. ...,  0.  0.  0.][ 0.  0.  0. ...,  0.  0.  0.][ 0.  0.  0. ...,  0.  0.  0.]]
b: [[-0.17370966  0.26752645 -0.01357625 -0.13669413  0.05872518  0.56635588-0.03811283  0.29731038 -0.72129518 -0.10653554]]
********************
Epoch:030/050 cost:0.322338095 train_accr:0.890 test_accr:0.916
W: [[ 0.  0.  0. ...,  0.  0.  0.][ 0.  0.  0. ...,  0.  0.  0.][ 0.  0.  0. ...,  0.  0.  0.]..., [ 0.  0.  0. ...,  0.  0.  0.][ 0.  0.  0. ...,  0.  0.  0.][ 0.  0.  0. ...,  0.  0.  0.]]
b: [[-0.19247559  0.27978855 -0.00483049 -0.15001576  0.05658424  0.64244586-0.04321598  0.33084908 -0.79931128 -0.11982626]]
********************
Epoch:035/050 cost:0.315975045 train_accr:0.910 test_accr:0.917
W: [[ 0.  0.  0. ...,  0.  0.  0.][ 0.  0.  0. ...,  0.  0.  0.][ 0.  0.  0. ...,  0.  0.  0.]..., [ 0.  0.  0. ...,  0.  0.  0.][ 0.  0.  0. ...,  0.  0.  0.][ 0.  0.  0. ...,  0.  0.  0.]]
b: [[-0.21010886  0.28931084  0.00489429 -0.16127652  0.05297195  0.71280587-0.04843408  0.36301994 -0.87218767 -0.1310018 ]]
********************
Epoch:040/050 cost:0.310735948 train_accr:0.920 test_accr:0.918
W: [[ 0.  0.  0. ...,  0.  0.  0.][ 0.  0.  0. ...,  0.  0.  0.][ 0.  0.  0. ...,  0.  0.  0.]..., [ 0.  0.  0. ...,  0.  0.  0.][ 0.  0.  0. ...,  0.  0.  0.][ 0.  0.  0. ...,  0.  0.  0.]]
b: [[-0.22672468  0.29810169  0.0139696  -0.17220686  0.0496463   0.77722383-0.05270857  0.39246288 -0.93745178 -0.14231744]]
********************
Epoch:045/050 cost:0.306350076 train_accr:0.960 test_accr:0.918
W: [[ 0.  0.  0. ...,  0.  0.  0.][ 0.  0.  0. ...,  0.  0.  0.][ 0.  0.  0. ...,  0.  0.  0.]..., [ 0.  0.  0. ...,  0.  0.  0.][ 0.  0.  0. ...,  0.  0.  0.][ 0.  0.  0. ...,  0.  0.  0.]]
b: [[-0.24226196  0.30532056  0.02280276 -0.18276472  0.04469334  0.83779395-0.05765147  0.42132133 -0.99635118 -0.15290719]]
********************
DONE

案例应用（四）——浅层神经网络（三层，两层隐藏层和一层输出层）

应用tensorflow实现手写数字识别

知识点：

1、softmax_cross_entropy_with_logits()函数

#!/usr/bin/env python
# -*- coding:utf-8 -*-
# Author:ZhengzhengLiu#浅层神经网络(三层，两个隐藏层和一个输出层)实现手写数字识别import numpy as np
import matplotlib.pyplot as plt
import tensorflow as tf
import input_data       #引入MNIST手写数字库#1、加载数据，在input_data.py中
mnist = input_data.read_data_sets("MNIST_data/",one_hot=True)#2、神经网络模型
n_hidden_1 = 256    #第一个隐藏层神经单元的数目
n_hidden_2 = 128    #第二个隐藏层神经单元的数目
n_put = 784         #每张图片为28x28的黑白图片，输入像素数目为784
n_classes = 10      #输出的标签label的维度，,0的独热编码为：[1 0 0 0 0 0 0 0 0 0]#placeholder:占位符，None表示任意多维度
x = tf.placeholder("float",[None,n_put])         #输入值
y = tf.placeholder("float",[None,n_classes])    #输出值#神经网络模型参数设置，两个隐藏层，初始化参数数据stddev = 0.1    #标准差#权重w(用字典存储各层的权重值)
weights = {#tf.random_normal 生成一个tensor其中的元素的值服从正态分布#tf.random_normal(shape,stddev)，stddev 基于样本估算标准偏差#模型的参数可用Variable表示"w1":tf.Variable(tf.random_normal([n_put,n_hidden_1],stddev=stddev)),"w2":tf.Variable(tf.random_normal([n_hidden_1,n_hidden_2],stddev=stddev)),"w3":tf.Variable(tf.random_normal([n_hidden_2,n_classes],stddev=stddev))
}#偏向b
biases = {"b1":tf.Variable(tf.random_normal([n_hidden_1])),"b2":tf.Variable(tf.random_normal([n_hidden_2])),"b3":tf.Variable(tf.random_normal([n_classes]))
}#(1)正向传播（FP），只对两个隐藏层做激活函数处理
def multilayer_perceotron(_X,_weights,_biases):a1 = tf.nn.sigmoid(tf.add(tf.matmul(_X,_weights["w1"]),_biases["b1"]))a2 = tf.nn.sigmoid(tf.add(tf.matmul(a1,_weights["w2"]),_biases["b2"]))# 返回的是10个输出,最后的输出层不加激活函数，用softmax进行多分类return (tf.matmul(a2,_weights["w3"])+_biases["b3"])pred = multilayer_perceotron(x,weights,biases)#(2)反向传播（BP）
#损失函数 softmax_cross_entropy_with_logits，中0.x版本和1.x不同的是1.x要加logits和labels
#softmax_cross_entropy_with_logits函数作用：计算logits经softmax激活后的交叉熵
#logits，它的shape是[batch_size,n_classes] 一般是神经网络的最后一层输出
#labels，它的shape也是[batch_size,n_classes] ，实际输出的标签值
#tf把softmax和cross_entropy计算放在一起用一个函数来实现，提高程序运行速度。
cost = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(logits=pred,labels=y))
#使用梯度下降最小化成本函数，训练参数W和b
optm = tf.train.GradientDescentOptimizer(learning_rate=0.001).minimize(cost)#3、模型评估
#tf.arg_max:按行或者按列求出最大值所在的索引值，1：表示按行求最大值
#tf.equal：比较矩阵是否相等，相等返回True，反之，则为false
corr = tf.equal(tf.arg_max(pred,1),tf.arg_max(y,1))
#正确率
accr = tf.reduce_mean(tf.cast(corr,"float"))    #将布尔型的corr转换成float类型# 运行迭代之前，初始化所有变量
init = tf.global_variables_initializer()
#session会话机制，启动模型
sess = tf.Session()
sess.run(init)#4、执行训练的模型
#epochs次数,一个epochs是：使用训练机全部样本训练一次
training_epochs = 50
#批尺寸
batch_size = 100
#全部样本迭代多少次（每隔display_step个epoch）后显示目前状态
display_step = 5#mini_batch(小批量梯度下降):一次epoch遍历，训练重复迭代iteration次
#举例：1000个样本，batchsize=10,100次迭代iteration，1次epoch
for epoch in range(training_epochs):avg_cost = 0.# 一个iteration：使用batch_size个样本训练一次，整个数据集要迭代多少次   55000/100iteration = int(mnist.train.num_examples/batch_size)for i in range(iteration):# 获取数据集 next_batch获取下一批的数据batch_xs,batch_ys = mnist.train.next_batch(batch_size)# 模型训练sess.run(optm,feed_dict={x:batch_xs,y:batch_ys})avg_cost += sess.run(cost,feed_dict={x:batch_xs,y:batch_ys})avg_cost /= iteration# 全部样本迭代duisplay_step次显示一次当前的损失以及准确率if epoch % display_step == 0:feed_train = {x:batch_xs,y:batch_ys}feed_test = {x:mnist.test.images,y:mnist.test.labels}#正确率train_accr = sess.run(accr,feed_dict=feed_train)test_accr = sess.run(accr,feed_dict=feed_test)print("Epoch:%03d/%03d cost:%.9f train_accr:%.3f test_accr:%.3f"%(epoch,training_epochs,avg_cost,train_accr,test_accr))# print("W:",sess.run(weights))# print("b:",sess.run(biases))print("*"*20)print ("OPTIMIZATION FINISHED")
#运行结果：
Extracting MNIST_data/train-images-idx3-ubyte.gz
Extracting MNIST_data/train-labels-idx1-ubyte.gz
Extracting MNIST_data/t10k-images-idx3-ubyte.gz
Extracting MNIST_data/t10k-labels-idx1-ubyte.gz
Epoch:000/050 cost:2.413839944 train_accr:0.100 test_accr:0.108
********************
Epoch:005/050 cost:2.256547526 train_accr:0.230 test_accr:0.249
********************
Epoch:010/050 cost:2.208265470 train_accr:0.360 test_accr:0.411
********************
Epoch:015/050 cost:2.151324805 train_accr:0.490 test_accr:0.511
********************
Epoch:020/050 cost:2.081211740 train_accr:0.490 test_accr:0.555
********************
Epoch:025/050 cost:1.994214419 train_accr:0.510 test_accr:0.606
********************
Epoch:030/050 cost:1.889150947 train_accr:0.600 test_accr:0.633
********************
Epoch:035/050 cost:1.768870280 train_accr:0.610 test_accr:0.659
********************
Epoch:040/050 cost:1.639974271 train_accr:0.650 test_accr:0.691
********************
Epoch:045/050 cost:1.510463864 train_accr:0.740 test_accr:0.720
********************
OPTIMIZATION FINISHED

神经网络——反向传播BP算法应用案例相关推荐

神经网络反向传播BP算法举例说明
0. 前言上篇博客对BP算法的大致步骤进行了总结,本篇博客将通过一个具体的例子来模拟一下这个算法的实现过程 ! 1. BP算法例子说明 1.1 网络结构 1.2 权重及偏移 w = ( 0.1 , ...
深度学习图像处理目标检测图像分割计算机视觉 04--神经网络与误差反向传播BP算法
深度学习图像处理目标检测图像分割计算机视觉 04--神经网络与误差反向传播BP算法摘要一.神经元二.前馈网络 2.1 Delta学习规则 2.2 目标函数J(w) 三.误差反向传播算法(BP算法 ...
反向传播BP 算法之一种直观的解释
0. 前言之前上模式识别课程的时候,老师也讲过 MLP 的 BP 算法, 但是 ppt 过得太快,只有一个大概印象.后来课下自己也尝试看了一下 stanford deep learning 的 wi ...
多层感知机Perceptron反向传播BP算法推导（Back Propagation）
看了很多BP的推导,都不够简洁直观,这里总结一下.多层Perceptron就是全连接的网络,定义第l层的输入为x(l)x^{(l)}x(l),那么全连接的线性输出z(l)=W(l)x(l)+b(l)z ...
【机器学习笔记】神经网络反向传播算法推导
神经网络反向传播算法推导 (一) 概念及基本思想 (二)信息的前向传播 (三)误差反向传播 (1)输出层的权重参数更新 (2)隐藏层的权重参数更新 (3)输出层与隐藏层的偏置参数更新 (4)反向传播 ...
神经网络反向传播的作用,双向传播的神经网络
如何理解神经网络里面的反向传播算法反向传播算法(Backpropagation)是目前用来训练人工神经网络(ArtificialNeuralNetwork,ANN)的最常用且最有效的算法. 其主要思 ...
人工神经网络反向传播,神经网络后向传播
如何理解神经网络里面的反向传播算法反向传播算法(Backpropagation)是目前用来训练人工神经网络(ArtificialNeuralNetwork,ANN)的最常用且最有效的算法. 其主要思 ...
神经网络前向传播过程,神经网络反向传播
正向传播反向传播是什么? 题主问的应该是神经网络中的问题.正向传播是指数据从X传入到神经网络,经过各个隐藏层得到最终损失的过程. 反向传播主要是针对神经网络优化的过程中进行,在L端计算总的损失函数,然 ...
cnn卷积神经网络反向传播,cnn正向传播和反向传播
如何对CNN网络的卷积层进行反向传播在多分类中,CNN的输出层一般都是Softmax.RBF在我的接触中如果没有特殊情况的话应该是"径向基函数"(RadialBasisFunct ...

神经网络——反向传播BP算法应用案例

神经网络——反向传播BP算法应用案例相关推荐

最新文章

热门文章