tensorflow函数学习笔记

 https://www.w3cschool.cn/tensorflow_python/tensorflow_python-4isv2ez3.html

 

tf.trainable_variables返回的是需要训练的变量列表

tf.all_variables返回的是所有变量的列表

import tensorflow as tf;    
import numpy as np;    
import matplotlib.pyplot as plt;    
  
v = tf.Variable(tf.constant(0.0, shape=[1], dtype=tf.float32), name='v')  
v1 = tf.Variable(tf.constant(5, shape=[1], dtype=tf.float32), name='v1')  
  
global_step = tf.Variable(tf.constant(5, shape=[1], dtype=tf.float32), name='global_step', trainable=False)  
ema = tf.train.ExponentialMovingAverage(0.99, global_step)  
  
for ele1 in tf.trainable_variables():  
    print ele1.name  
for ele2 in tf.all_variables():  
    print ele2.name  

输出：

v:0
v1:0

 

v:0
v1:0
global_step:0

 

分析：

上面得到两个变量，后面的一个得到上三个变量，因为global_step在声明的时候说明不是训练变量，用来关键字trainable=False。

 

》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》

tf.train.batch和tf.train.batch_join区别

http://blog.sina.com.cn/s/blog_6ca0f5eb0102wppn.html

 

这样就很容易明白了tf.train.batch和tf.train.batch_join的区别，一般来说，单一文件多线程，那么选用tf.train.batch（需要打乱样本，有对应的tf.train.shuffle_batch）；

而对于多线程多文件的情况，一般选用tf.train.batch_join来获取样本（打乱样本同样也有对应的tf.train.shuffle_batch_join使用）。

 

》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》 

capacity是队列的长度
min_after_dequeue是出队后，队列至少剩下min_after_dequeue个数据
假设现在有个test.tfrecord文件，里面按从小到大顺序存放整数0~100
1. tf.train.batch是按顺序读取数据，队列中的数据始终是一个有序的队列，
比如队列的capacity=20，开始队列内容为0,1，..,19=>读取10条记录后，队列剩下10,11，..,19，然后又补充10条变成=>10,11,...,29,
队头一直按顺序补充，队尾一直按顺序出队,到了第100条记录后，又重头开始补充0,1,2...

2. tf.train.shuffle_batch是将队列中数据打乱后，再读取出来，因此队列中剩下的数据也是乱序的，队头也是一直在补充（我猜也是按顺序补充），
比如batch_size=5,capacity=10,min_after_dequeue=5,
初始是有序的0,1，..,9(10条记录)，
然后打乱8,2,6,4,3,7,9,2,0,1(10条记录),
队尾取出5条，剩下7,9,2,0,1(5条记录),
然后又按顺序补充进来，变成7,9,2,0,1,10,11,12,13,14(10条记录)，
再打乱13,10,2,7,0,12...1(10条记录)，

再出队...

 

capacity可以看成是局部数据的范围，读取的数据是基于这个范围的，

 

在这个范围内，min_after_dequeue越大，数据越乱

这样按batch读取的话，最后会自动在前面添加一个维度，比如数据的维度是[1],batch_size是10，那么读取出来的shape就是[10,1]

 

》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》

tf.add_to_collection：把变量放入一个集合，把很多变量变成一个列表

tf.get_collection：从一个结合中取出全部变量，是一个列表

tf.add_n：把一个列表的东西都依次加起来

例如：

import tensorflow as tf;
import numpy as np;
import matplotlib.pyplot as plt;

v1 = tf.get_variable(name='v1', shape=[1], initializer=tf.constant_initializer(1))
tf.add_to_collection('loss', v1)
v2 = tf.get_variable(name='v2', shape=[1], initializer=tf.constant_initializer(2))
tf.add_to_collection('loss', v2)

with tf.Session() as sess:
sess.run(tf.initialize_all_variables())
print tf.get_collection('loss')
print sess.run(tf.add_n(tf.get_collection('loss')))

输出：

[<tensorflow.python.ops.variables.Variable object at 0x7f6b5d700c50>, <tensorflow.python.ops.variables.Variable object at 0x7f6b5d700c90>]
[ 3.]

 

》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》

在Tensorflow中，为解决设定学习率(learning rate)问题，提供了指数衰减法来解决。

通过tf.train.exponential_decay函数实现指数衰减学习率。

步骤：1.首先使用较大学习率(目的：为快速得到一个比较优的解);

             2.然后通过迭代逐步减小学习率(目的：为使模型在训练后期更加稳定);

代码实现：

 decayed_learning_rate=learining_rate*decay_rate^(global_step/decay_steps)  

其中，decayed_learning_rate为每一轮优化时使用的学习率；

            learning_rate为事先设定的初始学习率；

           decay_rate为衰减系数；

           decay_steps为衰减速度。

而tf.train.exponential_decay函数则可以通过staircase(默认值为False,当为True时，（global_step/decay_steps）则被转化为整数) ,选择不同的衰减方式。

代码示例：

global_step = tf.Variable(0)  

learning_rate = tf.train.exponential_decay(0.1, global_step, 100, 0.96, staircase=True)     #生成学习率  

learning_step = tf.train.GradientDescentOptimizer(learning_rate).minimize(....., global_step=global_step)  #使用指数衰减学习率  

learning_rate：0.1；staircase=True;则每100轮训练后要乘以0.96.

通常初始学习率，衰减系数，衰减速度的设定具有主观性(即经验设置)，而损失函数下降的速度与迭代结束之后损失的大小没有必然联系，

所以神经网络的效果不能单一的通过前几轮损失函数的下降速度来比较。

》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》

 

tf.nn.in_top_k组要是用于计算预测的结果和实际结果的是否相等，返回一个bool类型的张量，

tf.nn.in_top_k(prediction, target, K):prediction就是表示你预测的结果，大小就是预测样本的数量乘以输出的维度，类型是tf.float32等。target就是实际样本类别的标签，大小就是样本数量的个数。K表示每个样本的预测结果的前K个最大的数里面是否含有target中的值。一般都是取1。

例如：

 

import tensorflow as tf;

A = [[0.8,0.6,0.3], [0.1,0.6,0.4]]
B = [1, 1]
out = tf.nn.in_top_k(A, B, 1)
with tf.Session() as sess:
    sess.run(tf.initialize_all_variables())
    print sess.run(out)

输出：

 

[False  True]

 

解释：因为A张量里面的第一个元素的最大值的标签是0，第二个元素的最大值的标签是1.。但是实际的确是1和1.所以输出就是False 和True。如果把K改成2，那么第一个元素的前面2个最大的元素的位置是0，1，第二个的就是1，2。实际结果是1和1。包含在里面，所以输出结果就是True 和True.如果K的值大于张量A的列，那就表示输出结果都是true