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::。