tf.initializers.identity函数
定义在：tensorflow/python/ops/init_ops.py
生成单位矩阵的初始化程序.
仅用于2D矩阵.在使用十字绣网络时用到这个函数。
tf.reduce_max函数
计算张量的各个维度上的元素的最大值
import tensorflow as tf
max_value = tf.reduce_max([1, 3, 2])
with tf.Session() as sess:
max_value = sess.run(max_value)
print(max_value)##输出3
tf.sequence_mask函数
返回一个表示每个单元的前N个位置的mask张量，构建序列长度的mask标志，我理解就是判断输出每个维度前N个位置是否存在
import tensorflow as tf
mask = tf.sequence_mask([1, 3, 2], 5)
with tf.Session() as sess:
mask = sess.run(mask)
print(mask)
###
[[ True False False False False]
[ True True True False False]
[ True True False False False]]
###tf.reduce_max、tf.sequence_mask一起使用，根据目标序列长度，选出其中最大值，然后使用该值构建序列长度的mask标志
import tensorflow as tf
max_value = tf.reduce_max([1, 3, 2])
mask = tf.sequence_mask([1, 3, 2], max_value)
with tf.Session() as sess:
mask = sess.run(mask)
print(mask)
###
[[ True False False]
[ True True True]
[ True True False]]
###
tf.argmax函数
返回values在axis维度最大值的索引，此处对比 tf.reduce_max：返回values在axis维度的最大值
import tensorflow as tf
d = [[[1,2],[3,4],[5,6]],[[7,8],[9,10],[11,12]]] # d.shape = (2,3,2) 三维
idx = tf.argmax(d,axis=0)
val = tf.reduce_max(d,axis=0)
with tf.Session() as sess:
print(idx.eval()) # shape = (3,2) 二维
print(val.eval())
output:
[[1 1]
[1 1]
[1 1]]
[[ 7 8]
[ 9 10]
[11 12]]tf.expand_dims函数
expand_dims( input, axis=None, name=None, dim=None )
# 't' is a tensor of shape [2]
shape(expand_dims(t, 0)) ==> [1, 2]
shape(expand_dims(t, 1)) ==> [2, 1]
shape(expand_dims(t, -1)) ==> [2, 1]
# '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]tf.split函数
tf.split(value,num_or_size_splits,axis=0, num=None,name='split')
value ：输入的tensor
num_or_size_splits ：每个分割后的张量的尺寸，如果是个整数n，就将输入的tensor分为n个子tensor。如果是个tensor T，就将输入的tensor分为len(T)个子tensor。
axis ：A 0-D int32 Tensor；表示分割的尺寸；必须在[-rank(value), rank(value))范围内；默认为0。
num=None ：可选的，用于指定无法从 size_splits 的形状推断出的输出数。
这里需要注意num_or_size_splits的使用
如果num_or_size_splits是整数类型，num_split，则value沿维度 axis 分割成为num_split更小的张量。要求num_split均匀分配value.shape[axis]。
如果num_or_size_splits不是整数类型，则它被认为是一个张量size_splits，然后将value分割成len(size_splits)块。第i部分的形状与value的大小相同，除了沿维度axis之外的大小size_splits[i]。
import tensorflow as tf
value = [[1, 2, 3], [4, 5, 6]]
split1, split2 = tf.split(value, [0, 2], 0)
split3, split4, split5 = tf.split(value, [1, 0, 2], 1)
with tf.Session() as sess:
print("第一个变换结果：")
print(sess.run(split1))
print("**************")
print(sess.run(split2))
print("**************\r\n")
print("第二个变换结果：")
print(sess.run(split3))
print("**************")
print(sess.run(split4))
print("**************")
print(sess.run(split5))
第一个变换结果：
[]
**************
[[1 2 3]
[4 5 6]]
**************
第二个变换结果：
[[1]
[4]]
**************
[]
**************
[[2 3]
[5 6]]
tf.matmul函数
将矩阵a乘以矩阵b，生成a * b。
格式: tf.matmul(a, b, transpose_a=False, transpose_b=False, adjoint_a=False, adjoint_b=False, a_is_sparse=False, b_is_sparse=False, name=None)
参数:
a: 一个类型为 float16, float32, float64, int32, complex64, complex128 且张量秩 > 1 的张量。
b: 一个类型跟张量a相同的张量。
transpose_a: 如果为真, a则在进行乘法计算前进行转置。
transpose_b: 如果为真, b则在进行乘法计算前进行转置。
adjoint_a: 如果为真, a则在进行乘法计算前进行共轭和转置。
adjoint_b: 如果为真, b则在进行乘法计算前进行共轭和转置。
a_is_sparse: 如果为真, a会被处理为稀疏矩阵。
b_is_sparse: 如果为真, b会被处理为稀疏矩阵。
name: 操作的名字（可选参数）
返回值： 一个跟张量a和张量b类型一样的张量且最内部矩阵是a和b中的相应矩阵的乘积。
注意：
（1）输入必须是矩阵（或者是张量秩 >２的张量，表示成批的矩阵），并且其在转置之后有相匹配的矩阵尺寸。
（2）两个矩阵必须都是同样的类型，支持的类型如下：float16, float32, float64, int32, complex64, complex128。
引发错误:
ValueError: 如果transpose_a 和 adjoint_a, 或 transpose_b 和 adjoint_b 都被设置为真
import tensorflow as tf
h_doc=tf.placeholder(tf.int32,[None,30,512])
h_query=tf.placeholder(tf.int32,[None,10,512])
temp = tf.matmul(h_doc, h_query, adjoint_b = True) # tf.batch_matmul(h_doc, h_query, adj_y=True)
print(temp.get_shape())
#(?, 30, 10)tf.multiply函数
两个矩阵中对应元素各自相乘，就是点乘。
格式: tf.multiply(x, y, name=None)
参数:
x: 一个类型为:half, float32, float64, uint8, int8, uint16, int16, int32, int64, complex64, complex128的张量。
y: 一个类型跟张量x相同的张量。
返回值： x * y element-wise.
注意：
（1）multiply这个函数实现的是元素级别的相乘，也就是两个相乘的数元素各自相乘，而不是矩阵乘法，注意和tf.matmul区别。
（2）两个相乘的数必须有相同的数据类型，不然就会报错。
这里对比着numpy矩阵乘和点乘:
点乘可以直接用a*b就可以，在tensorflow也可以，
矩阵乘用np.dot(a,b)
tf.contrib.layers.batch_norm函数
tf.contrib.layers.batch_norm(
inputs,
decay=0.999,
center=True,
scale=False,
epsilon=0.001,
activation_fn=None,
param_initializers=None,
param_regularizers=None,
updates_collections=tf.GraphKeys.UPDATE_OPS,
is_training=True,
reuse=None,
variables_collections=None,
outputs_collections=None,
trainable=True,
batch_weights=None,
fused=None,
data_format=DATA_FORMAT_NHWC,
zero_debias_moving_mean=False,
scope=None,
renorm=False,
renorm_clipping=None,
renorm_decay=0.99,
adjustment=None
)
Batch Normalization通过减少内部协变量加速神经网络的训练。
可以用作conv2d和fully_connected的标准化函数。
参数：
1 inputs： 输入
2 decay ：衰减系数。合适的衰减系数值接近1.0,特别是含多个9的值：0.999,0.99,0.9。如果训练集表现很好而验证/测试集表现得不好，选择
小的系数（推荐使用0.9）。如果想要提高稳定性，zero_debias_moving_mean设为True
3 center：如果为True，有beta偏移量；如果为False，无beta偏移量
4 scale：如果为True，则乘以gamma。如果为False，gamma则不使用。当下一层是线性的时（例如nn.relu），由于缩放可以由下一层完成，
所以可以禁用该层。
5 epsilon：避免被零除
6 activation_fn：用于激活，默认为线性激活函数
7 param_initializers ： beta, gamma, moving mean and moving variance的优化初始化
8 param_regularizers ： beta and gamma正则化优化
9 updates_collections ：Collections来收集计算的更新操作。updates_ops需要使用train_op来执行。如果为None，则会添加控件依赖项以
确保更新已计算到位。
10 is_training:图层是否处于训练模式。在训练模式下，它将积累转入的统计量moving_mean并 moving_variance使用给定的指数移动平均值 decay。当它不是在训练模式，那么它将使用的数值moving_mean和moving_variance。11 scope：可选范围variable_scope注意：训练时，需要更新moving_mean和moving_variance。默认情况下，更新操作被放入tf.GraphKeys.UPDATE_OPS，所以需要添加它们作为依赖项train_op。例如：
update_ops = tf.get_collection(tf.GraphKeys.UPDATE_OPS) with tf.control_dependencies(update_ops): train_op = optimizer.minimize(loss)
可以将updates_collections = None设置为强制更新，但可能会导致速度损失，尤其是在分布式设置中。
返回 该操作的输出API：https://tensorflow.google.cn/api_docs/python/tf/contrib/layers/batch_norm
扫一扫
6484
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
