TensorFlow—多层感知器—MNIST手写数字识别

  1 import tensorflow as tf
 import tensorflow.examples.tutorials.mnist.input_data as input_data
 import matplotlib.pyplot as plt
 import numpy as np
 mnist=input_data.read_data_sets("MNIST_data/",one_hot=True)           #下载据数
 print('train images:',mnist.train.images.shape,                       #查看数据
      'labels:',mnist.train.labels.shape)
 print('validation images:',mnist.validation.images.shape,
      'labels:',mnist.validation.labels.shape)
 print('test images:',mnist.test.images.shape,
      'labels:',mnist.test.labels.shape
 #定义显示多项图像的函数
 def plot_images_labels_prediction_3(images,labels,prediction,idx,num=):
     fig=plt.gcf()
     fig.set_size_inches(,)
     if num>:num=
     for i in range(,num):
         ax=plt.subplot(,,i+)
         ax.imshow(np.reshape(images[idx],(,)),cmap='binary')
         title='lable='+str(np.argmax(labels[idx]))
         if len(prediction)>:
             title+=",prediction="+str(prediction[idx])
         ax.set_title(title,fontsize=)
         ax.set_xticks([]);ax.set_yticks([])
         idx+=
     plt.show()

 plot_images_labels_prediction_3(mnist.train.images,mnist.train.labels,[],)
 #定义layer函数，构建多层感知器模型
 def layer(output_dim,input_dim,inputs,activation=None):
     W=tf.Variable(tf.random_normal([input_dim,output_dim]))
     b=tf.Variable(tf.random_normal([,output_dim]))
     XWb=tf.matmul(inputs,W)+b
     if activation is None:
         outputs=XWb
     else:
         outputs=activation(XWb)
     return outputs
 #建立输入层
 x=tf.placeholder("float",[None,])
 #建立隐藏层
 h1=layer(output_dim=,input_dim=,inputs=x,
        activation=tf.nn.relu)
 #建立输出层
 y_predict=layer(output_dim=,input_dim=,inputs=h1,
         activation=None)
 y_label=tf.placeholder("float",[None,])
 #定义损失函数
 loss_function=tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits
                              (logits=y_predict,
                               labels=y_label))
 #定义优化器
 optimizer=tf.train.AdamOptimizer(learning_rate=0.001).minimize(loss_function)
 #计算每一项数据是否预测正确
 correct_prediction=tf.equal(tf.argmax(y_label,),
                             tf.argmax(y_predict,))
 #计算预测正确结果的平均值
 accuracy=tf.reduce_mean(tf.cast(correct_prediction,"float"))
 #、定义训练参数
 trainEpochs=                                   #设置执行15个训练周期
 batchSize=                                    #每一批次项数为100
 totalBatchs=int(mnist.train.num_examples/batchSize)        #计算每个训练周期
 loss_list=[];epoch_list=[];accuracy_list=[]      #初始化训练周期、误差、准确率
 from time import time                            #导入时间模块
 startTime=time()                                 #开始计算时间
 sess=tf.Session()                                #建立Session
 sess.run(tf.global_variables_initializer())       #初始化TensorFlow global 变量
 #、进行训练
 for epoch in range(trainEpochs):
     for i in range(totalBatchs):
         batch_x,batch_y=mnist.train.next_batch(batchSize)  #使用mnist.train.next_batch方法读取批次数据，传入参数batchSize是100
         sess.run(optimizer,feed_dict={x:batch_x,
                                       y_label:batch_y})    #执行批次训练
     loss,acc=sess.run([loss_function,accuracy],            #使用验证数据计算准确率
                       feed_dict={x:mnist.validation.images,
                                  y_label:mnist.validation.labels})
     epoch_list.append(epoch);                              #加入训练周期列表
     loss_list.append(loss)                                 #加入误差列表
     accuracy_list.append(acc)                              #加入准确率列表
     print("Train Epoch:",'%02d' % (epoch+),"Loss=",\
           "{:.9f}".format(loss),"Accuracy=",acc)
 duration=time()-startTime
 print("Train Finished takes:",duration)                    #计算并显示全部训练所需时间
 #画出误差执行结果

 fig=plt.gcf()
 fig.set_size_inches(,)
 plt.plot(epoch_list,loss_list,label='loss')
 plt.ylabel('loss')
 plt.xlabel('epoch')
 plt.legend(['loss'],loc='upper left')
 #画出准确率执行结果
 plt.plot(epoch_list,accuracy_list,label="accuracy")
 fig=plt.gcf()
 fig.set_size_inches(,)
 plt.ylim(0.8,)
 plt.ylabel('accuracy')
 plt.xlabel('epoch')
 plt.legend()
 plt.show()
 #评估模型准确率
 print("accuracy:",sess.run(accuracy,
                            feed_dict={x:mnist.test.images,
                                       y_label:mnist.test.labels}))
 #进行预测
 #.执行预测
 prediction_result=sess.run(tf.argmax(y_predict,),
                            feed_dict={x:mnist.test.images})
 #.预测结果
 print(prediction_result[:])
 #.显示前10项预测结果
 plot_images_labels_prediction_3(mnist.test.images,
                               mnist.test.labels,
                               prediction_result,)

运行结果：