import tensorflow as tf
# 导入数据
from tensorflow.examples.tutorials.mnist import input_data
mnist = input_data.read_data_sets("data/mnist", one_hot=True)
# 定义参数:学习率;迭代次数;批处理个数;显示步长
learning_rate = 0.01
iterations = 15
batch_number = 100
display_step = 1
# 定义输入输出矩阵大小
X = tf.placeholder("float", [None, 784]) # 28*28
Y = tf.placeholder("float", [None, 10]) # 10 labels : 0-9
# 定义隐藏层大小
hidden_one = 256
hidden_two = 256
# 定义多重感知机函数,需要输入参数X,权重weights,偏置biases
# 这里的weights和biases是python中一个字典, dict = {'Alice': '2341', 'Beth': '9102', 'Cecil': '3258'}
# dict['Alice']=2341
def multilayer_perceptron(x, weights, biases):
hidden_layer_one = tf.matmul(x, weights["W_layer_one"]) + biases["b_layer_one"]
# tf.nn.relu()属于激活函数,几种常见的激活函数如下:
# Sigmoid(S 型激活函数):输入一个实值,输出一个 0 至 1 间的值 σ(x) = 1 / (1 + exp(-x))
# tanh(双曲正切函数):输入一个实值,输出一个 [-1,1] 间的值 tanh(x) = 2σ(2x)-1
# ReLU:ReLU 代表修正线性单元。输出一个实值,并设定 0 的阈值(函数会将负值变为零)f(x) = max(0, x)
hidden_layer_one = tf.nn.relu(hidden_layer_one)
hidden_layer_two = tf.matmul(hidden_layer_one, weights["W_layer_two"]) + biases["b_layer_two"]
hidden_layer_two = tf.nn.relu(hidden_layer_two)
# 返回隐藏层2的输出,也就是输出层的输入,这里不需要求最后的输出,只需返回没有经过激活函数的输入,后面会讲原因
out_layer = tf.matmul(hidden_layer_two, weights["W_out_layer"]) + biases["b_out_layer"]
return out_layer
# tf.random_normal():随机生成均值为0,标准差为1的数值
weights = {"W_layer_one":tf.Variable(tf.random_normal([784, hidden_one])),
"W_layer_two":tf.Variable(tf.random_normal([hidden_one, hidden_two])),
"W_out_layer":tf.Variable(tf.random_normal([hidden_two, 10]))
}
biases = {"b_layer_one":tf.Variable(tf.random_normal([hidden_one])),
"b_layer_two":tf.Variable(tf.random_normal([hidden_two])),
"b_out_layer":tf.Variable(tf.random_normal([10]))
}
# 调用多重感知机函数
pred = multilayer_perceptron(X, weights, biases)
# tf.nn.softmax_cross_entropy_with_logits():
# http://www.jianshu.com/p/fb119d0ff6a6(对这个函数的说明)
# 这个函数可以利用softmax函数对输入进行映射,并求出与真实值之间的交叉熵
cost = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(labels=Y, logits=pred))
# 另外一种优化函数,在这个算法中比梯度下降优化更快
optimizer=tf.train.AdamOptimizer(learning_rate).minimize(cost)
# 初始化参数
init = tf.global_variables_initializer()
sess = tf.Session()
sess.run(init)
for iteration in range(iterations):
# 初始训练误差,计算每轮批量迭代次数
train_cost=0
batch_times=int(mnist.train._num_examples/batch_number)
for i in range(batch_times):
# 每次取100张图
batch_X,batch_Y=mnist.train.next_batch(batch_number)
# 运行优化函数
# 这里返回一个[optimizer,cost]的list, 其中 _代表optimizer,batch_cost代表cost的值
_,batch_cost=sess.run([optimizer,cost],feed_dict={X:batch_X,Y:batch_Y})
# 返回训练集误差:每次计算100张图的batch_cost,计算了i次,所以最后除以batch_numbers
train_cost+=batch_cost/batch_times
if iteration % display_step==0:
# %04d: % 转义说明符 ; 0 指以0填充前面的位数 ;4 四位数; d 十进制整数
# "{:.9f}".format(train_cost) 以保留小数点后9位显示train_cost
print("Iteration :","%04d"%(iteration+1),"Train_cost :","{:.9f}".format(train_cost))
# tf.arg_max(pred,1):得到向量中最大数的下标,1代表水平方向
# tf.equal():返回布尔值,相等返回1,否则0
# 最后返回大小[none,1]的向量,1所在位置为布尔类型数据
prediction=tf.equal(tf.arg_max(pred, 1), tf.arg_max(Y,1))
# tf.cast():将布尔型向量转换成浮点型向量
# tf.reduce_mean():求所有数的均值
# 返回正确率:也就是所有为1的数目占所有数目的比例
accuracy=tf.reduce_mean(tf.cast(prediction,"float"))
# 打印正确率
print("Train_cost :",sess.run(accuracy,feed_dict={X:mnist.train.images,Y:mnist.train.labels}))
print("Test_cost :",sess.run(accuracy,feed_dict={X:mnist.test.images,Y:mnist.test.labels}))
# 打印结果
# Iteration : 0001 Train_cost : 53.053542605
# Iteration : 0002 Train_cost : 8.394692302
# Iteration : 0003 Train_cost : 4.178018635
# Iteration : 0004 Train_cost : 2.850156586
# Iteration : 0005 Train_cost : 2.115638643
# Iteration : 0006 Train_cost : 2.068853149
# Iteration : 0007 Train_cost : 1.676146167
# Iteration : 0008 Train_cost : 1.487952944
# Iteration : 0009 Train_cost : 1.493097927
# Iteration : 0010 Train_cost : 1.245084499
# Iteration : 0011 Train_cost : 1.224542024
# Iteration : 0012 Train_cost : 0.930452932
# Iteration : 0013 Train_cost : 0.838671544
# Iteration : 0014 Train_cost : 0.777738831
# Iteration : 0015 Train_cost : 0.635424245
# Train_cost : 0.984127
# Test_cost : 0.9646
Tensorflow实现多层感知器
最新推荐文章于 2024-05-23 12:45:06 发布