tfboys——tensorflow模块学习（四）

2024年4月14日 121次阅读来源: tensorflow

tensorflow功能函数

tf.abs 计算张量的绝对值

abs （ 
    x ， 
    name = None
 ）
定义在：tensorflow/python/ops/math_ops.py。
参考指南：数学>基本数学函数
计算张量的绝对值。
给定一个实数的张量 x，该操作返回一个包含每个元素的绝对值的张量 x。例如，如果 x 是输入元素，y 是输出元素，则此操作将计算\\（y = | x | \\）。
ARGS：
x：一个类型为 float32，float64，int32，或 int64 的 Tensor 或 SparseTensor。
name：操作的名称（可选）。
返回：
与绝对值 x 有相同的大小和类型的一个 Tensor 或 SparseTensor 。

tf.accumulate_n 返回张量列表的元素和

accumulate_n （     
               inputs ，     
               shape = None ，     
               tensor_dtype = None ，     
               name = None 
）
定义在tensorflow/python/ops/math_ops.py。
参考指南：数学>减少
返回张量列表的元素和。
（可选）通过 shape 和 tensor_dtype 进行形状和类型检查，否则推断这些。
注意：此操作不可微分，如果输入取决于可训练的变量，则不能使用该操作。请在这种情况时使用 tf.add_n。
除了可微分性，tf.accumulate_n 执行与 tf.add_n 相同的操作，但不等待所有的输入在开始总结之前准备就绪。如果输入在不同时间准备就绪，这可以节省内存，因为最小临时存储与输出大小成比例，而不是输入大小。
例如：
#tensor 'a' 是 [[1，2]，[3，4]] #tensor `b` 是 [[5，0]，[0,6]] tf.accumulate_n （[一， b ，一] ） == >  [ [ 7 ， 4 ] ， [ 6 ， 14 ] ]#明确地通过形状并输入 tf.accumulate_n （[一， b ，一个] ，shape= [ 2 ， 2 ] ， tensor_dtype = tf.int32 ）  == >  [ [ 7 ， 4 ] ， [ 6 ， 14 ] ]
ARGS：
inputs：Tensor 对象的列表，它们的形状和类型都相同。
shape：输入元素的形状。
tensor_dtype：输入的类型。
name：操作的名称（可选）。
返回：
与输入元素有相同的形状和类型的张量。
举：
ValueError：如果输入不具有相同的形状和 dtype, 或者无法推断出形状。

tf.acos 计算张量元素的 acos

acos （     
     x ，     
     name = None 
）
参考指南：数学>基本数学函数
计算张量元素的 acos。
ARGS：
x：一个张量，它必须是下列类型之一：half，float32，float64，int32，int64，complex64，complex128。
name：操作的名称（可选）。
返回：
返回一个张量，它与 x 具有相同的类型。

tf.add 计算张量的和

add （     
    x ，     
    y ，     
    name = None 
）
参考指南：Math>算术运算符
上述操作返回 x + y 元素。
注意：Add 支持广播，而 AddN 不支持。更多关于广播的信息在这里。
ARGS：
x：一个 Tensor。必须是下列类型之一：half，float32，float64，uint8，int8，int16，int32，int64，complex64，complex128，string。
y：一个 Tensor。必须与 x 具有相同的类型。
name：操作的名称（可选）。
返回：
返回一个 Tensor，它与 x 具有相同的类型。

tf.add_check_numerics_ops check_numerics操作

add_check_numerics_ops （）
定义在：tensorflow/python/ops/numerics.py。
请参阅指南：控制流程>调试操作
该操作将 check_numerics 连接到每个浮点张量。
check_numerics 操作本身被添加到每个 half，float 或 double 张量所在的图中。对于图中的所有 ops，check_numerics 其所有（half，float 或 double）都保证在其任何输出 check_numerics 操作之前运行。
返回：
根据所添加的所有运算 check_numerics 的操作的一组操作。

tf.add_n 添加张量元素

add_n （ 
    inputs ， 
    name = None
 ）
定义在tensorflow/python/ops/math_ops.py。
参考指南：数学>基本数学函数
添加所有输入的张量元素。
ARGS：
inputs：Tensor 对象的列表，每个对象的形状和类型都相同。
name：操作的名称（可选）。
返回：
返回一个与输入元素相同的形状和类型的张量。
注意：
ValueError：如果输入不具有相同的形状和 dtype，或者无法推断出形状。

tf.add_to_collection 包装Graph.add_to

add_to_collection （
     name ，
     值
）
定义在tensorflow/python/framework/ops.py。
查看指南：构建图>图形集合
使用默认图形来包装 Graph.add_to
查看 tf.Graph.add_to_collection 更多详情。
ARGS：
name：集合的关键。例如，GraphKeys 类包含许多标准的集合名称。
value：要添加到集合中的值。

tf.AggregationMethod 梯度组合

定义在tensorflow/python/ops/gradients_impl.py。
参见指南：Training函数>梯度计算
用于组合梯度的类列表聚合方法。
计算偏导数可能需要聚合梯度贡献。此类列出了可用于在关系图中组合梯度的各种方法:
ADD_N：使用 “AddN” 操作将所有梯度项相加为一个操作的一部分。它具有在执行任何聚合之前所有梯度必须准备好的属性。
DEFAULT：系统选择的默认聚合方法。
类成员
ADD_N
DEFAULT
EXPERIMENTAL_ACCUMULATE_N
EXPERIMENTAL_TREE

tf.argmax 返回张量的最大值索引

argmax （ 
    input ， 
    axis = None ，
    name = None ，
    dimension = None
 ）
定义在tensorflow/python/ops/math_ops.py。
参考指南：数学>序列比较和索引
返回在张量的坐标轴上具有的最大值的索引。
请注意，在关联的情况下，返回值的身份不能保证。
ARGS：
input：张量，必须是下列类型之一：float32，float64，int64，int32，uint8，uint16，int16，int8，complex64，complex128，qint8，quint8，qint32，half。
axis：张量，必须是以下类型之一：int32，int64。当类型是 int32 时，要满足：0 <= axis < rank（input），描述输入向量的哪个轴减少。对于矢量，使用 axis = 0。
name：操作的名称（可选）。
返回：
返回张量的 int 64 类型。

同理有tf.argmin

tf.arg_max 返回张量维度上最大值的索引

arg_max （
     input ，
     dimension ，
     name = None
  ）
返回在张量维度上具有最大值的索引。
请注意，在关联的情况下，返回值的身份不能保证。
ARGS：
input：张量。必须是下列类型之一：float32，float64，int64，int32，uint8，uint16，int16，int8，complex64，complex128，qint8，quint8，qint32，half。
dimension：张量。必须是以下类型之一：int32，int64。当类型为 int32 时，应满足：0 <= dimension <rank（input）。描述输入张量的哪个维度可以减少。对于向量，请使用 dimension = 0。
name：操作的名称（可选）。
返回：
返回的张量类型为 int64。

同理tf.arg_min

tf.assign

assign （
      ref ，
      value ，
      validate_shape = None ，
      use_locking = None ，
      name = None
  ）
定义在：tensorflow/python/ops/state_ops.py
参见指南：变量>变量帮助函数
通过将 “value” 赋给 “ref” 来更新 “ref”。
此操作输出在赋值后保留新值 “ref” 的张量。这使得更易于链接需要使用重置值的操作。
ARGS：
ref：一个可变的张量。应该来自变量节点。节点可能未初始化。
value：张量。必须具有与 ref 相同的类型。是要分配给变量的值。
validate_shape：一个可选的 bool。默认为 True。如果为 true, 则操作将验证 “value” 的形状是否与分配给的张量的形状相匹配；如果为 false, “ref” 将对 “值” 的形状进行引用。
use_locking：一个可选的 bool。默认为 True。如果为 True, 则分配将受锁保护;否则, 该行为是未定义的, 但可能会显示较少的争用。
name：操作的名称（可选）。
返回：
一个在赋值完成后将保留 “ref” 的新值的张量。
tf.assign_add
assign_add （
      ref ，
      value ，
      use_locking = None ，
      name = None
  ）
定义在：tensorflow/python/ops/state_ops.py
参见指南：变量>变量帮助函数
通过向 “ref” 添加 “value” 来更新 “ref”。
此操作在更新完成后输出 “ref”。这使得更易于链接需要使用重置值的操作。
ARGS：
ref：一个可变的张量。必须是下列类型之一：float32，float64，int64，int32，uint8，uint16，int16，int8，complex64，complex128，qint8，quint8，qint32，half。应该来自变量节点。
value：张量。必须有相同的类型 ref，要添加到变量的值。
use_locking：默认为 False；如果为真, 加法将被锁保护；否则，该行为是未定义的，但可能会显示较少的争用。
name：操作的名称（可选）。
返回：
与“REF”相同。返回是为了希望在更新变量后使用新值的操作的便利。
tf.assign_sub
assign_sub （
      ref ，
      value ，
      use_locking = None ，
      name = None
  ）
定义在：tensorflow/python/ops/state_ops.py
参见指南：变量>变量帮助函数
通过从 “ref” 中减去 “value” 来更新 “ref”。
此操作在更新完成后输出 “ref”，这使得更易于链接需要使用重置值的操作。
ARGS：
ref：一个可变的张量。必须是下列类型之一：float32，float64，int64，int32，uint8，uint16，int16，int8，complex64，complex128，qint8，quint8，qint32，half。应该来自变量节点。
value：张量。必须有相同的类型 ref。要减去变量的值。
use_locking：一个可选的 bool，默认为 False。如果为 True，减法将被锁定保护，否则行为是未定义的，但可能表现出较少的争用。
name：操作的名称（可选）。
返回：
与“REF”相同。返回是为了使得在更新变量后要使用新值的操作的便利。

tf.as_dtype

as_dtype （ type_value ）
定义在：tensorflow/python/framework/dtypes.py
参见指南：构建图>张量类型
将给定的 type_value 转换为 DType。
ARGS：
type_value：可以转换为 tf.DType 对象的值，这可能的英文一个 tf.DType 对象，一个 DataType 枚举，一个字符串类型名称或一个 numpy.dtype。
返回：
对应于 type_value 的 DType。
注意：
TypeError：如果 type_value 不能转换为 DType。

tf.as_string 将给定张量的条目转换为字符串

as_string （  
    input ，  
    precision = None ，  
    scientific = None，  
    shortest = None，  
    width = None，  
    fill = None，  
    name = None
  ）
参见指南：字符串>转换
将给定张量中的每个条目转换为字符串，支持很多数字。
类型和布尔值。
ARGS：
input：张量，必须是下列类型之一：int32，int64，complex64，float32，float64，bool，int8。
precision：一个可选的 int。默认为-1。用于浮点数的后十进制精度。仅在精度> -1时才使用。
scientific：一个可选的布尔值，默认为 False，使用科学计数表示浮点数。
shortest：一个可选的布尔值。默认为 False。对浮点数使用最短的表示（无论是科学的还是标准的）。
width：可选的 int。默认为-1。将前十进制数字填充到此宽度。适用于浮点数和整数，仅在 width> -1时才使用。
fill：可选的 string。默认为空。。要填充的值如果宽度 > -1 。如果为空，则用空格填充；另一个典型值是 “0”，字符串不能超过1个字符。
name：操作的名称（可选）。
返回：
类型字符串的张量。

tf.batch_to_space

batch_to_space （
      input，
      crops，
      block_size ，
      name = None
  ）
定义在：tensorflow/python/ops/array_ops.py
参见指南：张量变换>分割和连接
用于 T 型的4维张量的 BatchToSpace。
这是更通用的 BatchToSpaceND 的旧版本。
将批处理 (permutes) 数据重新排列到空间数据块中，然后进行裁剪。这是 SpaceToBatch 的逆向转换。更具体地说，此操作输出输入张量的一个副本，其中，批处理维度中的值在空间块中移动到高度和宽度维度，然后沿高度和宽度尺寸进行裁剪。
ARGS：
input：张量。4-D 张量与形状 [batch*block_size*block_size, height_pad/block_size, width_pad/block_size, depth]。请注意，输入张量的批量大小必须可以被 block_size * block_size 整除。
crops：张量。必须是以下类型之一：int32，int64。具有形状 [2, 2] 的非负整数的2维张量。它指定从空间维度的中间结果中裁剪多少元素，如下所示：
crops = [[crop_top, crop_bottom], [crop_left, crop_right]] 
block_size：一个 int 就是>= 2。
name：操作的名称（可选）。
返回：
返回张量。具有与输入相同的类型。4维形状 [batch, height, width, depth]，其中：
height = height_pad - crop_top - crop_bottom
width = width_pad - crop_left - crop_right
ATTR block_size 必须大于 1，它表示块的大小。
一些例子：
（1）对于以下输入的形状 [4, 1, 1, 1] 和 BLOCK_SIZE 为2：
[[[[1]]], [[[2]]], [[[3]]], [[[4]]]]
输出张量具有形状 [1, 2, 2, 1] 和值：
x = [[[[1], [2]], [[3], [4]]]]
（2）对于以下输入的形状 [4, 1, 1, 3] 和 BLOCK_SIZE 为2：
[[[1, 2, 3]], [[4, 5, 6]], [[7, 8, 9]], [[10, 11, 12]]]
输出张量具有形状 [1, 2, 2, 3] 和值：
x = [[[[1, 2, 3], [4, 5, 6]],      [[7, 8, 9], [10, 11, 12]]]]
（3）对于以下输入的形状 [4, 2, 2, 1] 和 BLOCK_SIZE 为2：
x = [[[[1], [3]], [[9], [11]]],
     [[[2], [4]], [[10], [12]]],
     [[[5], [7]], [[13], [15]]],
     [[[6], [8]], [[14], [16]]]]
输出张量具有形状 [1, 4, 4, 1] 和值：
x = [[[1],   [2],  [3],  [4]],
     [[5],   [6],  [7],  [8]],
     [[9],  [10], [11],  [12]],
     [[13], [14], [15],  [16]]]
（4）对于以下输入的形状 [8, 1, 2, 1] 和 BLOCK_SIZE 2：
x = [[[[1], [3]]], [[[9], [11]]], [[[2], [4]]], [[[10], [12]]],
     [[[5], [7]]], [[[13], [15]]], [[[6], [8]]], [[[14], [16]]]]
输出张量具有形状 [2, 2, 4, 1] 和值：
x = [[[[1], [3]], [[5], [7]]],
     [[[2], [4]], [[10], [12]]],
     [[[5], [7]], [[13], [15]]],
     [[[6], [8]], [[14], [16]]]]
tf.batch_to_space_nd
batch_to_space_nd （
     input，
     block_shape ，
     crops，
     name = None
 ）
参见指南：张量变换>分割和连接
T 型的 n-D 张量的 BatchToSpace。
此操作将 “批处理” 维度0重塑为形状 block_shape + [batch] 的 M + 1 维度, 将这些块重新交错到空间维度定义的网格 [1,…, M], 以获得与输入相同的秩的结果。这个中间结果的空间维度, 可以根据作物选择裁剪产生输出。这与 SpaceToBatch 相反。请参见下面的详细描述。
ARGS：
input：张量。N – D 具有形状 input_shape = [batch] + spatial_shape + remaining_shape，其中 spatial_shape 具有 M 个维度。
block_shape：张量。必须是以下类型之一：int32，int64。1-D 形状 [M]，所有值必须> = 1。
crops：张量。必须是以下类型之一：int32，int64。2-D 具有形状 [M, 2]，所有值必须> = 0。crops[i] = [crop_start, crop_end] 指定从输入维度裁剪的量 i + 1，这对应于空间维度 i。需要 crop_start[i] + crop_end[i] <= block_shape[i] * input_shape[i + 1]。此操作等同于以下步骤：
重塑 input 为 reshaped 形状：[block_shape [0]，…，block_shape [M-1]，batch / prod（block_shape），input_shape [1]，…，input_shape [N-1]]
reshaped 产生 permuted 形状的允许尺寸 [batch / prod（block_shape））
input_shape [1]，block_shape [0]，...，input_shape [M]，block_shape [M-1]
 input_shape [M + 1]，...，input_shape [N-1]]
重塑 permuted 以产生 reshaped_permuted 的形状 [batch / prod（block_shape），
 input_shape [1] * block_shape [0]，...，input_shape [M] * block_shape [M-1]
input_shape [M + 1]，...，input_shape [N-1]]
裁剪尺寸的开始和结束 [1, …, M] 的 reshaped_permuted 根据 crops，以产生形状的输出：[batch / prod（block_shape），
input_shape [1] * block_shape [0] - crops[0,0] - crops[0,1]，...，input_shape [M] * block_shape [M-1] - crops[M-1,0] - crops[M-1,1]，
input_shape [M + 1]，...，input_shape                [N-1]]
一些例子：
（1）对于以下输入的形状 [4, 1, 1, 1]，block_shape = [2, 2] 和 crops = [[0, 0], [0, 0]]：
       [[[[1]]], [[[2]]], [[[3]]], [[[4]]]]
       输出的张量具有形状 [1, 2, 2, 1] 和值：
       x = [[[[1], [2]], [[3], [4]]]]
（2）对于以下输入的形状 [4, 1, 1, 3]，block_shape = [2, 2] 和 crops = [[0, 0], [0, 0]]：
       [[[1, 2, 3]], [[4, 5, 6]], [[7, 8, 9]], [[10, 11, 12]]]
       输出的张量具有形状 [1, 2, 2, 3] 和值：
       x = [[[[1, 2, 3], [4, 5, 6]], [[7, 8, 9], [10, 11, 12]]]]
（3）对于下列输入 [4, 2, 2, 1]，block_shape = [2, 2] 和 crops = [[0, 0], [0, 0]]：
       x = [[[[1], [3]], [[9], [11]]], [[[2], [4]], [[10], [12]]], [[[5], [7]], [[13], [15]]], [[[6], [8]], [[14], [16]]]]
       输出的张量具有形状 [1, 4, 4, 1] 和值：
       x = [[[1], [2], [3], [4]], [[5], [6], [7], [8]], [[9], [10], [11], [12]], [[13], [14], [15], [16]]]
（4）对于下列输入 [8, 1, 3, 1]，block_shape = [2, 2] 和 crops = [[0, 0], [2, 0]]：
       x = [[[[0], [1], [3]]], [[[0], [9], [11]]], [[[0], [2], [4]]], [[[0], [10], [12]]], [[[0], [5], [7]]], [[[0], [13], [15]]], [[[0], [6], [8]]], [[[0], [14], [16]]]]
       输出的张量具有形状 [2, 2, 4, 1] 和值：
       x = [[[[1], [2], [3], [4]], [[5], [6], [7], [8]]], [[[9], [10], [11], [12]], [[13], [14], [15], [16]]]]
* name：操作的名称（可选）。
返回：
返回张量，与 input 具有相同的类型。

tf.bincount 计算整数数组值出现的次数

bincount （ 
    arr ， 
    weights = None， 
    minlength = None， 
    maxlength = None， 
    dtype = tf.int32
 ）
定义在：tensorflow/python/ops/math_ops.py。
计算整数数组中每个值的出现次数。
如果 minlength 与 maxlength 没有给出，返回与长度的矢量 tf.reduce_max(arr) + 1，如果发射是非空的，则长度为0。如果权重是非零, 则输出的索引 i 存储每个索引中的权重值之和, 其中的相应值是 i。
ARGS：
arr：非负值的 int32 张量。
weights：如果非 None，则与 arr 的形状必须相同。对于每个 arr 值，bin 将以相应的权重递增而不是1。
minlength：如果给定，确保输出至少具有长度 minlength ，必要时在末尾填充零。
maxlength：如果给定，在 arr 中跳过等于或大于的值 maxlength，确保输出的长度最多为 maxlength。
dtype：如果权重为 None，则确定输出 bins 的类型。
返回：
返回与权重或给定的 dtype 相同的 dtype 的向量。bin 值。

tf.bitcast 张量类型转换

bitcast （ 
    input， 
    type， 
    name = None
 ）
参见指南：张量变换
在不复制数据的情况下，将张量从一种类型转换到另一种类型。
给定张量输入，此操作返回的张量与数据类型的输入具有相同缓冲区信息。
如果输入数据类型 T 大于输出数据类型，则形状将从 […] 更改为 […，sizeof（T）/ sizeof（type）]。
如果 T 小于 type，则操作者要求最右边的维度等于 sizeof（type）/ sizeof（T）。然后形状从 […，sizeof（type）/ sizeof（T）] 转到 […]。
注意：Bitcast 被当为低级的计算，因此具有不同字节序的机器将给出不同的结果。
ARGS：
input：张量。必须是下列类型之一：float32，float64，int64，int32，uint8，uint16，int16，int8，complex64，complex128，qint8，quint8，qint32，half。
type：一个 tf.DType 来自：tf.float32, tf.float64, tf.int64, tf.int32, tf.uint8, tf.uint16, tf.int16, tf.int8, tf.complex64, tf.complex128, tf.qint8, tf.quint8, tf.qint32, tf.half。
name：操作的名称（可选）。
返回：
返回 type 型张量。

tf.cast 张量投射

cast （  
    x ，  
    dtype ，  
    name = None
  ）
定义在：tensorflow/python/ops/math_ops.py
参见指南：张量变换>铸造
将张量投射到新的类型。
该操作将 x（在张量的情况下）或 x.values（在 SparseTensor 情况下）投射到 dtype。
例如：
＃tensor`a` is [1.8,2.2]，dtype = tf.float  
tf.cast（a， tf.int32 ） == >  [ 1 ， 2 ]   #dtype = tf.int32
ARGS：
x：一个张量或 SparseTensor。
dtype：目标类型。
name：操作的名称（可选）。
返回：
与 x 具有相同形状的张量或 SparseTensor。
注意：
TypeError：当 x 不能投射到 dtype。

tf.ceil 使用ceil返回不下于x的最小整数

ceil （ 
    x ， 
    name = None
 ）
参考指南：数学>基本数学函数
上述操作返回不小于 x 的元素最小整数。
ARGS：
x：张量；必须是下列类型之一：half，float32，float64。
name：操作的名称（可选）。
返回：
返回一个张量，它与 x 具有相同的类型。

tf.check_numerics 检查NaN和Inf值的张量

check_numerics （ 
    tensor， 
    message， 
    name = None
 ）
请参阅指南：控制流程>调试操作
检查 NaN 和 Inf 值的张量。
当运行时，如果张量有任何不是数字(NaN) 或无穷大(Inf) 的值，就会报告一个 InvalidArgument 错误。否则，按原样通过张量。
ARGS：
tensor：一个张量。必须是下列类型之一：half，float32，float64。
message：一个字符串。是错误消息的前缀。
name：操作的名称（可选）。
返回：
返回一个张量，与 tensor 具有相同的类型。

tf.cholesky 计算方阵的Cholesky分解

cholesky （
     input，
     name = None
 ）
参考指南：数学函数>矩阵数学函数
计算一个或多个方阵的 Cholesky 分解。
输入是一个张量的形状：[…, M, M]，其最内侧的2个维形成方形矩阵，具有与上述单矩阵 Cholesky 分解相同的约束条件。输出是与包含所有输入子矩阵 [..,:,:] 的 Cholesky 分解的输入相同形状的张量。
ARGS：
input：一个张量。必须是以下类型之一：float64，float32。形状是 […, M, M]。
name：操作的名称（可选）。
返回：
返回一个张量，与 input 具有相同的类型。形状是 […, M, M]。
tf.cholesky_solve
cholesky_solve （ 
    chol ， 
    rhs ， 
    name = None
 ）
定义在：tensorflow/python/ops/linalg_ops.py。
参考指南：数学函数>矩阵数学函数
求解系统的线性方程 A X = RHS，给出 Cholesky 因式分解。
#解决10个独立的2x2线性系统： 
A =  ... #shape 10x2x2 
RHS =  ... #shape 10x2x1
chol = tf .cholesky（A）  #shape 10x2x2 
X = tf 。cholesky_solve （ CHOL ， RHS ）  ＃10形状×2×1个
#tf.matmul（A，X）〜RHS 
X[3，：，0]   #解线性系统A [3，：，：1 = RHS [ 3，，，0]

#解决长度为10批次的每个成员的五个线性系统（K = 5）。
A =  ... #shape 10x2x2 
RHS =  ... #shape 10x2 x5 
...
X[3 ，：，2 ]   #解线性系统A [3，：，：1 = RHS [3，：1,2]
ARGS：
chol：一个张量。类型必须是 float32 或 float64，形状是 […, M, M]。Cholesky 分解 A，例如 chol = tf.cholesky(A)。因此，只有 chol 的最后两个维度的下三角形部分（包括对角线）被使用。严格上半部分被假定为零并且不被访问。
rhs：一个张量，与 chol 有相同类型，形状是 […, M, K]。
name：操作的名字。默认为 cholesky_solve。
返回：
返回解决方案 A x = rhs，形状是 […, M, K]。

tf.clip_by_average_norm 张量值剪辑到最大平均L2-norm

clip_by_average_norm （  
    t ，  
    clip_norm ，  
    name = None
  ）
定义在：tensorflow/python/ops/clip_ops.py
参见指南：Training函数>梯度剪辑
将张量值剪辑到最大平均 L2-norm。
给定一个张量 t 和一个最大的剪辑值 clip_norm，此操作规范化 t，使其平均 L2-norm 小于或等于 clip_norm。具体地说，如果平均 L2-norm 已经小于或等于 clip_norm，则 t 不会被修改。如果平均 L2-norm 大于 clip_norm，则此操作将返回与 t 相同的类型和形状的张量，其值设置为:
t * clip_norm / l2norm_avg(t)
在这种情况下，输出张量的平均 L2-norm 为 clip_norm。
此操作通常用于在将渐变应用于优化程序之前对其进行剪辑。
ARGS：
t：一个张量。
clip_norm：一个0维 (标量) 张量 > 0，最大剪辑值。
name：操作的名称（可选）。
返回：
返回一个剪辑张量。

tf.clip_by_value 剪辑TensorFlow张量为指定的最大值和最小值

clip_by_value （ 
    t ， 
    clip_value_min ， 
    clip_value_max ， 
    name = None
 ）
定义在：tensorflow/python/ops/clip_ops.py。
参见指南：Training函数>梯度剪辑
将张量值剪辑到指定的最小值和最大值。
给定一个张量 t, 此操作返回与 t 相同类型和形状的张量, 其值被裁剪为 clip_value_min 和 clip_value_max。任何小于 clip_value_min 的值都设置为 clip_value_min。任何大于 clip_value_max 的值都设置为 clip_value_max。
ARGS：
t：张量。
clip_value_min：0 维 (标量) 张量，或与 t 具有相同形状的张量，是要剪辑的最小值。
clip_value_max：0 维 (标量) 张量, 或与 t 具有相同形状的张量，是要剪辑的最大值。
name：操作的名称（可选）。
返回：
返回一个剪辑张量。
注意：
ValueError：如果剪辑的张量将触发数组广播，则返回的张量大于输入。

tf.complex 如何将TensorFlow的实数转换为复数

complex（ 
    real， 
    imag， 
    name=None
 ）
定义在：tensorflow/python/ops/math_ops.py。
参考指南：数学函数>复数函数
将两个实数转换为复数。
给定 real 表示复数的实部的张量和 imag 表示复数的虚部的张量，该操作的返回形式为 \（a + bj \）的元数字的复数，其中 a 表示 real 部分，b 表示 imag 部分。
输入的张量 real 和 imag 必须具有相同的形状。
例如：
# 张量 'real' 是 [2.25, 3.25]
# 张量 `imag` 是 [4.75, 5.75]
tf.complex(real, imag) ==> [[2.25 + 4.75j], [3.25 + 5.75j]]
ARGS：
real：张量。必须是以下类型之一：float32，float64。
imag：张量。必须与 real 具有相同的类型。
name：操作的名称（可选）。
返回：
返回 complex64 或 complex128 类型的张量。

tf.concat 将TensorFlow张量沿一个维度串联

concat （ 
    values ， 
    axis ， 
    name = 'concat' 
）
定义在：tensorflow/python/ops/array_ops.py。
参见指南：张量变换>张量的分割和连接
将张量沿一个维度串联。
将张量值的列表与维度轴串联在一起。如果 values[i].shape = [D0, D1, … Daxis(i), …Dn]，则连接结果有形状。
[D0, D1, ... Raxis, ...Dn]
当
Raxis = sum(Daxis(i))
也就是说，输入张量的数据将沿轴维度连接。
输入张量的维数必须匹配, 并且除坐标轴外的所有维度必须相等。
例如：
T1 =  [ [ 1 ， 2 ， 3 ] ， [ 4 ， 5 ， 6 ] ] 
T2 =  [ [ 7 ， 8 ， 9 ] ， [ 10 ， 11 ， 12 ] ] 
tf.concat（[T1 ，T2] ，0） == >  [[1 , 2 ，3 ]，[4 ，5 ，6]，[7 ，8 ，9]，[10 ，11，12]] 
tf.concat（[T1 ，T2] ，1） == >  [[ 1 ，2 ，3 ，7 ，8 ，9 ]，[4 ，5 ，6，10 ，11 ,12]]

＃张量 t3 的形状[2,3] 
＃张量 t4 的形状[2,3] 
tf.shape（tf.concat（[ t3 ， t4 ] ， 0 ）） == >  [ 4 ， 3 ] 
tf.shape（ tf.concat（[t3 ，t4 ] ， 1 ）） == >  [ 2 ， 6 ]
注意：如果沿着新轴连接，请考虑使用堆栈。例如:
tf.concat （[ tf.expand_dims （t ，axis） for t in tensors] ，axis）
可以重写为
tf.stack（tensors，axis = axis）
ARGS：
values：张量对象或单个张量列表。
axis：0 维 int32 张量，要连接的维度。
name：操作的名称（可选）。
返回：
由输入张量的连接引起的张量。

tf.convert_to_tensor 将给定值转换为张量

convert_to_tensor （ 
    value ， 
    dtype = None ， 
    name = None ， 
    preferred_dtype = None
 ）
定义在：tensorflow/python/framework/ops.py。
见指南：构建图>实用功能，生成常量，序列和随机值，控制流，高阶函数，图像，输入和读取器，数学，神经网络，稀疏张量，字符串操作，张量处理操作，张量转换，变量，包装python函数
将给定值转换为张量。
此函数将各种类型的 Python 对象转换为 Tensor 对象。它接受 Tensor 对象，numpy 数组，Python 列表和 Python 标量。例如：
import numpy as np

def my_func(arg):
  arg = tf.convert_to_tensor(arg, dtype=tf.float32)
  return tf.matmul(arg, arg) + arg

# The following calls are equivalent.
value_1 = my_func(tf.constant([[1.0, 2.0], [3.0, 4.0]]))
value_2 = my_func([[1.0, 2.0], [3.0, 4.0]])
value_3 = my_func(np.array([[1.0, 2.0], [3.0, 4.0]], dtype=np.float32))
当在 Python 中编写新的操作 (如上面示例中的 my_func) 时，此函数很有用。所有标准的 Python op 构造函数都将此函数应用于它们的每个张量值输入，这使得 ops 能够接受 numpy 数组、Python 列表和标量对象。
ARGS：
value：其类型具有已注册的张量转换函数的对象。
dtype：返回的张量的可选元素类型。如果缺少该类型, 则将从值的类型中推断出。
name：创建新的张量时要使用的可选名称。
preferred_dtype：返回张量的可选元素类型, 当 dtype 为 None 时使用。在某些情况下，调用方在转换为张量时可能没有 dtype，因此 preferred_dtype 可以作为软首选项使用。如果转换为 preferred_dtype 是不可行的，则此参数无效。
返回：
返回基于值的输出。
注意：
TypeError：如果没有为值注册转换函数。
RuntimeError：如果注册的转换函数返回无效值。

tf.convert_to_tensor_or_indexed_slices 将给定的对象转换为张量或IndexedSlices

convert_to_tensor_or_indexed_slices （ 
    value ， 
    dtype = None ， 
    name = None
 ）
定义在：tensorflow/python/framework/ops.py。
参见指南：构建图>实用功能
将给定的对象转换为张量或 IndexedSlices。
如果值为 IndexedSlices 或 SparseTensor，则将其原封不动地返回。否则，它将转换为使用 convert_to_tensor () 的张量。
ARGS：
value：可由 convert_to_tensor () 使用的 IndexedSlices、SparseTensor 或对象。
dtype：（可选）返回的张量或 IndexedSlices 所需的 DType。
name：(可选)创建新的张量时要使用的名称。
返回：
基于值的张量、IndexedSlices 或 SparseTensor。
注意：
ValueError：如果 dtype 与值的元素类型不匹配。

tf.convert_to_tensor_or_sparse_tensor TensorFlow将值转换为SparseTensor或张量

该函数别名：
tf.contrib.framework.convert_to_tensor_or_sparse_tensor
tf.convert_to_tensor_or_sparse_tensor
convert_to_tensor_or_sparse_tensor （ 
    value ， 
    dtype = None ， 
    name = None
 ）
定义在：tensorflow/python/framework/sparse_tensor.py。
参见指南：构建图>实用函数，框架（contrib）
将值转换为 SparseTensor 或张量。
ARGS：
value：A SparseTensor，SparseTensorValue或其类型具有注册Tensor转换功能的对象。SparseTensor、SparseTensorValue 或其类型具有已注册的张量转换函数的对象。
dtype：返回张量的可选元素类型。如果缺少该类型，则将从值的类型中推断出。
name：创建新的张量时要使用的可选名称。
返回：
返回基于值的 SparseTensor 或张量。
注意：
RuntimeError：如果结果类型与 dtype 不兼容。

tf.count_nonzero 计算TensorFlow中非零元素的个数

count_nonzero(
    input_tensor,
    axis=None,
    keep_dims=False,
    dtype=tf.int64,
    name=None,
    reduction_indices=None
)
定义在：tensorflow/python/ops/math_ops.py。
参考指南：数学函数>减少张量的计算
在张量的维度上计算的非零元素的个数。
沿轴线给定的维度减少 input_tensor。除非 keep_dims 是 true，否则张量的秩将在轴的每个条目中减少1。如果 keep_dims 为 true，则减小的维度将保持长度为1。
如果轴没有条目，则会减少所有维度，并返回具有单个元素的张量。
注意，浮点与零的比较是通过精确的浮点相等性检查完成的。对于非零检查，小值不四舍五入为零。
例如：
# 'x' is [[0, 1, 0]
#         [1, 1, 0]]
tf.count_nonzero(x) ==> 3
tf.count_nonzero(x, 0) ==> [1, 2, 0]
tf.count_nonzero(x, 1) ==> [1, 2]
tf.count_nonzero(x, 1, keep_dims=True) ==> [[1], [2]]
tf.count_nonzero(x, [0, 1]) ==> 3
ARGS：
input_tensor：要减少的张量。应该是数字类型，或 bool。
axis：要减少的维度。如果为 None（默认值），则减少所有维度。
keep_dims：如果为 true，则保留长度为1的缩小维度。
dtype：输出 dtype，默认为 tf.int64。
name：操作的名称（可选）。
reduction_indices：轴的旧名称（不推荐）。
返回：
减少的张量（非零值的数量）。

tf.count_up_to TensorFlow对ref进行递增

count_up_to （ 
    ref ， 
    limit ， 
    name = None
 ）
请参阅指南：控制流程>控制流程操作
递增 ‘ref’，直到达到 “limit”。
ARGS：
ref：一个可变的张量。必须是以下类型之一：int32，int64。应来自标量的变量节点。
limit：一int。如果递增 ref 将使其超出 limit，则会生成 “OutOfRange” 错误。
name：操作的名称（可选）。
返回：
返回一个张量，与 ref 具有相同的类型。
增量前的输入副本。如果没有其他内容的修改输入，则生成的值都将是不同的。

tf.create_partitioned_variables TensorFlow怎么创建分区变量列表

create_partitioned_variables(
    shape,
    slicing,
    initializer,
    dtype=tf.float32,
    trainable=True,
    collections=None,
    name=None,
    reuse=None
)
定义在：tensorflow/python/ops/partitioned_variables.py。
根据给定的 slicing 创建分区变量的列表。
目前只能对整个变量的一个维度的实现切片，并且可以通过沿该维度连接返回的列表来重建完整变量。
ARGS：
shape：整数列表。整个变量的形状。
slicing：整数列表。如何对变量分区。必须有相同长度的 shape。每个值表示在相应维度中创建多少个切片。目前只有一个值可以大于 1 ；也就是说，变量只能沿着一个维度进行切片。
为了方便起见，请求的分区数量不必均匀地分配相应的维数。如果没有，则分区的形状从分区 0 开始递增 1，直到所有的松弛都被吸收。调整规则在将来可能会改变，但是您可以使用不同的切片规格保存/恢复这些变量，这不成问题。
initializer：形状或变量初始化函数。如果一个函数，它将为每个切片调用一次，将切片的形状和数据类型作为参数传递。该函数必须返回与切片相同形状的张量。
dtype：变量的类型。如果初始值设定项为张量，则忽略。
trainable：如果为 True ，还将所有变量添加到图形集合 GraphKeys. TRAINABLE_VARIABLES。
collections：要向其中添加变量的图形集合键的列表，默认为 [GraphKeys.GLOBAL_VARIABLES]。
name：完整变量的可选名称。默认为 “PartitionedVariable”，并自动获取 uniquified。
reuse：是布尔值或者 None；如果为 true 且设置了名字，它将重用以前创建的变量。如果为 false，它将创建新的变量。如果为 None，它将继承父范围重用。
返回：
返回与切片相对应的变量的列表。
注意：
ValueError：如果任何参数的格式都是错误的。

tf.cumsum TensorFlow张量的累积和

cumsum （  
    x ，  
    axis = 0 ，  
    exclusive = False ，  
    reverse = False ，  
    name = None
  ）
定义在：tensorflow/python/ops/math_ops.py
参见指南：数学函数>张量扫描
计算张量 x 沿轴的累积总和。
默认情况下，此操作执行一个包含性的 cumsum，这意味着输入的第一个元素与输出的第一个元素相同:
tf.cumsum([a, b, c])  # => [a, a + b, a + b + c]
通过将 exclusive kwarg 设置为 True，执行专用的 cumsum：
tf.cumsum([a, b, c], exclusive = True)  # => [0, a, a + b]
通过设置reverse kwarg 为 True，cumsum 将以相反的方向执行：
tf.cumsum([a, b, c], reverse=True)  # => [a + b + c, b + c, c]
比这使用单独的 tf.reverse 操作更加有效。
reverse 和 exclusive kwargs 也可以组合在一起：
tf.cumsum([a, b, c], exclusive=True, reverse=True)  # => [b + c, c, 0]
ARGS：
x：一个张量。必须是下列类型之一：float32，float64，int64，int32，uint8，uint16，int16，int8，complex64，complex128，qint8，quint8，qint32，half。
axis：一个 int32 类型的张量（默认值：0）。
exclusive：如果为 True，则执行专有的 cumsum。
reverse：一个布尔值（默认值：False）。
name：操作的名称（可选）。
返回：
该函数返回一个张量，与 x 具有相同的类型。

tf.decode_base64 TensorFlow字符串解码

tf.decode_base64
decode_base64 （  
    input ，  
    name = None
  ）
参见指南：字符串操作>转换
解码 web-safe base64-encoded 字符串。
输入端可能有也可能没有填充。有关填充，请参见 EncodeBase64。Web 安全意味着输入必须使用 – 和 _ 而不是 + 和 /。
ARGS：
input：一个 string 类型的张量。对 Base64 编码字符串进行解码。
name：操作的名称（可选）。
返回：
返回 string 类型的张量，解码的字符串。

tf.decode_csv TensorFlow CSV转换

decode_csv （ 
    records ， 
    record_defaults ， 
    field_delim = None ， 
    use_quote_delim = None ， 
    name = None
 ）
参见指南：输入和读取器>转换，读取数据>从文件读取
将 CSV 记录转换为张量。每列映射到一个张量。
对于 CSV 记录，RFC 4180 格式是预期的（https://tools.ietf.org/html/rfc4180）。请注意，我们允许使用 int 或 float 字段的前导和尾部空格。
ARGS：
records： string 类型的张量。每个字符串都是 csv 中的记录/行，所有记录都应该具有相同的格式。
record_defaults：有 float32，int32，int64，string 类型的张量对象的列表。输入记录的每一列的一个张量，该列的标量为默认值，或者如果需要该列，则为空。
field_delim：可选的 string。默认为”，”。字符分隔符以分隔记录中的字段。
use_quote_delim：可选的 bool。默认为 True。如果为 false，则将双引号视为字符串字段内的常规字符。
name：操作的名称（可选）。
返回：
张量对象的列表，与 record_defaults 具有相同的类型。每个张量将具有与记录相同的形状。

tf.decode_raw TensorFlow将raw格式转换为张量

decode_raw （ 
    bytes ， 
    out_type ， 
    little_endian = None ， 
    name = None
 ）
参见指南：输入和读取器>数据格式转换，数据导入>从文件导入
将字符串的字节重新解释为数字的向量。
ARGS：
bytes：字符串类型的张量。所有元素的长度必须相同。
out_type：一个选自：tf.half，tf.float32，tf.float64，tf.int32，tf.uint8，tf.int16，tf.int8 以及 tf.int64 的 tf.DType 。
little_endian：可选的 bool 值，默认为 True。输入字节是否为小字节顺序。忽略存储在单个字节 (如 uint8) 中的 out_type 值。
name：操作的名称（可选）。
返回：
out_type 类型的张量。一个比输入字节多一个维度的张量。添加的维度的大小将等于字节的元素的长度除以要表示 out_type 的字节数。

tf.depth_to_space TensorFlow数据从深度排列为空间数据块

depth_to_space （ 
    input ， 
    block_size ， 
    name = None
 ）
参见指南：张量变换>分割和连接
T 型张量的 DepthToSpace。
将数据从深度重新排列为空间数据块。这是 SpaceToDepth 的逆向转换。更具体地说，此 op 输出输入张量的一个副本，其中来自深度维度的值在空间块中移动到高度和宽度维度。attr block_size 表示输入块的大小以及数据的移动方式。
从深度大小为 block_size * block_size 的数据块重新排列成不重叠的大小为 block_size x block_size 的数据块。
输出张量的宽度为 input_depth * block_size，而高度是 input_height * block_size。
输入张量的深度必须可以被 block_size * block_size 整除。
即，假设输入的形状是:[batch, height, width, depth]，输出的形状为:[batch, height*block_size, width*block_size, depth/(block_size*block_size)]；
这个操作要求输入的张量的秩为 4，并且 block_size > = 1 ，并且 block_size * block_size 是输入深度的除数。
此操作对于调整卷积（但保留所有数据）之间的激活是有用的，例如代替池。它也可用于训练纯卷积模型。
例如，给定此输入的形状[1, 1, 1, 4]，并且块大小为2：
x = [[[[1, 2, 3, 4]]]]
此操作将输出一个形状为 [1, 2, 2, 1] 的张量：
[[[[1], [2]],
  [[3], [4]]]]
这里，输入的批次为1，每个批次元素都有形状 [1, 1, 4]，相应的输出将具有2×2个元素，并具有1个通道，深度为：1 = 4 / (block_size * block_size)。输出元素的形状是[2, 2, 1]。
对于具有较大深度的输入张量，这里的形状为 [1, 1, 1, 12]，例如：
x = [[[[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]]]]
如果块大小为2，则此操作将返回以下形状为 [1, 2, 2, 3] 的张量：
[[[[1, 2, 3], [4, 5, 6]],
  [[7, 8, 9], [10, 11, 12]]]]
类似地，对于以下输入的形状 [1 2 2 4]，并且块大小为2，有：
x =  [[[[1, 2, 3, 4],
       [5, 6, 7, 8]],
      [[9, 10, 11, 12],
       [13, 14, 15, 16]]]]
运算符将返回以下张量 [1 4 4 1]：
x = [[ [1],   [2],  [5],  [6]],
     [ [3],   [4],  [7],  [8]],
     [ [9],  [10], [13],  [14]],
     [ [11], [12], [15],  [16]]]
ARGS：
input：一个张量。
block_size：是一个 int 并且大于等于 2。空间块的大小，与Space2Depth中的相同。
name：操作的名称（可选）。
返回：
返回一个张量，与 input 具有相同的类型。

tf.dequantize 反量化TensorFlow张量

dequantize(
    input,
    min_range,
    max_range,
    mode=None,
    name=None
)
参见指南：张量变换>分割和连接
上述代码将 “input” 张量反量化为浮动张量。
[min_range，max_range] 是指定 “input” 数据范围的标量浮点数。’mode’ 属性精确地用于控制将浮点值转换为其量化的等效项的计算。
在 “MIN_COMBINED” 模式下，张量的每个值将经历如下过程：
if T == qint8, in[i] += (range(T) + 1)/ 2.0
out[i] = min_range + (in[i]* (max_range - min_range) / range(T))
其中：range(T) = numeric_limits<T>::max() – numeric_limits<T>::min()
MIN_COMBINED 模式示例
如果输入来自 QuantizedRelu6，则输出类型为 quint8 (范围为 0-255)，但 QuantizedRelu6 的可能范围为0-6。因此，min_range 和 max_range 值是0.0 和6.0。在 quint8 上取消量化将取每个值，转换为浮点数并乘以 6 / 255。请注意，如果 quantizedtype 为 qint8，则操作将在强制转换之前将每个值添加 128。
如果模式是 “MIN_FIRST”, 则使用此方法:
number_of_steps = 1 << (# of bits in T)
range_adjust = number_of_steps / (number_of_steps - 1)
range = (range_max - range_min) * range_adjust
range_scale = range / number_of_steps
const double offset_input = static_cast<double>(input) - lowest_quantized;
result = range_min + ((input - numeric_limits<T>::min()) * range_scale)
ARGS：
input：张量。必须是下列类型之一：qint8，quint8，qint16，quint16，qint32。
min_range：类型为 float32 的张量。可能是 input 产生的最小标量值。
max_range：类型为 float32 的张量。可能是 input 产生的最大标量值。
mode：字符串，可以从：”MIN_COMBINED”, “MIN_FIRST”中选择，默认为”MIN_COMBINED”。
name：操作的名称（可选）。
返回：
返回类型为 float32 的张量。

tf.DeviceSpec TensorFlow设备规范

DeviceSpec 类
定义在：tensorflow/python/framework/device.py。
表示 TensorFlow 设备的（可能只是部分）规范。
在整个 TensorFlow 中使用 DeviceSpecs 来描述存储状态和计算发生的位置。使用 DeviceSpec 可以允许您分析设备规范字符串以验证其有效性、合并或以编程方式组合它们。
例：
# Place the operations on device "GPU:0" in the "ps" job.
device_spec = DeviceSpec(job="ps", device_type="GPU", device_index=0)
with tf.device(device_spec):
  # Both my_var and squared_var will be placed on /job:ps/device:GPU:0.
  my_var = tf.Variable(..., name="my_variable")
  squared_var = tf.square(my_var)
如果 DeviceSpec 是部分指定的，它将根据它定义的范围与其他 DeviceSpecs 合并。在内部范围内定义的 DeviceSpec 组件优先于外部作用域中定义的组件。
with tf.device(DeviceSpec(job="train", )):
  with tf.device(DeviceSpec(job="ps", device_type="GPU", device_index=0):
    # Nodes created here will be assigned to /job:ps/device:GPU:0.
  with tf.device(DeviceSpec(device_type="GPU", device_index=1):
    # Nodes created here will be assigned to /job:train/device:GPU:1.
DeviceSpec 由5个组件组成，每个组件都是可选指定的：
job：job 名称。
Replica：副本索引。
Task：任务索引。
Device type：设备类型字符串（例如 “CPU” 或 “GPU”）。
Device index：设备索引。
属性
job
replica
task
方法
__init__
__init__(
    job=None,
    replica=None,
    task=None,
    device_type=None,
    device_index=None
)
创建一个新的 DeviceSpec 对象。
ARGS：
job：字符串，可选的 job 名称。
replica：int，可选的副本索引。
task：int，可选的任务索引。
device_type：可选的设备类型字符串（例如 “CPU” 或 “GPU”）
device_index：int，可选的设备索引。如果未指定，则 device 表示 “任意的” device_index。
from_string
from_string （ spec ）
从字符串构造 DeviceSpec。
ARGS：
spec：一个字符串形式：/job:/replica:/task:/device:CPU: 或者 /job:/replica:/task:/device:GPU: 因为 cpu 和 gpu 是互斥的。所有条目都是可选的。
返回：
返回一个 DeviceSpec（设备规范）。
merge_from
merge_from （ dev ）
将 “dev” 的属性合并到此 DeviceSpec。
ARGS：
dev：一个 DeviceSpec。
parse_from_string
parse_from_string （ spec ）
将 DeviceSpec 名称解析为其组件。
ARGS：
spec：一个字符串形式：/job:/replica:/task:/device:CPU: 或者 /job:/replica:/task:/device:GPU: 因为 cpu 和 gpu 是互斥的。所有条目都是可选的。
返回：
返回 DeviceSpec（设备规范）。
注意：
ValueError：如果规范无效。
to_string
to_string （）
返回此 DeviceSpec 的字符串表示形式。
返回：
返回一个字符串的形式：/job:/replica:/task:/device::。

转自：https://www.w3cschool.cn/tensorflow_python/tensorflow_python-nlfw2du0.html

    原文作者：tensorflow
    原文地址: https://www.cnblogs.com/yifdu25/p/8313251.html
    本文转自网络文章，转载此文章仅为分享知识，如有侵权，请联系博主进行删除。