演练mnist,分化的多寡输入格式,相近的模子,结

作者:编程技术

美高梅4858官方网站 1

tf.random_uniform 生成均匀分布的随机数
tf.train.AdamOptimizer() 创建优化器,优化方法为Adam(adaptive moment estimation,Adam优化方法根据损失函数对每个参数的梯度的一阶矩估计和二阶矩估计动态调整针对于每个参数的学习速率)
tf.placeholder “占位符”,只要是对网络的输入,都需要用这个函数这个进行“初始化”
tf.random_normal 生成正态分布
tf.add 和 tf.matmul 数据的相加 、相乘
tf.reduce_sum 缩减维度的求和
tf.pow 求幂函数
tf.subtract 数据的相减
tf.global_variables_initializer 定义全局参数初始化
tf.Session 创建会话.
tf.Variable 创建变量,是用来存储模型参数的变量。是有别于模型的输入数据的
tf.train.AdamOptimizer (learning_rate = 0.001) 采用Adam进行优化,学习率为 0.001
————————————–我是分割线(二)———————————–

# 创建占位符

importtensorflowastffromtensorflow.examples.tutorials.mnistimportinput_data#MNIST数据集相关常数INPUT_NODE=784OUTPUT_NODE=10#配置神经网络的参数LAYER1_NODE=500#隐藏层第一层神经元设为五百个BATCH_SIZE=100LEANING_RATE_BASE=0.8#基础学习率LEARNING_RATE_DECAY=0.99#学习率的衰减率REGULARIZATION_RATE=0.001#正则化速率TRAINING_STEPS=1100#训练轮数#一个辅助函数,给定神经网络输入的参数,计算向前传播结果definference(input_tensor,weights1,biases1,weights2,biases2):#这里用了relu激活函数layer1=tf.nn.relu(tf.matmul(input_tensor,weights1) biases1)#返回输出层这里没用激活函数,因为后面会用softmaxreturntf.matmul(layer1,weights2) biases2#模拟训练过程deftrain(mnist):x=tf.placeholder(tf.float32,[None,INPUT_NODE],name='x-input')y_=tf.placeholder(tf.float32,[None,OUTPUT_NODE],name='y-input')#生成隐藏层参数weight1=tf.Variable(tf.truncated_normal([INPUT_NODE,LAYER1_NODE],stddev=0.1,seed=1))biases1=tf.Variable(tf.constant(0.1,shape=[LAYER1_NODE]))#生成输出层参数weight2=tf.Variable(tf.truncated_normal([LAYER1_NODE,OUTPUT_NODE],stddev=0.1,seed=1))biases2=tf.Variable(tf.constant(0.1,shape=[OUTPUT_NODE]))#----------------计算向前传播结果-----------y=inference(x,weight1,biases1,weight2,biases2)global_step=tf.Variable(0,trainable=False)#不需要训练,其他的权重和偏向都需要#-----------------用交叉熵和softmax配合计算损失函数。------#这里使用了tf.nn.sparse_softmax_cross_entropy_with_logits函数,#第一个参数为不包含softmax的向前传播结果,第二个是训练数据的正确答案corss_entropy=tf.nn.sparse_softmax_cross_entropy_with_logits(logits=y,labels=tf.argmax(y_,1))corss_entropy_mean=tf.reduce_mean(corss_entropy)#求均值#------------------L2正则化的损失函数--------regularizer=tf.contrib.layers.l2_regularizer(REGULARIZATION_RATE)regularization=regularizer(weight1) regularizer(weight2)#计算总损失函数loss=corss_entropy_mean regularization#------------------设置学习速率----------------------------------#这里的除法mnist.train.num_examples/BATCH_SIZE若等于x,则为x迭代才能过完整个训练集,而这句话意思是进行x次才更新一次速率learning_rate=tf.train.exponential_decay(LEANING_RATE_BASE,global_step,mnist.train.num_examples/BATCH_SIZE,LEARNING_RATE_DECAY)#-------------梯度下降反向传播-------train_step=tf.train.GradientDescentOptimizer(learning_rate).minimize(loss,global_step=global_step)#---------------检验准确率------------correct_prediction=tf.equal(tf.argmax(y,1),tf.argmax(y_,1))#注意,这里用了average_y,上面用了的y。1表示按行输出最大值得索引值,若是0,则表示按列。accuracy=tf.reduce_mean(tf.cast(correct_prediction,tf.float32))#tf.cast函数是用于类型转换为float32#------------初始化会话并开始训练过程-----------withtf.Session()assess:tf.global_variables_initializer().run()#准备验证数据validate_feed={x:mnist.validation.images,y_:mnist.validation.labels}#准备测试数据test_feed={x:mnist.test.images,y_:mnist.test.labels}#迭代地训练神经网络foriinrange(TRAINING_STEPS):#每1000轮输出一次在验证数据集上的测试结果ifi00==0:validate_acc=sess.run(accuracy,feed_dict=validate_feed)test_acc=sess.run(accuracy,feed_dict=test_feed)print("After%dtrainingstep(s),validationaccuracyusingaveragemodelis%g,""testaccuracyusingaveragemodelis%g"%(i,validate_acc,test_acc))#产生这一轮使用的一个batch的训练数据,并运行训练过程。xs,ys=mnist.train.next_batch(BATCH_SIZE,shuffle=False)#print((ys))sess.run([train_step],feed_dict={x:xs,y_:ys})#训练结束后输出在测试数据上最终正确率test_acc=sess.run(accuracy,feed_dict=test_feed)print("基础学习速率NOCHANGE:",LEANING_RATE_BASE)print("不含滑动平均值")print("After%dtrainingstep(s),testaccuracyusingaveragemodelis%g"%(TRAINING_STEPS,test_acc))#---------------------主程序入口----------------------defmain(argv=None):mnist=input_data.read_data_sets("/tmp/data",one_hot=True)train(mnist)#提供一个主程序入口,tf.app.run会调用main函数if__name__=='__main__':tf.app.run()
  1. sess = tf.InteractiveSession() 将sess注册为默认的session
  2. tf.placeholder() , Placeholder是输入数据的地方,也称为占位符,通俗的理解就是给输入数据(此例中的图片x)和真实标签(y_)提供一个入口,或者是存放地。(个人理解,可能不太正确,后期对TF有深入认识的话再回来改~~)
  3. tf.Variable() Variable是用来存储模型参数,与存储数据的tensor不同,tensor一旦使用掉就消失
  4. tf.matmul() 矩阵相乘函数
  5. tf.reduce_mean 和tf.reduce_sum 是缩减维度的计算均值,以及缩减维度的求和
  6. tf.argmax() 是寻找tensor中值最大的元素的序号 ,此例中用来判断类别
  7. tf.cast() 用于数据类型转换
    ————————————–我是分割线(一)———————————–

# 训练模型

方法二代码如下:

其中用到的函数总结(续上篇):

# 创建模型

我是在学习《TensorFlow:实战Google深度学习框架》中遇到这个问题。方法一:在第五章有一个用全连接神经网络训练Mnist数据集的代码,用到了学习率递减,正则化以及取滑动平均值的优化方法,这里用mnist.train.next_batch获取数据输入占位符。方法二:然后我将mnist的train数据和test转成TFRecord文件,再用迭代器进行获取,再用和上面同样的训练模型。结果相差非常大。如下图:可以看出学习速率在0.8时,两种方法有巨大的差异。用迭代器法直接就是失败结果。我以为是我粗心敲错了代码,检查后发现是学习速率太大了,调到0.01会得到较好的结果。但是同样占位符法用相同的模型却能达到96%的正确率。我非常困惑。我觉得可能是转完数据改变了什么。我试过将所有的weight和bias调整seed=1,也不打乱迭代器法中挑选batch中的顺序,还将mnist.train.next_batch(BATCH_SIZE,shuffle=False)中打乱顺序调成False。而即使是这样两种方法出来的数据都是不同的。这对我核对数据带来很大的困扰。。。。求大神救救我!!!两种方法为什么会出现这么大的区别。方法一代码如下:

# -*- coding: utf-8 -*-
"""
Created on Tue Jun 20 12:59:16 2017

@author: ASUS
"""
import tensorflow as tf
from tensorflow.examples.tutorials.mnist import input_data

mnist = input_data.read_data_sets('MNIST_data/', one_hot = True) # 是一个tensorflow内部的变量
sess = tf.InteractiveSession() # sess被注册为默认的session 

#---------------第1/4步:定义算法公式-------------------
# 各层参数初始化
in_units = 784
h1_units = 300
W1 = tf.Variable(tf.truncated_normal([in_units, h1_units], stddev = 0.1)) # 截断正态分布,剔除2倍标准差之外的数据
b1 = tf.Variable(tf.zeros([h1_units]))
W2 = tf.Variable(tf.zeros([h1_units, 10]))
b2 = tf.Variable(tf.zeros([10]))

# 定义计算图的输入
x = tf.placeholder(tf.float32, [None, in_units])
keep_prob = tf.placeholder(tf.float32)  # Droput的比例

# 定义隐藏层结构 h = relu(W1*x   b1)
hidden1 = tf.nn.relu(tf.matmul(x, W1)   b1)
hidden1_drop = tf.nn.dropout(hidden1, keep_prob)
# 定义输出层
y = tf.nn.softmax(tf.matmul(hidden1_drop, W2)   b2)
# 定义计算图的输入,y_ 是输入真实标签
y_ = tf.placeholder(tf.float32, [None, 10])

#---------------第2/4步:定义loss和优化器-------------------

cross_entropy = tf.reduce_mean(-tf.reduce_sum(y_ * tf.log(y),
                                reduction_indices = [1]))
train_step = tf.train.AdagradOptimizer(0.3).minimize(cross_entropy)


#---------------第3/4步:训练步骤-------------------
tf.global_variables_initializer().run()
#迭代地执行训练操作
for i in range(100):
    batch_xs, batch_ys = mnist.train.next_batch(100) # batch 数为100
    train_step.run({x: batch_xs, y_: batch_ys, keep_prob: 0.75})

#---------------第4/4步:模型评估-------------------

correct_prediction = tf.equal(tf.argmax(y, 1), tf.argmax(y_, 1))
accuracy = tf.reduce_mean(tf.cast(correct_prediction, tf.float32))
print(accuracy)
print(accuracy.eval({x: mnist.test.images, y_: mnist.test.labels,
                    keep_prob: 1.0}))

importapp.input_dataasinput_data

importtensorflowastf#输入数据使用本章第一节生成的训练和测试数据。train_files=tf.train.match_filenames_once("/path/to/MNIST_TF/output.tfrecords")test_files=tf.train.match_filenames_once("/path/to/MNIST_TF/output_test.tfrecords")#-------------------------------------------数据集-----------------------------------------------------------#解析一个TFRecord的方法。defparser(record):features=tf.parse_single_example(record,features={'image_raw':tf.FixedLenFeature([],tf.string),#'pixels':tf.FixedLenFeature([],tf.int64),'label':tf.FixedLenFeature([],tf.int64)})decoded_images=tf.decode_raw(features['image_raw'],tf.uint8)retyped_images=tf.cast(decoded_images,tf.float32)images=tf.reshape(retyped_images,[784])labels=tf.cast(features['label'],tf.int32)#pixels=tf.cast(features['pixels'],tf.int32)returnimages,labelsbatch_size=100#定义组合数据batch的大小。shuffle_buffer=10000#定义随机打乱数据时buffer的大小。#定义读取训练数据的数据集。dataset=tf.data.TFRecordDataset(train_files)dataset=dataset.map(parser)#对数据进行shuffle和batching操作。这里省略了对图像做随机调整的预处理步骤。dataset=dataset.shuffle(shuffle_buffer,seed=1).batch(batch_size)#dataset=dataset.batch(batch_size)#不打乱#重复NUM_EPOCHS个epoch。间接定义了训练次数NUM_EPOCHS=2dataset=dataset.repeat(NUM_EPOCHS)#定义数据集迭代器。iterator=dataset.make_initializable_iterator()image_batch,label_batch=iterator.get_next()#-------------------------------------------神经网络-----------------------------------------------------------INPUT_NODE=784OUTPUT_NODE=10LAYER1_NODE=500REGULARAZTION_RATE=0.001#正则化速率LEANING_RATE_BASE=0.001#基础学习率LEARNING_RATE_DECAY=0.99#学习率的衰减率#定义神经网络的结构以及优化过程。这里与7.3.4小节相同。definference(input_tensor,weights1,biases1,weights2,biases2):#这里用了relu激活函数layer1=tf.nn.relu(tf.matmul(input_tensor,weights1) biases1)#返回输出层这里没用激活函数,因为后面会用softmaxreturntf.matmul(layer1,weights2) biases2#生成隐藏层参数weights1=tf.Variable(tf.truncated_normal([INPUT_NODE,LAYER1_NODE],stddev=0.1,seed=1))biases1=tf.Variable(tf.constant(0.1,shape=[LAYER1_NODE]))#生成输出层参数weights2=tf.Variable(tf.truncated_normal([LAYER1_NODE,OUTPUT_NODE],stddev=0.1,seed=1))biases2=tf.Variable(tf.constant(0.1,shape=[OUTPUT_NODE]))y=inference(image_batch,weights1,biases1,weights2,biases2)global_step=tf.Variable(0,trainable=False)#不需要在滑动平均的类里训练,其他的权重和偏向都需要cross_entropy=tf.nn.sparse_softmax_cross_entropy_with_logits(logits=y,labels=label_batch)cross_entropy_mean=tf.reduce_mean(cross_entropy)#损失函数的计算regularizer=tf.contrib.layers.l2_regularizer(REGULARAZTION_RATE)regularaztion=regularizer(weights1) regularizer(weights2)loss=cross_entropy_mean regularaztion#------------------设置学习速率----------------------------------#这里的除法mnist.train.num_examples/BATCH_SIZE若等于x,则为x迭代才能过完整个训练集,而这句话意思是进行x次才更新一次速率learning_rate=tf.train.exponential_decay(LEANING_RATE_BASE,global_step,55000/batch_size,LEARNING_RATE_DECAY)#反向传播 优化损失函数train_step=tf.train.GradientDescentOptimizer(learning_rate).minimize(loss,global_step=global_step)#train_step=tf.train.GradientDescentOptimizer(LEANING_RATE_BASE).minimize(loss)#-------------------------------------------测试-----------------------------------------------------------#定义测试用的Dataset。test_dataset=tf.data.TFRecordDataset(test_files)test_dataset=test_dataset.map(parser)test_dataset=test_dataset.batch(batch_size)#定义测试数据上的迭代器。test_iterator=test_dataset.make_initializable_iterator()test_image_batch,test_label_batch=test_iterator.get_next()#定义测试数据上的预测结果。test_logit=inference(test_image_batch,weights1,biases1,weights2,biases2)predictions=tf.argmax(test_logit,axis=-1,output_type=tf.int32)#-------------------------------------------sess-----------------------------------------------------------#声明会话并运行神经网络的优化过程。withtf.Session()assess:#初始化变量。sess.run((tf.global_variables_initializer(),tf.local_variables_initializer()))#初始化训练数据的迭代器。sess.run(iterator.initializer)i=0#循环进行训练,直到数据集完成输入、抛出OutOfRangeError错误。whileTrue:try:i =1print(i)sess.run([train_step])ifi==1:print(image_batch)print(image_batch.eval())excepttf.errors.OutOfRangeError:breaki=0test_results=[]test_labels=[]#初始化测试数据的迭代器。sess.run(test_iterator.initializer)#获取预测结果。whileTrue:try:pred,label=sess.run([predictions,test_label_batch])test_results.extend(pred)test_labels.extend(label)i =1print(i)excepttf.errors.OutOfRangeError:break#计算准确率correct=[float(y==y_)for(y,y_)inzip(test_results,test_labels)]accuracy=sum(correct)/len(correct)print("基础学习速率NOCHANGE:",LEANING_RATE_BASE)print("不含滑动平均值")print("Testaccuracyis:",accuracy)

先贴代码:

sess.run(init)

平台:
1.windows 10 64位
2.Anaconda3-4.2.0-Windows-x86_64.exe (当时TF还不支持python3.6,又懒得在高版本的anaconda下配置多个Python环境,于是装了一个3-4.2.0(默认装python3.5),建议装anaconda3的最新版本,TF1.2.0版本已经支持python3.6!)
3.TensorFlow1.1.0

importtensorflowastf

  1. 定义loss和优化器
  2. 训练
  3. 模型评估

# 用梯度下降算法(gradient descent algorithm)以0.01的学习速率最小化交叉熵

  1. hidden1_drop = tf.nn.dropout(hidden1, keep_prob) 给 hindden1层增加Droput,返回新的层hidden1_drop,keep_prob是 Droput的比例
  2. mnist.train.next_batch() 来详细讲讲 这个函数。一句话概括就是,打乱样本顺序,然后按顺序读取batch_size 个样本 进行返回。
    具体看代码及其注释,首先要找到函数定义,在tensorflowcontriblearnpythonlearndatasets 下的mnist.py

    def next_batch(self, batch_size, fake_data=False, shuffle=True):

     """Return the next `batch_size` examples from this data set.
         可以接收三个参数,第二个没搞明白,第三个就是打乱样本顺序啦
         默认为打乱,不想打乱可以加上  shuffle=False
     """
     # 第一个if 是对 fake_data的,默认是不用管啦
     if fake_data:
       fake_image = [1] * 784
       if self.one_hot:
         fake_label = [1]   [0] * 9
       else:
         fake_label = 0
       return [fake_image for _ in xrange(batch_size)], [
           fake_label for _ in xrange(batch_size)
       ]
     # self._index_in_epoch是被初始化为 0
     # start就是此 batch第一个样本所在整个数据集的编号
     start = self._index_in_epoch
     # Shuffle for the first epoch
     # 这个if是在第一次的时候才运行,因为打乱样本只需要进行一次
     if self._epochs_completed == 0 and start == 0 and shuffle:
       perm0 = numpy.arange(self._num_examples)
       numpy.random.shuffle(perm0)
       self._images = self.images[perm0]
       self._labels = self.labels[perm0]
     # Go to the next epoch 当最后一个batch小于
     # 这个if是针对 样本数不能整除batch_size而设定的
     if start   batch_size > self._num_examples:
       # Finished epoch
       self._epochs_completed  = 1
       # Get the rest examples in this epoch
       rest_num_examples = self._num_examples - start
       images_rest_part = self._images[start:self._num_examples]
       labels_rest_part = self._labels[start:self._num_examples]
       # Shuffle the data
       if shuffle:
         perm = numpy.arange(self._num_examples)
         numpy.random.shuffle(perm)
         self._images = self.images[perm]
         self._labels = self.labels[perm]
       # Start next epoch
       start = 0
       self._index_in_epoch = batch_size - rest_num_examples
       end = self._index_in_epoch
       images_new_part = self._images[start:end]
       labels_new_part = self._labels[start:end]
       return numpy.concatenate((images_rest_part, images_new_part), axis=0) , numpy.concatenate((labels_rest_part, labels_new_part), axis=0)
     else:
     # 其实,正常情况下,只执行下面两条语句,以上代码体现了此代码的健壮性
     # self._index_in_epoch其实就是为下一个batch的start做准备的 
     # end 就是本batch的 最后一个样本所在整个数据集的编号
     # 本batch的第一个样本的编号(start) 在上面已经赋值了
       self._index_in_epoch  = batch_size  
       end = self._index_in_epoch 
       return self._images[start:end], self._labels[start:end]
    

#把布尔值转换成浮点数,然后取平均值

主要内容:
1.基于多层感知器的mnist手写数字识别(代码注释)
2.该实现中的函数总结

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

整体分四步:
1.定义算法公式

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

'''一个Variable代表一个可修改的张量,存在在TensorFlow的用于描述交互性操作的图中。

对于各种机器学习应用,一般都会有模型参数,可以用Variable表示。'''

foriinrange(1000):

# 为了计算交叉熵,我们首先需要添加一个新的占位符用于输入正确值:

# 启动我们的模型,并且初始化变量

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

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

sess = tf.Session()

#评估我们的模型

# 训练模型,这里我们让模型循环训练1000次

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

# 训练模型

Tensorflow的官方文档中提供了一个很好的mnist的demo数据,在这里我把我执行的代码分享一下。具体的代码参考https://github.com/weizy1981/TensorFlow

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

init = tf.global_variables_initializer()

#评估我们的模型

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

# 导入数据

这里只是把利用softmax来识别手下数字的程序说明一下:

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

它们可以用于计算输入值,也可以在计算中被修改。

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

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

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

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

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

# 计算交叉熵

#用 tf.equal 来检测我们的预测是否真实标签匹配

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

# 初始化我们创建的变量

本文由美高梅4858官方网站发布,转载请注明来源

关键词: 数据 函数 速率 神经网络 t