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}))
     # 因为之前的计算已经把中间参数计算出来了，所以这里只用最后的计算测试集就行了