keras框架的MLP手写数字识别MNIST，梳理？

keras框架的MLP手写数字识别MNIST

代码：

# coding: utf-8

# In[1]:


import numpy as np
import pandas as pd

from keras.utils import np_utils
np.random.seed(10)


# In[2]:


from keras.datasets import mnist


# In[3]:


(x_train_image,y_train_label),(x_test_image,y_test_label) = mnist.load_data()


# In[4]:


import matplotlib.pyplot as plt
def plot_image(image):
    fig = plt.gcf()
    fig.set_size_inches(1,1)
    plt.imshow(image,cmap='binary')
    plt.show()


# In[5]:


plot_image(x_train_image[0])
y_train_label[0]


# In[6]:


def plot_image_labels_prediction(images,labels,prediction,idx,num=10):
    fig = plt.gcf()
    fig.set_size_inches(12,24)
    if num>50 : num = 50
    for i in range(0,num):
        ax = plt.subplot(10,5,1+i)
        ax.imshow(images[idx],cmap='binary')
        title = "lable="+str(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[7]:


plot_image_labels_prediction(x_train_image,y_train_label,[],0,10)


# In[8]:


x_train = x_train_image.reshape(60000,784).astype('float32')
x_test = x_test_image.reshape(10000,784).astype('float32')


# In[9]:


x_train_normalize = x_train/255
x_test_normalize = x_test/255


# In[10]:


y_train_oneHot = np_utils.to_categorical(y_train_label)
y_test_oneHot = np_utils.to_categorical(y_test_label)


# In[11]:


from keras.models import Sequential
from keras.layers import Dense
from keras.layers import Dropout


# In[12]:


model = Sequential()


# In[13]:


model.add(Dense(units = 1000, 
                input_dim=784,
               kernel_initializer = 'normal',
               activation = 'relu'))


# In[14]:



model.add(Dropout(0.5))


# In[15]:


model.add(Dense(units = 10, 
               kernel_initializer = 'normal',
               activation = 'sigmoid'))


# In[16]:


print(model.summary())


# In[17]:


model.compile(loss='categorical_crossentropy',
             optimizer='adam',metrics=['accuracy'])


# In[18]:


train_history = model.fit(x=x_train_normalize,
                         y=y_train_oneHot,
                         validation_split = 0.2,
                         epochs = 10,
                         batch_size = 200,
                         verbose = 2)


# In[19]:


def show_train_history(train_history,train,validation):
    plt.plot(train_history.history[train])
    plt.plot(train_history.history[validation])
    plt.title('Train_History')
    plt.ylabel(train)
    plt.xlabel('Epoch')
    plt.legend(['train','validation'], loc = 'upper left')
    plt.show()


# In[20]:


show_train_history(train_history,'acc','val_acc')


# In[21]:


score = model.evaluate(x_test_normalize,y_test_oneHot)
print()
print('accurary=',score[1])


# In[22]:


prediction = model.predict_classes(x_test_normalize)


# In[23]:


prediction


# In[24]:


plot_image_labels_prediction(x_test_image,
                             y_test_label,
                             prediction,
                             0,
                            50)


# In[25]:


pd.crosstab(y_test_label,
            prediction,
           rownames=['label'],
           colnames=['predict'])


# In[ ]:





# In[ ]:

MLP多层感知器 Multi-Layer Perceptron

导入需要的模块，读取MNIST数据，读取数据下载慢的话：其它途径下载然后放...Users....kerasdatasets路径下，文件在这里：https://pan.baidu.com/s/1LkOJhMzRM2uizXufnJUxlw

将28X28图像转换为784点，将784点的像素值转化为0-1之间的数值。

导入并建立相应的模型，设置输入层，隐层，输出层的点数，设置隐层，输出层的激活函数，设置初始权值的正态分布。

查看建立的神经网络

设置损失函数，优化器，评估方案，开始训练神经网络，训练神经网络时，传入输入数据，期望数据，训练数据与验证数据的分割比例，训练迭代次数，每批次处理的数量，显示训练过程。开始训练并显示。

训练结束以后，评估准确率，绘制曲线，图像实际预测结果等。进行效果评估。