tf 重要用法及概念

tf模型procedure

选择graph（非必须）

>>> graph = tf.Graph()
>>> with graph.as_default():

构建graph：batch/label, tf.placeholder()
构建graph：NN structures，weight/bias/logits/activations
构建graph：loss function
构建graph：optimizer
构建graph：变量初始化，通常tf.global_variables_initializer()
session初始化，常用with语句
run变量，sess.run(init)或init.run()
batch generating，用loop
sess.run(loss&optimizer)，需要feed_dict喂入9中数据
assessment，关键指标eval()和展示

tf.gfile.GFile()

类似于普通python之open()的命令，将返回一个文件操作句柄。

def read_words(filename):
    with tf.gfile.GFile(filename, 'r') as f:
        return f.read().replace('\n', '<eos>').split()

tf.convert_to_tensor(data)

将给定的list或array转换为tf的tensor对象。

>>> data = tf.convert_to_tensor([1,2,3])
<tf.Tensor 'Const:0' shape=(3,) dtype=int32>

tf.size(data)

返回data中全部元素的数量的tensor，注意返回的数量是全部元素，而不是len(data)

>>> tf.size(tf.convert_to_tensor([[1,2,3],[2,3,4]]))
<tf.Tensor 'Size_4:0' shape=() dtype=int32>
>>> sess=tf.Session()
>>> sess.run(tf.size(tf.convert_to_tensor([[1,2,3],[2,3,4]])))
6

tf.reshape(data, shape)

tf下面类似于np.reshape的函数，推断维度时用-1

>>> sess=tf.Session()
>>> sess.run(tf.reshape([1,2,3,4],[-1,2]))
array([[1, 2],
       [3, 4]])

tf.one_hot(indices, length)

根据indices生成one_hot形式的tensor，length为每个one-hot vector的长度，即最后一个axis的长度

>>> sess=tf.Session()
>>> a=tf.one_hot([1,2,4],5)
>>> sess.run(a)
array([[0., 1., 0., 0., 0.],
       [0., 0., 1., 0., 0.],
       [0., 0., 0., 0., 1.]], dtype=float32)
>>> b=tf.one_hot([[1,2,5],[3,4,6]],7)
>>> sess.run(b)
array([[[0., 1., 0., 0., 0., 0., 0.],
        [0., 0., 1., 0., 0., 0., 0.],
        [0., 0., 0., 0., 0., 1., 0.]],
       [[0., 0., 0., 1., 0., 0., 0.],
        [0., 0., 0., 0., 1., 0., 0.],
        [0., 0., 0., 0., 0., 0., 1.]]], dtype=float32)

tf.placeholder(dtype,shape)

类似于不需要进行初始化的tf变量，因为有的时候我们在声明变量的时候无法明确其初始值。其也称为占位符。我们只需要明确其类型和形状即可。形状表示中可用None进行推断，推断时需要注意非None维度的匹配，否则会报错，None推断通常是对应于训练batch中的batch长度。由于占位符没有初始值，因此在run的时候，我们需要给其“喂值”，即使用feed_dict.

>>> b = tf.placeholder(tf.float32, [None, 1])
>>> a = np.random.randint(0,5,(6,1))
>>> a
array([[1],
       [2],
       [3],
       [4],
       [3],
       [0]])
>>> sess = tf.Session()
>>> sess.run(b, feed_dict={b: a})
array([[1.],
       [2.],
       [3.],
       [4.],
       [3.],
       [0.]], dtype=float32)

tf.constant(value,dtype,shape)

生成一个给定值的张量常量。

>>> tf.constant([[1, 2, 3], [4, 5, 6]],tf.int32,[2,3])
<tf.Tensor 'Const:0' shape=(2, 3) dtype=int32>
>>> c=tf.constant([[1, 2, 3], [4, 5, 6]],tf.int32,[2,3])
>>> tf.Session().run(c)
array([[1, 2, 3],
       [4, 5, 6]])

tf.Variable(value,name=None)

tf张量变量，注意由于需要明确初始化数值，因此不需要设定形状参数，名字可有可无。

>>> a
array([0, 0, 4, 1, 4, 1])
>>> tf.Variable(a)
<tf.Variable 'Variable:0' shape=(6,) dtype=int32_ref>

tf math operations

>>> d = tf.add(b, c, name='d')
>>> a = tf.multiply(d, e, name='a')
>>> c = tf.log(5.0)

tf.reduce_mean(data,axis=0)

等同于np.mean，即tf的求均值函数。这里的reduce源于functional programming概念中的reduce paradigm，可忽略。

tf.reduce_sum(data,axis=0)

等同于np.sum，即tf的求和函数。这里的reduce源于functional programming概念中的reduce paradigm，可忽略。

tf.global_variables_initializer()

初始化全部模型参数

>>> init_op = tf.global_variables_initializer()
>>> sess = tf.Session()
>>> sess.run(init_op)

也可以写为init_op.run()

tf.Session().run(list,feed_dict)

tf张量和模型必须要在Session中run后才会真的进行计算和生成值，因此素有tf深度学习模型中必须有Session()和run()步骤。
tf的session在run的过程中，我们不需要去明确的run每一个操作，因为tf会根据图的结构自己寻找每步操所所依赖的前提变量或操作，然后自动run这些前提变量或操作。注意，如存在占位符变量，我们需要在run时喂入数据。

>>> sess = tf.Session()
>>> out = sess.run(a, feed_dict={b: np.arange(0, 10)[:, np.newaxis]})

另外，run将计算list中的全部目标值，返回相应数量的计算结果。

a, c = sess.run([optimiser, cross_entropy], 
                         feed_dict={x: batch_x, y: batch_y})

tf.random_normal(shape, mean=0.0, stddev=1.0, dtype=tf.float32)

取正态分布数值

>>> a = tf.random_normal([2,3])
>>> sess = tf.Session()
>>> sess.run(a)
array([[-0.25265786, -1.6633197 ,  0.71720666],
       [-0.12861042,  0.9900551 , -0.04970803]], dtype=float32)

tf.nn.relu(value)

rectified linear unit activation function，将大于0的数保持不变，小于0的数置为0

>>> sess = tf.Session()
>>> sess.run(tf.nn.relu([-5,1,3]))
array([0, 1, 3])

tf.nn.softmax(logits)

对logits内全部要素进行exp函数加权，注意logits必须为float，可以将其理解为每层layer的net input，即输入与权重相乘并加如bias后的值。

>>> import numpy as np
>>> aa = tf.nn.softmax([1.0,2.0,3.0])
>>> sess = tf.Session()
>>> sess.run(aa)
array([0.09003057, 0.24472848, 0.66524094], dtype=float32)
>>> a1,a2,a3 = np.exp(1),np.exp(2),np.exp(3)
>>> a4 = a1+a2+a3
>>> a1/a4
0.09003057317038046
>>> a2/a4
0.24472847105479767
>>> a3/a4
0.6652409557748219

tf.clip_by_value(data,min,max)

把data中的每一个元素的值都压缩在min和max之间。小于min的让它等于min，大于max的元素的值等于max

>>> sess=tf.Session()
>>> sess.run(tf.clip_by_value([1,3,5,7,9],3,7))
array([3, 3, 5, 7, 7])

tf.nn.softmax_cross_entropy_with_logits(labels,logits)

softmax在深度学习分类问题中通常作为输出层的activation function，以此将输出层的net input，即logits转换为概率输出。tf的softmax_cross_entropy函数的功能就是在输出层集成softmax激活函数以及cross_entropy熵或纯度评估函数，从而直接输出层的logits进行准确度评估。基本的思路就是先对logits进行softmax处理，从而生成各分类的概率评估：
$S_j=\cfrac{e^{a_j}}{\sum_{k=1} ^T e^{a_k}}$
而后根据各分类的概率评估以及各分类的实际值，进行cross entropy计算：
$L=-\sum\limits^{T}_{j=1} y_j \cdot ln(s_j)$
代码如下：

>>> labels = [1.0,1.0,0,0]
>>> logits = [1.0,2.0,5.0,3.0]
>>> sess = tf.Session()
>>> sess.run(tf.nn.softmax_cross_entropy_with_logits(labels=labels,logits=logits))
7.370365
>>> softmax_list=[np.exp(logits[i]) for i in range(len(logits))]
>>> softmax_list
[2.718281828459045, 7.38905609893065, 148.4131591025766, 20.085536923187668]
>>> softmax_sum=sum(softmax_list)
>>> softmax_sum
178.60603395315397
>>> softmax=[i/softmax_sum for i in softmax_list]
>>> softmax
[0.015219428864155927, 0.04137069692096015, 0.8309526605439513, 0.11245721367093255]
>>> cross_entropy_list=[-labels[i]*np.log(softmax[i]) for i in range(len(logits))]
>>> sum(cross_entropy_list)
7.370364905207625

可见我们逐项利用logtis计算softmax，而后在用此softmax与真实labels进行cross entropy计算后的得到的值是与直接使用tf中的softmax_cross_entropy_with_logits函数计算出来的值是完全一致的。

tf.train.GradientDescentOptimizer(learning_rate)

gradient descent最优化问题，需输入learning rate。
.minimize(loss) 根据optimizer对象最小化loss值。

>>> optimiser = tf.train.GradientDescentOptimizer(learning_rate=learning_rate).minimize(cross_entropy)

tf.argmax(data,axis=0)

返回data中的最大值的索引号，如果是向量，那就返回一个值，如果是矩阵，那就返回一个向量，这个向量的每一个维度都是相对应矩阵行的最大值元素的索引号。axis为取值维度参数。

>>> A = [[1,3,4,5,6]]
>>> B = [[1,3,4], [2,4,1]]
>>> sess.run(tf.argmax(A,0))
array([0, 0, 0, 0, 0], dtype=int64)
>>> sess.run(tf.argmax(A,1))
array([4], dtype=int64)
>>> sess.run(tf.argmax(B,1))
array([2, 1], dtype=int64)
>>> sess.run(tf.argmax(B,0))
array([1, 1, 0], dtype=int64)

tf.equal(A, B)

对比这两个矩阵或向量相对应的元素是否相等，如相等返回True，不等返回False，注意A和B的维度应相同，否则将报错。返回的值的维度与二者相同

>>> B = [[1,3,4], [2,4,1]]
>>> sess.run(tf.equal([1,2],[1,3]))
array([ True, False])
>>> sess.run(tf.equal(B,B))
array([[ True,  True,  True],
       [ True,  True,  True]])

tf.cast(value,dtype)

将value格式转化为指定的dtype

>>> sess.run(tf.cast([True,1],tf.float32))
array([1., 1.], dtype=float32)
>>> sess.run(tf.cast([True,1.0],tf.int8))
array([1, 1], dtype=int8)

Queuing

queue是tf中进行队列管理的工具，在效率上，queue强于我们通常在训练阶段使用的喂值工具feed_dict。