Tensorflow案例实战-09神经网络模型架构

模型

网络准备

import tensorflow as tf
import numpy as np
import matplotlib.pyplot as plt
import input_data
#神经网络预测十分类任务,数据：n*784,n个样本，784个像素点
#输出是十分类的得分值
n_hidden_1=256
n_hidden_2=128
n_input=784
n_classes=10
#IO
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]))
}
print("NETWORK Ready")

定义函数

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

函数准备

#prediction
pred=multilayer_perceptron(x,weights,biases)
#lost&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.argmax(pred,1),tf.argmax(y,1))
accr=tf.reduce_mean(tf.cast(corr,'float'))
init=tf.global_variables_initializer()
print("Functions ready")

这里提一下tf.nn.softmax_cross_entropy_with_logits，因为计算loss的时候，最常见的一句话就是tf.nn.softmax_cross_entropy_with_logits

loss是代价值，也就是我们要最小化的值tf.nn.softmax_cross_entropy_with_logits(logits, labels, name=None)除去name参数用以指定该操作的name，与方法有关的一共两个参数

第一个参数logits：就是神经网络最后一层的输出，如果有batch的话，它的大小就是[batchsize，num_classes]，单样本的话，大小就是num_classes

第二个参数labels：实际的标签，大小同上具体的执行流程大概分为两步：第一步是先对网络最后一层的输出做一个softmax，这一步通常是求取输出属于某一类的概率，对于单样本而言，输出就是一个num_classes大小的向量（[Y1，Y2,Y3…]其中Y1，Y2，Y3…分别代表了是属于该类的概率）

第二步是softmax的输出向量[Y1，Y2,Y3…]和样本的实际标签做一个交叉熵
显而易见，预测越准确，结果的值越小（别忘了前面还有负号），最后求一个平均，得到我们想要的loss

训练过程

#样本迭代20次，每次选择100个样本
training_epochs=20
batch_size=100
display_step=4
#session
sess=tf.Session()
sess.run(init)
#mini-batch leaning
for epoch in range(training_epochs):
    avg_cost=0
    num_batch=int(minst.train.num_examples/batch_size)
    for i in range(num_batch):
        batch_xs,batch_ys=minst.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/num_batch
    #display
    if (epoch+1) % display_step==0:
        print("Epoch:%03d%03d cost: %.9f"%(epoch,training_epochs,avg_cost))
        feeds_train={x:batch_xs,y:batch_ys}
        train_acc=sess.run(accr,feed_dict=feeds)
        print("Train accrancy:%.3f"%(train_acc))
        feeds={x:minst.test.images,y:minst.test.labels}
        test_acc=sess.run(accr,feed_dict=feeds)
        print("Test accrancy:%.3f"%(test_acc))
print("optimization Done")

训练过程有点慢