【总结】【python】【TensorFlow】tensorflow常见的数据处理函数--机器学习，深度学习，强化学习

Numpy：

1、numpy.random 链接

numpy中的random主要是用来产生随机数的一个模块。

2、numpy.newaxis 链接

numpy中的newaxis主要是帮助数组创建新轴，或者也叫增加维度。

3、numpy.lexsort  链接

numpy中的lexsort主要是对数组排序

TensorFlow：

1、tf.argmax(a,axis=)/tf.reduce_max(a,axis=)

返回a在axis最大值的索引/值

1.1、tf.assign(ref，value)

赋值函数，通过将 "value" 赋给 "ref" 来更新 "ref".

此操作输出在赋值后保留新值 "ref" 的张量.这使得更易于链接需要使用重置值的操作. 

2、tf.cast(a, dtype)

将a映射到数据类型dtype

3、tf.clip_by_value(a, min, max)

截取a使之在min和max之间，小于min的值等于min，大于max的值等于max

4、tf.cumsum(a,axis=,exclusive=False,reverse=False)

将张量a根据axis累计求和。exclusive指定了初始的输出是否要赋初值为0。reverse指定了是否要逆向

5、tf.cond(pred,true_fn = None,false_fn = None)

pred为True，返回true_fn

例如：

result = tf.cond(X < Y, lambda: tf.add(X, Z), lambda: tf.square(Y))

6、tf.equal(a,b)

比较张量对应的元素，如果相等就返回True，否则返回False，返回的张量维度和a是一样的

7、tf.expand_dims(a, dim)

在dim指定的维度给a维度+1

TensorFlow中，想要维度增加一维，可以使用tf.expand_dims(input, dim, name=None)函数。当然，我们常用tf.reshape(input, shape=[])也可以达到相同效果，但是有些时候在构建图的过程中，placeholder没有被feed具体的值，这时就会包下面的错误：TypeError: Expected binary or unicode string, got 1

8、tf.gather_nd(params,indices)

indices的最后一维指定了取params的哪几维填回indices，indices维度可能会减少

9、tf.identity(a)

计算图中定义一个和a相同的操作节点

10、layers.linear(input, output_num, scope=name)

from tensorflow.contrib.layers.python.layers import layers

从input到output的一个线性变化

11、tf.layers.dense

添加一个全连接层

tf.layers.dense(
    inputs,
    units,
    activation=None,
    use_bias=True,
    kernel_initializer=None,  # 卷积核的初始化器
    bias_initializer=tf.zeros_initializer(),  # 偏置项的初始化器，默认初始化为0
    kernel_regularizer=None,  # 卷积核的正则化，可选
    bias_regularizer=None,  # 偏置项的正则化，可选
    activity_regularizer=None,  # 输出的正则化函数
    kernel_constraint=None,   
    bias_constraint=None,
    trainable=True,
    name=None,  # 层的名字
    reuse=None  # 是否重复使用参数
)

12、MultiRNNCell

多层RNN网络

from tensorflow.contrib.rnn import GRUCell, LSTMCell, MultiRNNCell

encoder_cell = MultiRNNCell([GRUCell(num_units) for _ in range(num_layers)])

13、MutableHashTable

可以根据key，将张量a中的key替换成value的表，不会增加张量a的维度

from tensorflow.contrib.lookup.lookup_ops import MutableHashTable

table = MutableHashTable(key-dtype=,  # 键的类型
                        value-dtype=,  # 值的类型
                        default-value=,  # 当检索不到时的默认值
                        sharedname=,  # 如果非空，表将在多个session中以该名字共享
                        name=,  # 操作名
                        checkpoint=)  # 如果为真，表能从checkpoint中保存和恢复

# 给表赋初值
table.insert(key_list, value_list)
# 根据表替换张量值
table.lookup(a)

14、nest.flatten(a)

将嵌套结构压平，返回Python的list，如果是tensor，则不会被压平

15、tf.nn.dynamic_rnn

outputs, last_states = tf.nn.dynamic_rnn(
    cell=cell,  # RNN 单元
    dtype=tf.float64,  # dtype
    sequence_length=X_lengths,  # 输入的有效长度
    inputs=X  # padding后的输入
)  
# 输出：
# outputs 为输出，超过有效长度的部分为 0，
# last_states 为last_states，超过有效长度的部分重复最后一步的结果，是由(c,h)组成的tuple
# 可以节省计算资源

16、tf.nn.embedding_lookup(embed, id)

根据id从embed中查找嵌入并替换，id的维度会增加

16.1、tf.nn.moments(x,axis)

tf.nn.moments()函数用于计算均值和方差。

x: 形如：[batch_size, height, width, kernels]

axis: 求解的维度，如 [1,2,3]

返回：

Two Tensor objects: mean and variance.

两个Tensor对象：mean和variance.

17、tf.nn.raw_rnn

原始的RNN，每个时间步之前都会调用loop_fn，可以用来实现下个时间步之前自己的一些处理

outputs_ta, final_state, final_loop_state = rnn.raw_rnn(
        cell, loop_fn, parallel_iterations=parallel_iterations,
        swap_memory=swap_memory, scope=scope)

loop_fn需要自己重写

def loop_fn(time, cell_output, cell_state, loop_state):
"""loop_fn 是一个函数，这个函数在 rnn 的相邻时间步之间被调用。
            　　
    函数的总体调用过程为：
    1. 初始时刻，先调用一次loop_fn，获取第一个时间步的cell的输入，loop_fn 中进行读取初始时刻的输入。
    2. 进行cell自环　(output, cell_state) = cell(next_input, state)
    3. 在 t 时刻 RNN 计算结束时，cell 有一组输出 cell_output 和状态 cell_state，都是 tensor；
    4. 到 t+1 时刻开始进行计算之前，loop_fn 被调用，调用的形式为
    loop_fn( t, cell_output, cell_state, loop_state)，而被期待的输出为：(finished, next_input, initial_state, emit_output, loop_state)；
    5. RNN 采用 loop_fn 返回的 next_input 作为输入，initial_state 作为状态，计算得到新的输出。
    在每次执行（output， cell_state） =  cell(next_input, state)后，执行 loop_fn() 进行数据的准备和处理。

    参数:
    time: 第 time 个时间步之前的处理，起始为 0
    cell_output: 上一个时间步的输出
    cell_state: RNNCells 的长时记忆
    loop_state: 保存了上个时间步执行后是否已经结束，如果输出 alignments，还保存了存有 alignments 的 TensorArray
    
    返回:
    next_done:是否已经完成
    next_cell_input:下个时间步的输入
    next_cell_state:下个时间步的状态
    emit_output:实际的输出
    next_loop_state:保存一些循环信息
    """
return (next_done, next_cell_input, next_cell_state, emit_output, next_loop_state)

18、tf.nn.sparse_softmax_cross_entropy_with_logits(logits= , labels=)

sparse_softmax_cross_entropy_with_logits 中的labels接受直接的数字标签

softmax_cross_entropy_with_logits 中的labels是独热编码

19、tf.nn.sampled_softmax_loss

sampled_softmax

tf.nn.sampled_softmax_loss(weights, # Shape (num_classes, dim)     - floatXX
                     biases,        # Shape (num_classes)          - floatXX 
                     labels,        # Shape (batch_size, num_true) - int64
                     inputs,        # Shape (batch_size, dim)      - floatXX  
                     num_sampled,   # - int
                     num_classes,   # - int
                     num_true=1,  
                     sampled_values=None,
                     remove_accidental_hits=True,
                     partition_strategy="mod",
                     name="sampled_softmax_loss")

20、tf.one_hot(a,depth)

将张量a根据分类数量为depth进行one hot编码

21、tf.reduce_sum(a,[],keep_dims=False)

将张量a按照第2个参数进行求和，维度会减少，如果要保持维度，指定keep_dims=True

22、tf.reshape(a, [-1, 28, 28, 1])

将张量a根据第2个参数改变形状，-1位置根据a原本的形状推算出

23、tf.squeeze(a, squeeze_dims=[])

删除a中所有size为1的维度，如果不想删除全部，则可以通过squeeze_dims来指定

24、tf.split(a,[-1,2],axis=)

将张量a根据第2个参数，在axis上进行划分。如果参数中存在-1，则根据张量自动推算-1位置的值，一般只存在一个-1

25、tf.shape(a)

获取张量a各个方向上的维度

26、tf.stack 和 tf.unstack 链接

tf.stack 和 tf.unstack分别负责矩阵拼接（数据的升维）和分解（数据的降维）

27、tf.transpose 链接

用于交换输入张量的不同维度

28、tf.transpose(a,perm=[1,0])

交换a的维度0和1，通过perm参数可以交换任意几个维度

29、tf.tile(a,multiples=[])

将张量a根据第2个参数进行复制，例如multiples=[2,1,1]，则a第0个维度复制两遍，1,2维度保持不变

30、tf.TensorArray

tensor数组

ta = tf.TensorArray(size, dtype, dynamic_size=True)  # dynamic_size指定数组长度可变
ta.stack(name=None)  # 将TensorArray中元素叠起来当做一个Tensor输出
ta.unstack(value, name=None)  # 可以看做是stack的反操作，输入Tensor，输出一个新的TensorArray对象，value按照其axis=0进行分割
ta.write(index, value, name=None)  # 指定index位置写入Tensor
ta.read(index, name=None)  # 读取指定index位置的Tensor

31、tf.unstack(a,axis=)

将张量a根据axis从n+1维分解到n维tf.stack([a,b],axis=)

将张量a，b根据axis合并

32、tf.where(tensor,a,b)

tensor为bool类型的张量，a，b和tensor同维度，如果tensor的某位置为True，则用a上该位置的值回填

33、tf.zeros_like(a)/tf.ones_like(a)

返回一个和a相同，全0/全1填充的张量