tensorflow（7） Mnist优化大于98

 在之前学习基础上不断的提升Mnist识别准确率：

• 1.学习率的使用：

lr=tf.Variable(0.001,dtype=tf.float32)#学习率的变量，初始学习率是0.001

• 2.适合S神经元输出优化器的使用：

train_step=tf.train.AdamOptimizer(lr).minimize(loss)

• 学习率不断减少（收敛速度由快到慢）

  for epoch in range(20):#每个图片训练21次或者更多次
          sess.run(tf.assign(lr,0.001*(0.95**epoch)))#0.95的epoch次方 学习率逐渐减小 利于开始的时候快速的收敛

  import tensorflow as tf
  from tensorflow.examples.tutorials.mnist import input_data
  #载入数据(可以是某盘的绝对路径)（我的数据存储在运行路径下）
  #mnist = input_data.read_data_sets('C:\\Users\\ZSl\\Documents\\MNIST_data',one_hot = True)
  #或者相对存储路径：
  mnist = input_data.read_data_sets('MNIST_data',one_hot = True)
   
  #每个批次100张照片 每个批次的大小
  batch_size = 100
   
  #计算一共有多少个批次 （整除符号）
  n_batch = mnist.train.num_examples // batch_size
   
  #定义两个placeholder，None=100批次
  x = tf.placeholder(tf.float32,[None,784])
  y = tf.placeholder(tf.float32,[None,10])
  keep_prob=tf.placeholder(tf.float32)
  lr=tf.Variable(0.001,dtype=tf.float32)#学习率的变量，初始学习率是0.001
  
  #创建一个简单的网络（函2个隐层 500神经元 300神经元）
  W1 = tf.Variable(tf.truncated_normal([784,500],stddev=0.1))#初始化方式：正态  标准差0.1
  b1 = tf.Variable(tf.zeros([500])+0.1)
  L1=tf.nn.tanh(tf.matmul(x,W1)+b1)#输出激活
  L1_drop=tf.nn.dropout(L1,keep_prob)#keep_prob代表有百分之多少的神经元在工作
   
      
  W2 = tf.Variable(tf.truncated_normal([500,300],stddev=0.1))#初始化方式：正态  标准差0.1
  b2 = tf.Variable(tf.zeros([300])+0.1)
  L2=tf.nn.tanh(tf.matmul(L1_drop,W2)+b2)#输出激活
  L2_drop=tf.nn.dropout(L2,keep_prob)#keep_prob代表有百分之多少的神经元在工作
  
  #创建一个简单的神经网络（这里只是2层）
  #输入层784个神经元，输出层10个神经元
  W3 = tf.Variable(tf.truncated_normal([300,10],stddev=0.1))#初始化方式：正态  标准差0.1
  b3 = tf.Variable(tf.zeros([10])+0.1)
  #W = tf.Variable(tf.zeros([784,10]))
  #b = tf.Variable(tf.zeros([10]))
  prediction = tf.nn.softmax(tf.matmul(L2_drop,W3)+b3)#得到很多概率（对应标签的10个概率）
   
  
  # loss = tf.reduce_mean(tf.square(y-prediction)) 正确率是91.34%
  #另一种损失（交叉熵函数代价函数）如果输出神经元是S型的，适合用交叉熵函数（对数似然函数） 正确率是92.17% 
  #在训练过程中 调整参数比较合理，收敛的就比较快
  loss = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(labels=y,logits=prediction))
   
  #使用梯度下降法（0.2的学习率）
  # train_step = tf.train.GradientDescentOptimizer(0.2).minimize(loss)
  #训练的方式（一个新的优化器）
  train_step=tf.train.AdamOptimizer(lr).minimize(loss)#学习率10的-3次方，或者小数点:0.001 收敛速度比SGD快，学习率一般比较小
   
  #初始化变量
  init = tf.global_variables_initializer()
   
      
  #定义一个球准确率的方法
  #结果存放在一个布尔型列表中（比较两个参数是否相等，是返回true）
  #tf.argmax(prediction,1)返回最大的值（概率是在哪个位置）所在的位置，标签是几
  #tf.argmax(y,1) one-hot方法对应的是否是1  就是对应的标签
  correct_prediction = tf.equal(tf.argmax(y,1),tf.argmax(prediction,1))
  #求准确率（bool类型是true和false）转化为浮点型  显示1的和总的数据的比值就是准确率
  accuracy = tf.reduce_mean(tf.cast(correct_prediction,tf.float32))
   
   
  with tf.Session() as sess:
      sess.run(init)
      #迭代21个周期
      for epoch in range(20):#每个图片训练21次或者更多次
          sess.run(tf.assign(lr,0.001*(0.95**epoch)))#0.95的epoch次方 学习率逐渐减小 利于开始的时候快速的收敛
          for batch in range(n_batch):
              batch_xs,batch_ys =  mnist.train.next_batch(batch_size)
              #把训练数据feed数据喂给网络
              sess.run(train_step,feed_dict={x:batch_xs,y:batch_ys,keep_prob:1.0})
              #把测试数据feed数据喂给网络
          learning_rate=sess.run(lr)
          acc = sess.run(accuracy,feed_dict = {x:mnist.test.images,y:mnist.test.labels,keep_prob:1.0})
          print("Iter " + str(epoch) + " ,Testing Accuracy " + str(acc)+" ,Learning Rate " + str(learning_rate ))