tfboys——tensorflow模块学习

Posted yif25

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了tfboys——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]。此操作等同于以下步骤：
    1. 重塑 input 为 reshaped 形状：[block_shape [0]，...，block_shape [M-1]，batch / prod（block_shape），input_shape [1]，...，input_shape [N-1]]
    2. 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]]
    3. 重塑 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]]
    4. 裁剪尺寸的开始和结束 [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

以上是关于tfboys——tensorflow模块学习的主要内容，如果未能解决你的问题，请参考以下文章

tfboys——tensorflow模块学习

tfboys——tensorflow模块学习

TensorFLow1.3文档中文翻译之1.0.0安装

TFboy养成记 MNIST Classification （主要是如何计算accuracy）

分布式TensorFlow 采坑记

TFboy养成记 tensorboard