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之类打开网站。

查看生成的图：