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])