tensorflow构建用于MNIST分类的多层感知机

使用tensorflow，keras等库构建于图像分类的MLP网络。其实也就是构建网络加载数据集，进行建模，然后训练模型，进行模型测试以及对模型的评估。
首先载入库

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

加载数据集,可以用被注释的部分来加载数据集，但是由于我的会报错没有发现datasetslib，所以我就改用未被注释的部分，效果差不多是一样的。

# mnist_home=os.path.join(datasetslib.datasets_root,'mnist')
# mnist=input_data.read_data_sets(mnist_home,one_hot=True)
# X_train=mnist.train.images
# X_test=mnist.test.images
# Y_train=mnist.train.labels
# Y_test=mnist.test.labels
mnist = input_data.read_data_sets('MNIST_data', one_hot=True)

num_inputs=784#总像素
num_outputs=10#0-9的数字

在定义输入，输出的占位符x和y,以及其他的超参数：

#输出图像
x=tf.placeholder(dtype=tf.float32,name="x",
                shape=[None,num_inputs])
#目标输出
y=tf.placeholder(dtype=tf.float32,name="y",
                shape=[None,num_outputs])
 
num_layers=0  #隐藏层数量
num_neurons=[]   #空列表
learning_rate=0.01   #学习率
n_epochs=50     #迭代
batch_size=100      #批次大小
n_batches=int(mnist.train.num_examples/batch_size)#批次的数量              

实现整个MLP网络，需要创建三个辅助函数帮助创建只有一个隐藏层的简单MLP，然后在创建较大的MLP，有多个层，每个层中有多个神经元。

#实现整个MLP
def mlp(x,num_inputs,num_outputs,num_layers,num_neurons):
    w=[]
    b=[]
    for i in range(num_layers):
        #权重
        w.append(tf.Variable(tf.random_normal(
                [num_inputs if i==0 else num_neurons[i-1],
                num_neurons[i]]),
                nme="w_{0:04d}".format(i)
        ))
        #偏差
        b.append(tf.Variable(tf.random_normal(
                [num_neurons[i]]),
                name="b_{0:04d}".format(i)
        ))
    w.append(tf.Variable(tf.random_normal(
        [num_neurons[num_layers-1] if num_layers>0 else num_inputs,
         num_outputs]),name="w_out"))
    b.append(tf.Variable(tf.random_normal([num_outputs]),name="b_out"))
    #x是输入层
    layer=x
    #添加隐藏层
    for i in range(num_layers):
        layer=tf.nn.relu(tf.matmul(layer,w[i])+b[i])
            
    #添加输出层
    layer=tf.matmul(layer,w[num_layers])+b[num_layers]  
    
    return layer

辅助函数mnist_batch_func()封装了针对MNIST数据集的批处理函数，以便可以获取下一批图像：

#封装了批处理函数
def mnist_batch_func(batch_size=100):
    X_batch,Y_batch=mnist.train.next_batch(batch_size)
    return [X_batch,Y_batch]

辅助函数tensorflow_classification()用于训练和评估模型

#用于训练和评估模型
def tensorflow_classification(n_epochs,n_batches,
                             batch_size,batch_func,
                             model,optimizer,loss,accuracy_function,
                             X_test,Y_test):
    with tf.Session() as sess:
        sess.run(tf.global_variables_initializer())
        for epoch in range(n_epochs):
            #计算每次的平均损失函数值
            epoch_loss=0.0
            for batch in range(n_batches):
                X_batch,Y_batch=batch_func(batch_size)
                feed_dict={x:X_batch,y:Y_batch}
                _,batch_loss=sess.run([optimizer,loss],feed_dict)
                epoch_loss+=batch_loss
            average_loss=epoch_loss/n_batches
            print("epoch:{0:04d} loss={1:0.6f}".format(
                    epoch,average_loss))
        #计算分类精度
        feed_dict={x:X_test,y:Y_test}
        accuracy_score=sess.run(accuracy_function,feed_dict=feed_dict)
        print("accuracy={0:.8f}".format(accuracy_score))

定义网络，损失值，优化器函数和分类精度函数

model=mlp(x=x,
         num_inputs=num_inputs,
         num_outputs=num_outputs,
         num_layers=num_layers,
         num_neurons=num_neurons)
loss=tf.reduce_mean(
        tf.nn.softmax_cross_entropy_with_logits(logits=model,labels=y))
optimizer=tf.train.GradientDescentOptimizer(learning_rate=learning_rate).minimize(loss)
predictions_check=tf.equal(tf.argmax(model,1),tf.argmax(y,1))
accuracy_function=tf.reduce_mean(tf.cast(predictions_check,tf.float32))   

运行辅助函数tensorflow_classification函数训练和评估

#训练和评估模型
tensorflow_classification(n_epochs=n_epochs,
                             n_batches=n_batches,
                             batch_size=batch_size,
                             batch_func=mnist_batch_func,
                             model=model,
                             optimizer=optimizer,
                             loss=loss,
                             accuracy_function=accuracy_function,
                             X_test=mnist.test.images,
                             Y_test=mnist.test.labels
                             )

运行过程的输出：

10-40省略一下，比较多