Tensorflow常用API

tf.layers.dense()

全连接层。tf.layers.dense( input, units=k )会在内部自动生成一个权矩阵kernel和偏移项bias，各变量具体尺寸如下：对于尺寸为[m, n]的二维张量input， tf.layers.dense()会生成：尺寸为[n, k]的权矩阵kernel，和尺寸为[m, k]的偏移项bias。内部的计算过程为y = input * kernel + bias，输出值y的维度为[m, k]。

tf.layers.dense(
    inputs,   # 该层的输入数据
    units,   # 输出的大小（维数），整数或long
    activation=None,   # 选用的激活函数(神经网络的非线性层)，默认None，不用激活函数
    use_bias=True,   # 使用bias为True(默认使用)
    kernel_initializer=None,   # 权重矩阵的初始化函数。如果为None(默认值)，则使用tf.get_variable的默认初始化程序初始化权重
    bias_initializer=tf.zeros_initializer(),   # bias的初始化函数
    kernel_regularizer=None,   # 权重矩阵的正则函数
    bias_regularizer=None,   # bias的的正则函数
    activity_regularizer=None,
    kernel_constraint=None,
    bias_constraint=None,
    trainable=True,
    name=None,
    reuse=None
)

import tensorflow as tf

# 1. 调用tf.layers.dense计算
input = tf.reshape(tf.constant([[1., 2.], [2., 3.]]), shape=[4, 1])    
b1 = tf.layers.dense(input,
                     units=2,
                     kernel_initializer=tf.constant_initializer([2,2]),   # 初始化shape为1*2，值为2的权值矩阵
                     bias_initializer=tf.constant_initializer(value=1))     # 初始化shape为4*1，值为1的偏置向量


# 2. 采用矩阵相乘的方式计算
kernel = tf.reshape(tf.constant([2., 2.]), shape=[1, 2])
bias = tf.reshape(tf.constant([1., 1., 1., 1., 1., 1., 1., 1.]), shape=[4, 2])
b2 = tf.add(tf.matmul(input, kernel), bias)


with tf.Session()as sess:
    sess.run(tf.global_variables_initializer())
    print(sess.run(b1))
    print(sess.run(b2)) 

# [[3. 3.]
#  [5. 5.]
#  [5. 5.]
#  [7. 7.]]
# [[3. 3.]
#  [5. 5.]
#  [5. 5.]
#  [7. 7.]]

tf.nn.dropout()

该函数机制是为了防止或减轻过拟合，一般用在全连接层。在不同的训练过程中随机扔掉一部分神经元。也就是让某个神经元的激活值以一定的概率p，让其停止工作，这次训练过程中不更新权值，也不参加神经网络的计算。但是它的权重得保留下来（只是暂时不更新而已），因为下次样本输入时它可能又得工作了。

tf.nn.dropout(
	x,   # 输入数据
	keep_prob,   # 决定每个元素被保留的几率
	noise_shape=None,
	seed=None,
	name=None
)

# 该函数使x的一部分（概率大约为keep_prob）变为0，其余变为x/keep_prob,
# noise_shape可以使得矩阵x一部分行全为0或者部分列全为0

with tf.Session() as sess:
    d = tf.to_float(tf.reshape(tf.range(1,17),[4,4]))
    sess.run(tf.global_variables_initializer())
    print(d.get_shape(), sess.run(tf.shape(d)))
    print(sess.run(d))
    
    # 矩阵有一半左右的元素变为element/0.5,其余为0
    dropout_a44 = tf.nn.dropout(d, 0.5, seed = 2020, noise_shape = None)
    result_dropout_a44 = sess.run(dropout_a44)
    print(result_dropout_a44)

# (4, 4) [4 4]
# [[ 1.  2.  3.  4.]
#  [ 5.  6.  7.  8.]
#  [ 9. 10. 11. 12.]
#  [13. 14. 15. 16.]]
# [[ 0.  4.  6.  0.]
#  [ 0. 12.  0.  0.]
#  [18.  0. 22. 24.]
#  [26.  0.  0.  0.]]

tf.nn.embedding_lookup()

选取一个张量里面索引对应的元素。

tf.nn.embedding_lookup(
     params,   # 完整的嵌入张量
     ids,   # 要在params中查找的id
     partition_strategy='mod',
     name=None,
     validate_indices=True,
     max_norm=None
)

p = tf.Variable(tf.random_normal([5,1]))
b = tf.nn.embedding_lookup(p, [1, 3])   # 查找张量中的序号为1和3的

with tf.Session() as sess:
    sess.run(tf.global_variables_initializer())
    print(sess.run(p))
    print(sess.run(b))

# [[ 1.7974318 ]
#  [-1.5761899 ]
#  [ 0.2596668 ]
#  [ 0.21228862]
#  [ 1.9865903 ]]
# [[-1.5761899 ]
#  [ 0.21228862]]

import numpy as np
a = np.array([[0.1, 0.2, 0.3], [1.1, 1.2, 1.3], [2.1, 2.2, 2.3]])
idx1 = tf.Variable([0, 2], tf.int32)
out1 = tf.nn.embedding_lookup(a, idx1)

with tf.Session() as sess:
    sess.run(tf.global_variables_initializer())
    print(a)
    print(sess.run(out1))

# [[0.1 0.2 0.3]
#  [1.1 1.2 1.3]
#  [2.1 2.2 2.3]]
# [[0.1 0.2 0.3]
#  [2.1 2.2 2.3]]

tf.one_hot()

one_hot(
    indices,   # 指示on_value的位置,就是onehot给值1的位置
    depth,   # onehot编码矩阵维度
    on_value=None,   # 输出矩阵 起作用位置的值 默认1
    off_value=None,   # 输出矩阵 不起作用位置的值 默认0
    axis=None,
    dtype=None,
    name=None
)

indices = [0,2,3,5]
depth1 = 6   # indices没有元素超过(depth-1)
depth2 = 4   # indices有元素超过(depth-1)
a = tf.one_hot(indices,depth1)
b = tf.one_hot(indices,depth2)

with tf.Session() as sess:
    print('a = \n',sess.run(a))
    print('b = \n',sess.run(b))

# a = 
#  [[1. 0. 0. 0. 0. 0.]
#  [0. 0. 1. 0. 0. 0.]
#  [0. 0. 0. 1. 0. 0.]
#  [0. 0. 0. 0. 0. 1.]]
# b = 
#  [[1. 0. 0. 0.]
#  [0. 0. 1. 0.]
#  [0. 0. 0. 1.]
#  [0. 0. 0. 0.]]