Tensorflow學習2:四層神經網絡進行手寫數字識別(輸入層+隱藏層1+隱藏層2+輸出層)+卷積神經網絡

我採用的是本地的MNIST數據，道友們可以自己在網上下載好MNIST數據，然後再進行識別。

import tensorflow as tf
import numpy as np
import matplotlib.pyplot as plt
from tensorflow.keras.datasets import mnist
from tensorflow import keras 

#%%
from tensorflow.examples.tutorials.mnist import input_data
#%%
# 加載MNIST 數據 60000張圖片
mnist_input = input_data.read_data_sets("./MNIST_data", one_hot=True)
print(type(mnist_input))
print(mnist_input.train.num_examples)
print(mnist_input.test.num_examples)
#%%
training = mnist_input.train.images
trainlabel = mnist_input.train.labels
testing = mnist_input.test.images
testlabel = mnist_input.test.labels
#%%
print(training.shape)
print(trainlabel.shape)
print(testing.shape)
print(testlabel.shape)
#%%

n_hidden_1=256
n_hidden_2=128
n_input=784
n_classes=10

# inputs and outputs
x=tf.placeholder('float',[None,n_input])
y=tf.placeholder('float',[None,n_classes])

# network parameters
stddev=0.1
weights ={
    'w1':tf.Variable(tf.random_normal([n_input,n_hidden_1],stddev=stddev)),
    'w2':tf.Variable(tf.random_normal([n_hidden_1,n_hidden_2],stddev=stddev)),
    'out':tf.Variable(tf.random_normal([n_hidden_2,n_classes],stddev=stddev))
}
biases= {
    'b1':tf.Variable(tf.random_normal([n_hidden_1])),
    'b2':tf.Variable(tf.random_normal([n_hidden_2])),
    'out':tf.Variable(tf.random_normal([n_classes]))
}

#%%

def multilayer_perceptron(_X,_weights,_biases):
    layer_1=tf.nn.sigmoid(tf.add(tf.matmul(_X,_weights['w1']),_biases['b1']))
    # relu也可以
    layer_2=tf.nn.sigmoid(tf.add(tf.matmul(layer_1,_weights['w2']),_biases['b2']))
    return tf.matmul(layer_2,_weights['out'])+_biases['out']

#%%

pred = multilayer_perceptron(x,weights,biases)

# loss and optimizer
cost = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(logits=pred,labels=y))
optm = tf.train.GradientDescentOptimizer(learning_rate=0.001).minimize(cost)
corr = tf.equal(tf.arg_max(pred,1),tf.arg_max(y,1))
accr = tf.reduce_mean(tf.cast(corr,'float'))

init = tf.global_variables_initializer()

#%%

train_epochs=100
batch_size=100
display_step=4
#Star train
sess=tf.Session()
sess.run(init)

for epoch in range(train_epochs):
    avg_cost=0
    total_batch=int(mnist_input.train.num_examples/batch_size)
    star_batch_size=(epoch-1)*total_batch
    batch_xs,batch_ys=0,0
    for i in range(total_batch):
        batch_xs,batch_ys = mnist_input.train.next_batch(batch_size)
        feeds = {x:batch_xs,y:batch_ys}
        sess.run(optm,feed_dict=feeds)
        avg_cost+=sess.run(cost,feed_dict=feeds)
    avg_cost=avg_cost/total_batch
    if (epoch+1)%display_step == 0:
        print("Epoch:%03d/%03d cost:%.9f"%(epoch+1,train_epochs,avg_cost))
        feeds={x:batch_xs,y:batch_ys}
        train_acc = sess.run(accr,feed_dict=feeds)
        feeds={x:testing,y:testlabel}
        test_acc=sess.run(accr,feed_dict=feeds)
        print("Train ACCURACY: %.3f"% train_acc,",Test ACCURACY: %.3f"% test_acc)
        # print("Test ACCURACY: %.3f"% test_acc)

效果還是不錯的，沒想到兩層的隱含層也能達到這麼高的一個非線性圖像處理能力，迭代100次有84.6%的一個測試準確率，但是和卷積神經網絡的比較還是比較大的差距了。

給一個卷積神經網絡的預測，基本上可以達到99.9%的一個準確率。

# coding=gbk
# 採用TensorFlow對手寫數字的識別
from tensorflow.keras.datasets import mnist
import matplotlib.pyplot as plt
from tensorflow import keras
from tensorflow.keras import layers
from tensorflow.keras import models

# 加載MNIST 數據 60000張圖片
(X_train, Y_train), (x_test, y_test) = mnist.load_data()

# plt.subplot(221)
# plt.imshow(X_train[0], cmap=plt.get_cmap('gray'))
# plt.subplot(222)
# plt.imshow(X_train[1], cmap=plt.get_cmap('gray'))
# plt.subplot(223)
# plt.imshow(X_train[2], cmap=plt.get_cmap('gray'))
# plt.subplot(224)
# plt.imshow(X_train[3], cmap=plt.get_cmap('gray'))
# plt.show()

# 圖形的尺寸
img_rows, img_cols = 28, 28
# x_train是60000*28*28
# y_train是60000*1
X_train, x_test = X_train / 255.0, x_test / 255.0  # 把(0,255)歸納到(0,1)之間
# 將y的值通過one_hot編碼轉化爲需要的格式
Y_train = keras.utils.to_categorical(Y_train, num_classes=10)
Y_test = keras.utils.to_categorical(y_test, num_classes=10)
# 將訓練所用的圖像調整尺寸，因爲圖像是黑白圖像，所以最後一維的值是1
X_train = X_train.reshape(X_train.shape[0], img_rows, img_cols, 1)
X_test = x_test.reshape(x_test.shape[0], img_rows, img_cols, 1)
# 開始建立模型
model = models.Sequential()
# 添加捲積層，使用relu作爲激活函數
model.add(layers.Conv2D(32,
                        kernel_size=(5, 5),
                        activation='relu',
                        input_shape=(img_rows, img_cols, 1)))
# 添加池化層，過濾大小爲2*2
model.add(layers.MaxPool2D(pool_size=(2, 2)))
# 添加捲積層
model.add(layers.Conv2D(64, (5, 5), activation='relu'))
# 添加池化層
model.add(layers.MaxPool2D(pool_size=(2, 2)))
# 將池化層的輸出拉直，然後作爲全連接的輸入
model.add(layers.Flatten())
# 添加全連接層，設置爲有500個節點,激活函數使用relu
model.add(layers.Dense(500, activation='relu'))
# 輸出結果，10個結果，激活函數使用softmax
model.add(layers.Dense(10, activation='softmax'))
# 1.定義損失函數，優化函數，評測方法
model.compile(loss=keras.losses.categorical_crossentropy,
              optimizer=keras.optimizers.SGD(),
              metrics=['accuracy'])
# 2.完成模型的訓練過程
model.fit(X_train, Y_train, batch_size=128, epochs=17, validation_data=(X_test, Y_test))
# 3.得到結果，即損失和準確度
score = model.evaluate(X_test, Y_test)

print("Test loss:", score[0])
print("Test accuracy:", score[1])