利用tensorflow的mnist 数据，进行【线性回归】模型

通过网络获取tensorflow 的mnist 数据（手写数字的图片和标记）
训练数据有2组，images[55000,784]和labels[55000,10]，分别是2828的图片，0-10的标记
测试数组有2组，images[10000,784]和labels[10000,10]，分别是2828的图片，0-10的标记
假设识别模型为线性 y=wx+b
通过tensorflow对数据进行线性回归，计算出模型参数 W和b

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

# 读取 tensorflow 的 mnist 示例数据到 ./tmp/data/
train_data = input_data.read_data_sets("./tmp/data/", one_hot=True)
# 训练数据有2组，images[55000,784]和labels[55000,10]，分别是28*28的图片，0-10的标记

# 参数
# 梯度下降的学习率
learning_rate = 0.01
# 循环次数
training_epochs = 20
# 一次训练的取值大小
batch_size = 120

# 输入数据
# 在tf里创建占位符 x_data,类型为 float32 shape为 [none,28*28] ，为图片变量
x_data = tf.placeholder(tf.float32, [None, 784])
# 在tf里创建占位符 y_data,类型为 float32 shape为 [none,10] ，为标记变量
y_data = tf.placeholder(tf.float32, [None, 10])  # 模型参数
# 在tf里创建变量 W,创建shape为[784,10]的随机数组，取值范围为 [ mean - 2 * stddev, mean + 2 * stddev ]，[0-0.2,0+0.2]
W = tf.Variable(tf.truncated_normal([784, 10], stddev=0.1), name="W")
# 在tf里创建变量 b, 创建shape为[10]的数组，数值全部为固定值 0.1
b = tf.Variable(tf.constant(0.1, shape=[10]), name="b")
# 归一化处理，将 tf.matmul(x_data, W) + b 得到的值，全部转换成 0-1 的概率（变成每个数字都在[0,1)之间，且数字的和加起来都等于1的概率序列。）
# tf.matmul(x_data, W) + b = x_data * W +b 为[None, 784] * [784, 10] +[10] ,做归一化处理
# 等同于 W和B 为图片识别的变量，根据x_data计算出y的最大可能性
y_pred = tf.nn.softmax(tf.matmul(x_data, W) + b)
# 损失函数
cost = tf.reduce_mean(-tf.reduce_sum(y_data * tf.log(y_pred), reduction_indices=1))
# 优化，利用梯度下降法，计算损失函数，并更新变量值
optimizer = tf.train.GradientDescentOptimizer(learning_rate).minimize(cost)

with tf.Session() as sess:
    init = tf.global_variables_initializer()
    sess.run(init)
    # 开始执行程序，每次选择batch的样本
    for epoch in range(training_epochs):
        avg_cost = 0.0
        # int(55000/120) = 458
        total_batch = int(train_data.train.num_examples / batch_size)
        for i in range(total_batch):
            # 取0-120个数据，batch_xs 为[120,784],batch_ys 为 [120,10]
            batch_xs, batch_ys = train_data.train.next_batch(batch_size)
            # 执行梯度下降法，
            _, c = sess.run([optimizer, cost], feed_dict={x_data: batch_xs, y_data: batch_ys})
            avg_cost += c / total_batch
        if (epoch + 1) % 10 == 0:
            print ("Epoch:", '%04d' % (epoch + 1), "cost=", "{:.9f}".format(avg_cost))

    # 模型测试
    # 返回最大值所在的下班进行比较，得到true false 的数组
    correct_prediction = tf.equal(tf.argmax(y_pred, 1), tf.argmax(y_data, 1))
    # 将得到的数组进行转换成float类型，再求均值
    accuracy = tf.reduce_mean(tf.cast(correct_prediction, tf.float32))
    # 现在W和B已经计算出准确值，将 accuracy 中x_data，y_data 替换为test值，计算准确性
    print ("Accuracy:", accuracy.eval({x_data: train_data.test.images, y_data: train_data.test.labels}))

得到的结果输出