Tensorflow 常见函数说明

最新推荐文章于 2022-05-12 21:14:26 发布

lainegates

最新推荐文章于 2022-05-12 21:14:26 发布

阅读量1.1k

点赞数

分类专栏： # tensorflow 深度学习文章标签： tensorflow rnn 深度学习

本文链接：https://blog.csdn.net/LaineGates/article/details/78833812

版权

深度学习同时被 2 个专栏收录

8 篇文章 0 订阅

订阅专栏

tensorflow

5 篇文章 0 订阅

订阅专栏

常见参数说明

epoch：整个数据集，通常几个epoch，就会完整跑几轮数据集（但随机取样时不一定会全用）
batch:一次训练的数据集大小，常见的128,256,…
learning rate:学习速度

常见函数说明

获取shape值

a = tf.Variable([[1,2,3],[4,5,6]],dtype=tf.float32)
print(a.shape) 
print(tf.shape(a))
# print => (2, 3)

变量作用域

tf.name_scope() & tf.variable_scope()
# name_scope只对op(+/-/...)操作起命名前缀作用
# variable_scope对op和variable都起命名前缀作用。
[作用域说明](http://blog.csdn.net/u012436149/article/details/53081454)
# ---示例---
with tf.variable_scope("foo"):
    with tf.name_scope("bar"):
        v = tf.get_variable("v", [1])
        x = 1.0 + v
assert v.name == "foo/v:0"
assert x.op.name == "foo/bar/add"

矩阵相乘

#矩阵a和b的轶必须>=2，相乘时维度计算[n,m,ta,k]X[n,m,k,tb]=[n,m,ta,tb]
tf.matmul(a, b, transpose_a=False, transpose_b=False, a_is_sparse=False, b_is_sparse=False, name=None) 
#矩阵按位乘
a*b

#算例
ma = tf.Variable(tf.constant(2.0, shape=[2,2]), dtype=tf.float32)
mb = tf.Variable(tf.constant(3.0, shape=[2,2]), dtype=tf.float32)

mc = ma*mb
md = tf.matmul(ma,mb)
print(sess.run(mc))
print(sess.run(md))
----结果----
[[ 6.  6.]
 [ 6.  6.]]
[[ 12.  12.]
 [ 12.  12.]]

全连接网络

在tensorflow例子里有全连接网络示例： $y_{pre}=softmax(wx+b)$
其实有简单写法

#生成全连接网络的便利函数
tensorflow.contrib.layers.fully_connected(
    inputs,
    num_outputs,
    activation_fn=tf.nn.relu,
    normalizer_fn=None,
    normalizer_params=None,
    weights_initializer=initializers.xavier_initializer(),
    weights_regularizer=None,
    biases_initializer=tf.zeros_initializer(),
    biases_regularizer=None,
    reuse=None,
    variables_collections=None,
    outputs_collections=None,
    trainable=True,
    scope=None
)
#它在底层调用用了，和numpy.tensordot一样，指定维度相乘
tf.tensordot(
    a,
    b,
    axes,
    name=None
)

注：这个函数的最大作用在于，如果x只是2维tensor，那么自己手写也没有问题，但对于v是3维以上的tensor就比较麻烦了。
比如tensor[batch_size, doc_len, hidden_size]，要每个时序都MLP一下，而batch_size又是大小可变，可写这个函数，就必须手动调用tf.tensordot，重复代码多，容易出错，但如果有fully_connected函数，这个工作就十分简单了。

掩码

用于去除不需要数据的影响，比如，softmax结果长度为5，[0.3,0.2,0.1,0.1,0.3]，但不想要后3个数，就可以用掩码函数来处理

 #生成结果为[1,1,...,0,0]，seqlen是1的个数,maxlen是序列长度。
 tf.sequence_mask(seqlen, maxlen=config.num_steps, dtype=tf.int32)

维度扩展

计算矩阵相乘但shape不同时常用

tf.expand_dims(input, dim, name=None)
# 't2' is a tensor of shape [2, 3, 5]
# shape(expand_dims(t2, 0)) ==> [1, 2, 3, 5]
# shape(expand_dims(t2, 2)) ==> [2, 3, 1, 5]
# shape(expand_dims(t2, 3)) ==> [2, 3, 5, 1]

pad操作

pad操作在卷积网络或自然语言处理相关任务中比较重要。
tensorflow提供了操作函数

tf.pad(
    tensor,
    paddings,  # N*2的数组，N必须与tensor的秩数相同，即，tensor是3维，N就得是3，之后的两个数据代表前后填充什么
    mode='CONSTANT', # "CONSTANT/REFLECT/SYMMETRIC"
    name=None,
    constant_values=0
)

示例：

t = tf.constant([[1, 2, 3], [4, 5, 6]])
paddings = tf.constant([[1, 1,], [2, 2]]) # 0维前后各加一个数，1维前后各加两个数
# 'constant_values' is 0.
# rank of 't' is 2.
tf.pad(t, paddings, "CONSTANT")  # [[0, 0, 0, 0, 0, 0, 0],
                                 #  [0, 0, 1, 2, 3, 0, 0],
                                 #  [0, 0, 4, 5, 6, 0, 0],
                                 #  [0, 0, 0, 0, 0, 0, 0]]

tf.pad(t, paddings, "REFLECT")  # [[6, 5, 4, 5, 6, 5, 4],
                                #  [3, 2, 1, 2, 3, 2, 1],
                                #  [6, 5, 4, 5, 6, 5, 4],
                                #  [3, 2, 1, 2, 3, 2, 1]]

tf.pad(t, paddings, "SYMMETRIC")  # [[2, 1, 1, 2, 3, 3, 2],
                                  #  [2, 1, 1, 2, 3, 3, 2],
                                  #  [5, 4, 4, 5, 6, 6, 5],
                                  #  [5, 4, 4, 5, 6, 6, 5]]

复制数据

有时需要对一个序列做同一个操作，需要同一组参数。
注：因为使用了这个操作，就可做到每次计算图到这一步，都会让Variable数据复制multiples次

tile(input, multiples, name=None)
# a = tf.Variable([[1,2],[2,3]], tf.float32)
# c = tf.tile(a, [3,1])
# sess.run(c)
# ==> array([[1, 2],
       [2, 3],
       [1, 2],
       [2, 3],
       [1, 2],
       [2, 3]], dtype=int32)

注：因为使用了这个操作，就可做到每次计算图到这一步，都会让Variable数据复制multiples次

动态Tensor数组

有时需要动态数据

tf.TensorArray( dtype,
    size=None,
    dynamic_size=None,
    clear_after_read=None,
    tensor_array_name=None,
    handle=None,
    flow=None,
    infer_shape=True,
    element_shape=None,
    colocate_with_first_write_call=True,
    name=None
)

# 获得输入数据
inputArray = tf.TensorArray(dtype=tf.float32, size=input_size) 
inputArray = inputArray.unstack(inputArray, input_emb)
# 获得输出数据
outputArray = tf.TensorArray(dtype=tf.float32, dynamic_size=True, size=0)
for i in range(tf.shape(input_size)[0]) :
#     依次输出结果
     outputArray.write(i, process(inputArray.read(i))

one hot

通常用于做label，计算cross_entropy

# 生成指定位为1的序列,序列个数为indices长度
tf.one_hot(indices, depth=10, on_value=None, off_value=None, axis=None, dtype=None, name=None) 
# tf.one_hot([2,3], depth=5) =>
#[[0, 0, 1, 0, 0]
# [0, 0, 0, 1, 0]]

生成正态分布的随机数

#截断区间为（μ-2σ，μ+2σ），其内的面积为95.449974%，如取值在这个范围外，则重新生成随机数。参考正态分布的“3σ”原则
tf.truncated_normal(shape, mean=0.0, stddev=1.0, dtype=tf.float32, seed=None, name=None)

#生成随机数，不会考虑取值范围
tf.random_normal(shape, mean=0.0, stddev=1.0, dtype=tf.float32, seed=None, name=None)

循环函数

#fn是被循环调用的函数，其第一个参数是前一步的输出值，第二参数是当前步的输入值
#elems值依次给fn作为第二个参数
#initializer确定了结果的shape，也会在循环开始时做为fn的第一个参数
#swap_memory是否允许cpu/gpu交换数据
tf.scan(fn, elems, initializer=None, parallel_iterations=10, back_prop=True,
         swap_memory=False, infer_shape=True, name=None)
定义于 [scan函数位置](https://github.com/tensorflow/tensorflow/blob/master/tensorflow/python/ops/functional_ops.py)
#例子如下
#def add(pre, cur): 
#    return pre+cur
#tf.scan(fn=add, elems=[1,2,2,2],initializer=0)
#返回结果为[ 1.  3.  5.  7.]
#迭代 0: fn(0.0, 1.0) == 1.0
#迭代 1: fn(1.0, 2.0) == 3.0
#迭代 2: fn(3.0, 2.0) == 5.0
#迭代 3: fn(5.0, 2.0) == 7.0

赋值函数

tf.assign(ref, value, validate_shape=None, use_locking=None, name=None)
定义于 [tensorflow/python/ops/state_ops.py](https://github.com/tensorflow/tensorflow/blob/r1.1/tensorflow/python/ops/state_ops.py)
需要说明的是这是个option，必须session.run(tf.assign(..))，赋值才会生效

RNN

cell = tf.nn.rnn_cell.BasicLSTMCell(num_units, forget_bias, input_size, state_is_tuple, activation)
　　　　 num_units: int, The number of units in the LSTM cell（就是指cell中隐藏层神经元的个数）；
　　　　 forget_bias: float, The bias added to forget gates (添加到“forget gates”的偏置，这里的“forget gates”指lstm网络中的component)；
　　　　 input_size: Deprecated and unused（这个参数以后会被废弃掉，就不用考虑了）；
　　　　 state_is_tuple: 为真表示，状态值是(c_state, m_state)构成的元组，比如每一个time step有K层，那么state结构为((c0, m0), (c1, m1), …, (ck, mk))；
　　　　 activation: cell中的激励函数；
　　　注：这个函数用于生成RNN网络的最基本的组成单元，这个类对象中还有一个比较重要的method，call(self, inputs, state, scope=None)，它确定了在forward propagation过程中，调用BasicLSTMCell对象时的输入输出参数。

cell = tf.nn.rnn_cell.MultiRNNCell(cells, state_is_tuple=True)
　　　　 cells: list of RNNCells that will be composed in this order（根据cells列表中的LSTMCell生成MultiRNNCell的基本组成单元，这里的MultiRNNCell是指每一时刻的输出由多层LSTMCell级联而成。显然，列表中的每个LSTMCell可以含有不同的权重参数）；
　　　　 state_is_tuple: 同上；

state = tf.nn.rnn_cell.MultiRNNCell.zero_state(batch_size, dtype)
　　　　 batch_size: 训练块的大小；
　　　　 dtype: 指定待返回的state变量的数据类型；
　　　注：这个函数用于返回全0的state tensor。state tensor的尺寸与层数、hidden units num、batch size有关系，前面两个在定义cell对象时已经指定过了，故这里要指定batch_size参数。
　　　这个函数要和之后的tf.nn.rnn_cell.BasicLSTMCell(input, state)一起理解。
　　　
tf.nn.rnn_cell.BasicLSTMCell(input, state)
input:一条数据的当前输入
state:当前隐藏层状态
注：这里要详细配合zero_state说下，（1）在每个batch中，输入数据可看作一个矩阵，一行是一条输入，zero_state初始化了这个矩阵。（2）一个batch内，权重矩阵W不会更新，那么完全可以同时运行n条数据，gpu传递数据代价较大，这个设计太牛了。（3）每次隐藏层新的值都传递了出来，但个人猜测单元内部会保留每个隐藏层的值后续更新权重矩阵用。