tensorflow下识别手写数字基于MLP网络

 # coding: utf-8

 # In[1]:

 import tensorflow as tf
 import tensorflow.examples.tutorials.mnist.input_data as input_data

 # In[2]:

 mnist = input_data.read_data_sets("MNIST_data/", one_hot=True)

 # In[3]:

 print('train',mnist.train.num_examples,
       ',validation',mnist.validation.num_examples,
       ',test',mnist.test.num_examples)

 # In[4]:

 print('train images     :', mnist.train.images.shape,
       'labels:'           , mnist.train.labels.shape)

 # In[5]:

 import matplotlib.pyplot as plt
 def plot_image(image):
     plt.imshow(image.reshape(28,28),cmap='binary')
     plt.gcf().set_size_inches(2, 4)
     plt.show()

 # In[6]:

 plot_image(mnist.train.images[0])

 # In[7]:

 import numpy as np
 np.argmax(mnist.train.labels[0])

 # In[8]:

 import matplotlib.pyplot as plt
 def plot_images_labels_prediction(images,labels,
                                   prediction,idx,num=10):
     fig = plt.gcf()
     fig.set_size_inches(12, 14)
     if num>25: num=25
     for i in range(0, num):
         ax=plt.subplot(5,5, 1+i)

         ax.imshow(np.reshape(images[idx],(28, 28)),
                   cmap='binary')

         title= "label=" +str(np.argmax(labels[idx]))
         if len(prediction)>0:
             title+=",predict="+str(prediction[idx]) 

         ax.set_title(title,fontsize=10)
         ax.set_xticks([]);ax.set_yticks([])
         idx+=1
     plt.show()

 # In[9]:

 plot_images_labels_prediction(mnist.train.images,
                               mnist.train.labels,[],0)

 # In[10]:

 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([1, output_dim]))
     XWb = tf.matmul(inputs, W) + b
     if activation is None:
         outputs = XWb
     else:
         outputs = activation(XWb)
     return outputs

 # In[11]:

 x = tf.placeholder("float", [None, 784])
 h1=layer(output_dim=256,input_dim=784,
          inputs=x ,activation=tf.nn.relu)
 y_predict=layer(output_dim=10,input_dim=256,
                     inputs=h1,activation=None)
 y_label = tf.placeholder("float", [None, 10])

 # In[12]:

 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)

 # In[13]:

 correct_prediction = tf.equal(tf.argmax(y_label  , 1),
                               tf.argmax(y_predict, 1))
 accuracy = tf.reduce_mean(tf.cast(correct_prediction, "float"))

 # In[14]:

 trainEpochs = 20
 batchSize = 100
 totalBatchs = int(mnist.train.num_examples/batchSize)
 epoch_list=[];loss_list=[];accuracy_list=[]
 from time import time
 startTime=time()
 sess = tf.Session()
 sess.run(tf.global_variables_initializer())

 # In[15]:

 for epoch in range(trainEpochs):
     for i in range(totalBatchs):
         batch_x, batch_y = mnist.train.next_batch(batchSize)
         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+1), "Loss=",                 "{:.9f}".format(loss)," Accuracy=",acc)

 duration =time()-startTime
 print("Train Finished takes:",duration)      

 # In[16]:

 get_ipython().magic('matplotlib inline')
 import matplotlib.pyplot as plt
 fig = plt.gcf()
 fig.set_size_inches(4,2)
 plt.plot(epoch_list, loss_list, label = 'loss')
 plt.ylabel('loss')
 plt.xlabel('epoch')
 plt.legend(['loss'], loc='upper left')

 # In[17]:

 plt.plot(epoch_list, accuracy_list,label="accuracy" )
 fig = plt.gcf()
 fig.set_size_inches(4,2)
 plt.ylim(0.8,1)
 plt.ylabel('accuracy')
 plt.xlabel('epoch')
 plt.legend()
 plt.show()

 # In[18]:

 print("Accuracy:", sess.run(accuracy,
                            feed_dict={x: mnist.test.images,
                                       y_label: mnist.test.labels}))

 # In[19]:

 prediction_result=sess.run(tf.argmax(y_predict,1),
                            feed_dict={x: mnist.test.images })
 prediction_result[:10]

 # In[20]:

 plot_images_labels_prediction(mnist.test.images,
                               mnist.test.labels,
                               prediction_result,0)

 # In[21]:

 y_predict_Onehot=sess.run(y_predict,
                           feed_dict={x: mnist.test.images })
 y_predict_Onehot[8]

 # In[22]:

 for i in range(400):
     if prediction_result[i]!=np.argmax(mnist.test.labels[i]):
         print("i="+str(i)+
               "   label=",np.argmax(mnist.test.labels[i]),
               "predict=",prediction_result[i])

 # In[ ]:

代码如上。

手动建立好输入层，隐层，输出层。

设置损失函数，优化器：

评估方式与准确率：

开始分批次训练：

训练完成后的准确率：

查看某项中的预测概率：

筛选出预测失败的数据：

可以通过：

tf.summary.merge_all()
train_writer = tf.summary.FileWriter('log/area',sess.graph)

保存图。

通过tensorboard --logdir="路径"，打开服务，通过输入localhost:6006之类打开网站。

查看生成的图：