tfboys——tensorflow模块学习（四）

时间 2019-11-18

标签 tfboys tensorflow 模块学习繁體版

原文原文链接

tensorflow功能函数

tf.abs 计算张量的绝对值

abs （ 
    x ， 
    name = None
 ）
定义在：tensorflow/python/ops/math_ops.py。html

参考指南：数学>基本数学函数python

计算张量的绝对值。git

给定一个实数的张量 x，该操做返回一个包含每一个元素的绝对值的张量 x。例如，若是 x 是输入元素，y 是输出元素，则此操做将计算\\（y = | x | \\）。github

ARGS：

x：一个类型为 float32，float64，int32，或 int64 的 Tensor 或 SparseTensor。

name：操做的名称（可选）。

返回：

与绝对值 x 有相同的大小和类型的一个 Tensor 或 SparseTensor 。web

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

accumulate_n （     
               inputs ，     
               shape = None ，     
               tensor_dtype = None ，     
               name = None 
）
定义在tensorflow/python/ops/math_ops.py。编程

参考指南：数学>减小api

返回张量列表的元素和。数组

（可选）经过 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