import gzip

 import os

 import tempfile  

 import numpy

 from six.moves import urllib

 from six.moves import xrange  # pylint: disable=redefined-builtin

 import tensorflow as tf

 from tensorflow.contrib.learn.python.learn.datasets.mnist import read_data_sets

 mnist = read_data_sets("MNIST_data/", one_hot=True) 

 x = tf.placeholder(tf.float32,[None, 784]) #图像输入向量

 W = tf.Variable(tf.zeros([784,10]))  #权重，初始化值为全零

 b = tf.Variable(tf.zeros([10]))  #偏置，初始化值为全零  

 #进行模型计算，y是预测，y_ 是实际

 y = tf.nn.softmax(tf.matmul(x,W) + b)  

 y_ = tf.placeholder("float", [None,10])  

 #计算交叉熵

 cross_entropy = -tf.reduce_sum(y_*tf.log(y))

 #接下来使用BP算法来进行微调,以0.01的学习速率

 train_step = tf.train.GradientDescentOptimizer(0.01).minimize(cross_entropy)  

 #上面设置好了模型，添加初始化创建变量的操作

 init = tf.global_variables_initializer()

 #启动创建的模型，并初始化变量

 sess = tf.Session()

 sess.run(init)

 #开始训练模型，循环训练1000次

 for i in range(1000):

     #随机抓取训练数据中的100个批处理数据点

     batch_xs, batch_ys = mnist.train.next_batch(100)

     sess.run(train_step, feed_dict={x:batch_xs,y_:batch_ys})  

 ''''' 进行模型评估 '''  

 #判断预测标签和实际标签是否匹配

 correct_prediction = tf.equal(tf.argmax(y,1),tf.argmax(y_,1))

 accuracy = tf.reduce_mean(tf.cast(correct_prediction, "float"))

 #计算所学习到的模型在测试数据集上面的正确率

 print( sess.run(accuracy, feed_dict={x:mnist.test.images, y_:mnist.test.labels}) )

 import tensorflow as tf

 import struct

 import numpy as np

 with open('train-labels.idx1-ubyte','rb') as lb:

    magic,n=struct.unpack('>II',lb.read(8))

    labels = np.fromfile(lb,dtype=np.uint8)

 with open('train-images.idx3-ubyte','rb') as img:

    magic,num,rows,cols=struct.unpack('>IIII',img.read(16))

    images = np.fromfile(img,dtype=np.uint8).reshape(-1,784)

    images = images.astype(np.float32)

    images = np.multiply(images, 1.0 / 255.0)

 with open('t10k-labels.idx1-ubyte','rb') as lb:

    magic,n=struct.unpack('>II',lb.read(8))

    testlabels = np.fromfile(lb,dtype=np.uint8)

 with open('t10k-images.idx3-ubyte','rb') as img:

    magic,num,rows,cols=struct.unpack('>IIII',img.read(16))

    testimages = np.fromfile(img,dtype=np.uint8).reshape(-1,784)

    testimages = testimages.astype(np.float32)

    testimages = np.multiply(testimages, 1.0 / 255.0)

 x = tf.placeholder(tf.float32, [None, 784])

 W = tf.Variable(tf.zeros([784, 10]))

 b = tf.Variable(tf.zeros([10]))

 y = tf.nn.softmax(tf.matmul(x, W) + b)

 y_ = tf.placeholder(tf.float32, [None, 10])

 cross_entropy = -tf.reduce_sum(y_ * tf.log(y))

 train_step = tf.train.GradientDescentOptimizer(0.01).minimize(cross_entropy)

 sess = tf.InteractiveSession()

 tf.global_variables_initializer().run()

 labels = sess.run(tf.one_hot(labels,10))

 testlabels = sess.run(tf.one_hot(testlabels,10))

 for _ in range(1000):

   a=np.random.permutation(np.arange(60000))

   bx = images[a[:100]]

   by = labels[a[:100]]

   sess.run(train_step,feed_dict={x:bx,y_:by})

 correct_prediction = tf.equal(tf.argmax(y,1), tf.argmax(y_,1))

 accuracy = tf.reduce_mean(tf.cast(correct_prediction, tf.float32))

 print(sess.run(accuracy, feed_dict={x:testimages, y_:testlabels}))

def dense_to_one_hot(labels_dense, num_classes):

  """Convert class labels from scalars to one-hot vectors."""

  num_labels = labels_dense.shape[0]

  index_offset = numpy.arange(num_labels) * num_classes

  labels_one_hot = numpy.zeros((num_labels, num_classes))

  labels_one_hot.flat[index_offset + labels_dense.ravel()] = 1

  return labels_one_hot