tfboys——tensorflow模塊學習（四）

本文轉載自查看原文 2018-01-18 22:01 4363 Tensorflow/ 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

免責聲明！

本站轉載的文章為個人學習借鑒使用，本站對版權不負任何法律責任。如果侵犯了您的隱私權益，請聯系本站郵箱yoyou2525@163.com刪除。

猜您在找 tfboys——tensorflow模塊學習（一） tfboys——tensorflow模塊學習（二） tfboys——tensorflow模塊學習（三） Tensorflow 的saved_model模塊學習 tensorflow 2.0 學習（八） keras模塊的認識 tensorflow學習一 TensorFlow Data模塊 TensorFlow 的常用模塊介紹學習tensorflow之mac上安裝tensorflow Tensorflow 學習筆記（一）TensorFlow入門