tensorflow手写数字识别（有注释）

import tensorflow as tf
import numpy as np
# const = tf.constant(2.0, name='const')
# b = tf.placeholder(tf.float32, [None, 1], name='b')
# # b = tf.Variable(2.0, dtype=tf.float32, name='b')
# c = tf.Variable(1.0, dtype=tf.float32, name='c')
#
# d = tf.add(b, c, name='d')
# e = tf.add(c, const, name='e')
# a = tf.multiply(d, e, name='a')
# init = tf.global_variables_initializer()
#
# print(a)
# with tf.Session() as sess:
#     sess.run(init)
#     ans = sess.run(a, feed_dict={b: np.arange(0, 10)[:, np.newaxis]})
# print(a)
# print(ans)

from tensorflow.examples.tutorials.mnist import input_data
mnist = input_data.read_data_sets("MNIST_data/", one_hot=True)  # 载入数据集

learning_rate = 0.5  # 学习率
epochs = 10  # 训练10次所有的样本
batch_size = 100  # 每批训练的样本数

x = tf.placeholder(tf.float32, [None, 784])  # 为训练集的特征提供占位符
y = tf.placeholder(tf.float32, [None, 10])  # 为训练集的标签提供占位符

W1 = tf.Variable(tf.random_normal([784, 300], stddev=0.03), name='W1')  # 初始化隐藏层的W1参数
b1 = tf.Variable(tf.random_normal([300]), name='b1')  # 初始化隐藏层的b1参数
W2 = tf.Variable(tf.random_normal([300, 10], stddev=0.03), name='W2')  # 初始化全连接层的W1参数
b2 = tf.Variable(tf.random_normal([10]), name='b2')  # 初始化全连接层的b1参数

hidden_out = tf.add(tf.matmul(x, W1), b1)  # 定义隐藏层的第一步运算
hidden_out = tf.nn.relu(hidden_out)  # 定义隐藏层经过激活函数后的运算

y_ = tf.nn.softmax(tf.add(tf.matmul(hidden_out, W2), b2))  # 定义全连接层的输出运算

y_clipped = tf.clip_by_value(y_, 1e-10, 0.9999999)
cross_entropy = -tf.reduce_mean(tf.reduce_sum(y * tf.log(y_clipped) + (1 - y) * tf.log(1 - y_clipped), axis=1))
# 交叉熵

optimizer = tf.train.GradientDescentOptimizer(learning_rate=learning_rate).minimize(cross_entropy)
# 梯度下降优化器，传入的参数是交叉熵

init = tf.global_variables_initializer()  # 所有参数初始化

correct_prediction = tf.equal(tf.argmax(y, 1), tf.argmax(y_, 1))  # 返回true|false
accuracy = tf.reduce_mean(tf.cast(correct_prediction, tf.float32))  # 将true转化为1，false转化为0

# 开始训练
with tf.Session() as sess:
    sess.run(init)
    total_batch = int(len(mnist.train.labels) / batch_size)  # 计算每个epoch要迭代几次
    for epoch in range(epochs):
        avg_cost = 0
        for i in range(total_batch):
            batch_x, batch_y = mnist.train.next_batch(batch_size=batch_size)
            _, c = sess.run([optimizer, cross_entropy], feed_dict={x: batch_x, y: batch_y})
            # 其实上面这一步只需要跑optimizer这个优化器就好了，因为交叉熵也会同时跑。
            # 但是我们想要得到交叉熵的值来作为损失函数，所以还需要跑一个交叉熵。
            avg_cost += c / total_batch
        print("Epoch:", (epoch + 1), "cost = ", "{:.3f}".format(avg_cost))  # 这是每训练完所有样本得到的损失值
    print(sess.run(accuracy, feed_dict={x: mnist.test.images, y: mnist.test.labels}))
    # 因为之前的计算已经把中间参数计算出来了，所以这里只用最后的计算测试集就行了