Tensorflow Python API 翻譯（math_ops）（第一部分）

coderpai發表於2019-03-02

PythonAPI

作者：chen_h
微訊號 & QQ：862251340
微信公眾號：coderpai
我的部落格：請點選這裡

計劃現將 tensorflow 中的 Python API 做一個學習，這樣方便以後的學習。
原文連結

該章介紹有關數學符號操作的API

算術運算子

TensorFlow提供了一些操作，你可以使用基本的算術運算子新增到你的圖表。

tf.add(x, y, name = None)

解釋：這個函式返回x與y逐元素相加的結果。

注意：tf.add操作支援廣播形式，但是tf.add_n操作不支援廣播形式。

使用例子：

#!/usr/bin/env python
# -*- coding: utf-8 -*-

import tensorflow as tf 

a = tf.constant(2)
b = tf.constant(3)
c = tf.add(a, b)
sess = tf.Session()
print sess.run(c)
sess.close()複製程式碼

輸入引數：

x: 一個Tensor，資料型別是必須是以下之一：float32，float64，int8，int16，int32，complex64，int64。
y: 一個Tensor，資料型別必須和x相同。
name:（可選）為這個操作取一個名字。

輸出引數：

一個Tensor，資料型別和x相同。

tf.sub(x, y, name = None)

解釋：這個函式返回x與y逐元素相減的結果。

使用例子：

#!/usr/bin/env python
# -*- coding: utf-8 -*-

import tensorflow as tf 

a = tf.constant([1,2])
b = tf.constant(2)
c = tf.sub(a, b)
sess = tf.Session()
print sess.run(c)
sess.close()複製程式碼

輸入引數：

x: 一個Tensor，資料型別是必須是以下之一：float32，float64，int8，int16，int32，complex64，int64。
y: 一個Tensor，資料型別必須和x相同。
name:（可選）為這個操作取一個名字。

輸出引數：

一個Tensor，資料型別和x相同。

tf.mul(x, y, name = None)

解釋：這個函式返回x與y逐元素相乘的結果。

使用例子：

#!/usr/bin/env python
# -*- coding: utf-8 -*-

import tensorflow as tf 

a = tf.constant([1,2])
b = tf.constant(2)
c = tf.mul(a, b)
sess = tf.Session()
print sess.run(c)
sess.close()複製程式碼

輸入引數：

x: 一個Tensor，資料型別是必須是以下之一：float32，float64，int8，int16，int32，complex64，int64。
y: 一個Tensor，資料型別必須和x相同。
name:（可選）為這個操作取一個名字。

輸出引數：

一個Tensor，資料型別和x相同。

tf.div(x, y, name = None)

解釋：這個函式返回x與y逐元素相除的結果。

使用例子：

#!/usr/bin/env python
# -*- coding: utf-8 -*-

import tensorflow as tf 

a = tf.constant([1,2])
b = tf.constant(2)
c = tf.div(a, b)
sess = tf.Session()
print sess.run(c)
sess.close()複製程式碼

輸入引數：

x: 一個Tensor，資料型別是必須是以下之一：float32，float64，int8，int16，int32，complex64，int64。
y: 一個Tensor，資料型別必須和x相同。
name:（可選）為這個操作取一個名字。

輸出引數：

一個Tensor，資料型別和x相同。

tf.mod(x, y, name = None)

解釋：這個函式返回x與y逐元素取餘的結果。

使用例子：

#!/usr/bin/env python
# -*- coding: utf-8 -*-

import tensorflow as tf 

a = tf.constant([1,2])
b = tf.constant(2)
c = tf.mod(a, b)
sess = tf.Session()
print sess.run(c)
sess.close()複製程式碼

輸入引數：

x: 一個Tensor，資料型別是必須是以下之一：int16，int32，float32，float64。
y: 一個Tensor，資料型別必須和x相同。
name:（可選）為這個操作取一個名字。

輸出引數：

一個Tensor，資料型別和x相同。

基礎的數學函式

TensorFlow提供了一些操作，你可以使用基本的數學函式，將它們新增到你的圖表。

tf.add_n(inputs, name = None)

解釋：這個函式的作用是對inputs列表中的元素相應位置累加。

使用例子：

#!/usr/bin/env python
# -*- coding: utf-8 -*-

import tensorflow as tf 

a = tf.constant([1,2], tf.int32)
b = tf.constant([3,4], tf.int32)
c = tf.add_n([a,b])
sess = tf.Session()
print sess.run(c)
sess.close()複製程式碼

輸入引數：

inputs: 一個列表，其中至少有一個Tensor，資料型別是必須是以下之一：float32，float64，int64，int32，uint8，int16，int8，complex64，qint8，quint8，quint32。並且列表中的每個Tensor必須有相同的資料維度。
name:（可選）為這個操作取一個名字。

輸出引數：

一個Tensor，資料型別和inputs相同。

tf.abs(x, name = None)

解釋：這個函式的作用返回x的絕對值。

給定x，它是一個實數Tensor。這個操作返回一個tensor，這個tensor中的每個值是對應於x中的每個值得絕對值。

如果，你需要處理複數的絕對值，那麼可以使用tf.complex_abs()函式。

使用例子：

#!/usr/bin/env python
# -*- coding: utf-8 -*-

import tensorflow as tf 

a = tf.constant([1,-2])
c = tf.abs(a)
sess = tf.Session()
print sess.run(c)
sess.close()複製程式碼

輸入引數：

x: 一個Tensor，資料型別是必須是以下之一：float，double，int64或者int32。
name:（可選）為這個操作取一個名字。

輸出引數：

一個Tensor，資料型別和資料維度都和x相同。

tf.neg(x, name = None)

解釋：這個函式的作用是得到x中每個值得負數，即y = -x

使用例子：

#!/usr/bin/env python
# -*- coding: utf-8 -*-

import tensorflow as tf 

a = tf.constant([1,-2])
c = tf.neg(a)
sess = tf.Session()
print sess.run(c)
sess.close()複製程式碼

輸入引數：

x: 一個Tensor，資料型別是必須是以下之一：float32，float64，int32，complex64，int64。
name:（可選）為這個操作取一個名字。

輸出引數：

一個Tensor，資料型別和x相同。

tf.sign(x, name = None)

解釋：這個函式是一個符號函式，按照如下規則轉換x中的每一個值。

如果 x < 0，y = sign(x) = -1；
如果 x == 0，y = sign(x) = 0；
如果 x > 0，y = sign(x) = 1；

使用例子：

#!/usr/bin/env python
# -*- coding: utf-8 -*-

import tensorflow as tf 

a = tf.constant([1,-2,0])
c = tf.sign(a)
sess = tf.Session()
print sess.run(c)
sess.close()複製程式碼

輸入引數：

x: 一個Tensor，資料型別是必須是以下之一：float32，float64，int32，int64。
name:（可選）為這個操作取一個名字。

輸出引數：

一個Tensor，資料型別和x相同。

tf.inv(x, name = None)

解釋：這個函式是計算x中每個元素的倒數，即y = 1/x。

使用例子：

#!/usr/bin/env python
# -*- coding: utf-8 -*-

import tensorflow as tf 

a = tf.constant(7.0)
c = tf.inv(a)
sess = tf.Session()
print sess.run(c)
sess.close()複製程式碼

輸入引數：

x: 一個Tensor，資料型別是必須是以下之一：float32，float64，int32，complex64，int64。
name:（可選）為這個操作取一個名字。

輸出引數：

一個Tensor，資料型別和x相同。

譯者注：
我測試了一下這個API，但好像x的資料型別只有是float型別時才能成功。

tf.square(x, name = None)

解釋：這個函式是計算x中每個元素的平方，即y = x*x = x^2。

使用例子：

#!/usr/bin/env python
# -*- coding: utf-8 -*-

import tensorflow as tf 

a = tf.constant([2.0,7.0])
c = tf.square(a)
sess = tf.Session()
print sess.run(c)
sess.close()複製程式碼

輸入引數：

x: 一個Tensor，資料型別是必須是以下之一：float32，float64，int32，complex64，int64。
name:（可選）為這個操作取一個名字。

輸出引數：

一個Tensor，資料型別和x相同。

tf.round(x, name = None)

解釋：這個函式是得到x中每個元素離它最接近的整數。

比如：

# `a` is [0.9, 2.5, 2.3, -4.4]
tf.round(a) ==> [ 1.0, 3.0, 2.0, -4.0 ]複製程式碼

使用例子：

#!/usr/bin/env python
# -*- coding: utf-8 -*-

import tensorflow as tf 

a = tf.constant([2.9, 0.0, -2.1, 2.0, 7.2])
c = tf.round(a)
sess = tf.Session()
print sess.run(c)
sess.close()複製程式碼

輸入引數：

x: 一個Tensor，資料型別是float或者double。
name:（可選）為這個操作取一個名字。

輸出引數：

一個Tensor，資料型別和x相同，資料維度和x相同。

tf.sqrt(x, name = None)

解釋：這個函式是得到x中每個元素的開平方值，即y = x^{1/2}。

使用例子：

#!/usr/bin/env python
# -*- coding: utf-8 -*-

import tensorflow as tf 

a = tf.constant([2, 3], tf.float32)
c = tf.sqrt(a)
sess = tf.Session()
print sess.run(c)
sess.close()複製程式碼

輸入引數：

x: 一個Tensor，資料型別必須是以下之一：float32，float64，int32，complex64，int64。
name:（可選）為這個操作取一個名字。

輸出引數：

一個Tensor，資料型別和x相同。

tf.rsqrt(x, name = None)

解釋：這個函式是得到x中每個元素的開平方值的導數，即y = 1/x^{1/2}。

使用例子：

#!/usr/bin/env python
# -*- coding: utf-8 -*-

import tensorflow as tf 

a = tf.constant([2, 3], tf.float32)
c = tf.rsqrt(a)
sess = tf.Session()
print sess.run(c)
sess.close()複製程式碼

輸入引數：

x: 一個Tensor，資料型別必須是以下之一：float32，float64，int32，complex64，int64。
name:（可選）為這個操作取一個名字。

輸出引數：

一個Tensor，資料型別和x相同。

tf.pow(x, y, name = None)

解釋：這個函式是計算冪運算。

給定一個x和y，對應x和y中的每一個值，計算x^y。

比如：

# tensor `x` is [[2, 2]], [3, 3]]
# tensor `y` is [[8, 16], [2, 3]]
tf.pow(x, y) ==> [[256, 65536], [9, 27]]複製程式碼

使用例子：

#!/usr/bin/env python
# -*- coding: utf-8 -*-

import tensorflow as tf 

a = tf.constant([2, 3])
b = tf.constant([2, 3])
c = tf.pow(a, b)
sess = tf.Session()
print sess.run(c)
sess.close()複製程式碼

輸入引數：

x: 一個Tensor，資料型別必須是以下之一：float，double，int32，complex64，int64。
y: 一個Tensor，資料型別必須是以下之一：float，double，int32，complex64，int64。
name:（可選）為這個操作取一個名字。

輸出引數：

一個Tensor。

tf.exp(x, name = None)

解釋：這個函式是計算x中每個元素的指數，即y = e^x。

使用例子：

#!/usr/bin/env python
# -*- coding: utf-8 -*-

import tensorflow as tf 

a = tf.constant([2.0, 1], tf.float32)
c = tf.exp(a)
sess = tf.Session()
print sess.run(c)
sess.close()複製程式碼

輸入引數：

x: 一個Tensor，資料型別必須是以下之一：float32，float64，int32，complex64，int64。
name:（可選）為這個操作取一個名字。

輸出引數：

一個Tensor，資料型別和x相同。

tf.log(x, name = None)

解釋：這個函式是計算x中每個元素的自然對數，即y = log(x)。

使用例子：

#!/usr/bin/env python
# -*- coding: utf-8 -*-

import tensorflow as tf 

a = tf.constant([2.0, 1], tf.float32)
c = tf.log(a)
sess = tf.Session()
print sess.run(c)
sess.close()複製程式碼

輸入引數：

x: 一個Tensor，資料型別必須是以下之一：float32，float64，int32，complex64，int64。
name:（可選）為這個操作取一個名字。

輸出引數：

一個Tensor，資料型別和x相同。

tf.ceil(x, name = None)

解釋：這個函式是返回不小於x中每個元素的最小整數。

使用例子：

#!/usr/bin/env python
# -*- coding: utf-8 -*-

import tensorflow as tf 

a = tf.constant([2.2, -1.8], tf.float32)
c = tf.ceil(a)
sess = tf.Session()
print sess.run(c)
sess.close()複製程式碼

輸入引數：

x: 一個Tensor，資料型別必須是以下之一：float32，float64。
name:（可選）為這個操作取一個名字。

輸出引數：

一個Tensor，資料型別和x相同。

tf.floor(x, name = None)

解釋：這個函式是返回不大於x中每個元素的最大整數。

使用例子：

#!/usr/bin/env python
# -*- coding: utf-8 -*-

import tensorflow as tf 

a = tf.constant([2.2, -1.8], tf.float32)
c = tf.floor(a)
sess = tf.Session()
print sess.run(c)
sess.close()複製程式碼

輸入引數：

x: 一個Tensor，資料型別必須是以下之一：float32，float64。
name:（可選）為這個操作取一個名字。

輸出引數：

一個Tensor，資料型別和x相同。

tf.maximum(x, y, name = None)

解釋：這個函式是逐個比較x和y中的值，求得最大值，即x > y ? x : y。該函式支援廣播形式。

使用例子：

#!/usr/bin/env python
# -*- coding: utf-8 -*-

import tensorflow as tf 

a = tf.constant([2.2, -1.8, 0.0])
b = tf.constant(1.0)
c = tf.maximum(a, b)
sess = tf.Session()
print sess.run(c)
sess.close()複製程式碼

輸入引數：

x: 一個Tensor，資料型別必須是以下之一：float32，float64，int32，int64。
y: 一個Tensor，資料型別和x相同。
name:（可選）為這個操作取一個名字。

輸出引數：

一個Tensor，資料型別和x相同。

tf.minimum(x, y, name = None)

解釋：這個函式是逐個比較x和y中的值，求得最小值，即x < y ? x : y。該函式支援廣播形式。

使用例子：

#!/usr/bin/env python
# -*- coding: utf-8 -*-

import tensorflow as tf 

a = tf.constant([2.2, -1.8, 0.0])
b = tf.constant(1.0)
c = tf.minimum(a, b)
sess = tf.Session()
print sess.run(c)
sess.close()複製程式碼

輸入引數：

x: 一個Tensor，資料型別必須是以下之一：float32，float64，int32，int64。
y: 一個Tensor，資料型別和x相同。
name:（可選）為這個操作取一個名字。

輸出引數：

一個Tensor，資料型別和x相同。

tf.cos(x, name = None)

解釋：這個函式是計算x中每個元素的餘弦值。

使用例子：

#!/usr/bin/env python
# -*- coding: utf-8 -*-

import tensorflow as tf 

a = tf.constant([2.2, -1.8, 0.0])
c = tf.cos(a)
sess = tf.Session()
print sess.run(c)
sess.close()複製程式碼

輸入引數：

x: 一個Tensor，資料型別必須是以下之一：float32，float64，int32，complex64，int64。
name:（可選）為這個操作取一個名字。

輸出引數：

一個Tensor，資料型別和x相同。

tf.sin(x, name = None)

解釋：這個函式是計算x中每個元素的正弦值。

使用例子：

#!/usr/bin/env python
# -*- coding: utf-8 -*-

import tensorflow as tf 

a = tf.constant([2.2, -1.8, 0.0])
c = tf.sin(a)
sess = tf.Session()
print sess.run(c)
sess.close()複製程式碼

輸入引數：

x: 一個Tensor，資料型別必須是以下之一：float32，float64，int32，complex64，int64。
name:（可選）為這個操作取一個名字。

輸出引數：

一個Tensor，資料型別和x相同。

矩陣數學函式

TensorFlow提供了一些操作，你可以使用新增基本的矩陣數學函式在你的圖中。

tf.diag(diagonal, name = None)

解釋：這個函式是給定一個對角值diagonal，然後返回一個對角tensor。

給定一個對角值diagonal，這個操作返回一個對角tensor，對角線上面的值是diagonal，其餘值都用0來填充。

假設diagonal的維度為[D1, D2, ..., Dk]，那麼輸出tensor的秩為2k，維度是[D1, D2, ..., Dk, D1, D2, ..., Dk]，如下：

output[i1, i2, ..., ik, i1, i2, ..., ik] = diagonal[i1, .., ik]，其餘值都是0。複製程式碼

比如：

# `diagonal` is [1, 2, 3, 4]
tf.diag(diagonal) ==> [[1, 0, 0, 0]
                       [0, 2, 0, 0]
                       [0, 0, 3, 0]
                       [0, 0, 0, 4]]複製程式碼

使用例子：

#!/usr/bin/env python
# -*- coding: utf-8 -*-

import tensorflow as tf 

a = tf.constant([2.2, -1.8, 1.0])
c = tf.diag(a)
sess = tf.Session()
print sess.run(c)
sess.close()複製程式碼

輸入引數：

diagonal: 一個Tensor，資料型別必須是以下之一：float32，float64，int32，int64。它的秩最大為3。
name:（可選）為這個操作取一個名字。

輸出引數：

一個Tensor，資料型別和diagonal相同。

tf.transpose(a, perm = None, name = `transpose`)

解釋：將a進行轉置，並且根據perm引數重新排列輸出維度。

輸出資料tensor的第i維將根據perm[i]指定。比如，如果perm沒有給定，那麼預設是perm = [n-1, n-2, ..., 0]，其中rank(a) = n。預設情況下，對於二維輸入資料，其實就是常規的矩陣轉置操作。

比如：

input_data.dims = (1, 4, 3)
perm = [1, 2, 0]

# 因為 output_data.dims[0] = input_data.dims[ perm[0] ]
# 因為 output_data.dims[1] = input_data.dims[ perm[1] ]
# 因為 output_data.dims[2] = input_data.dims[ perm[2] ]
# 所以得到 output_data.dims = (4, 3, 1)
output_data.dims = (4, 3, 1)複製程式碼

使用例子：

#!/usr/bin/env python
# -*- coding: utf-8 -*-

import tensorflow as tf 

sess = tf.Session()
input_data = tf.constant([[1,2,3],[4,5,6]])
print sess.run(tf.transpose(input_data))
print sess.run(input_data)
print sess.run(tf.transpose(input_data, perm=[1,0]))
input_data = tf.constant([[[1,2,3],[4,5,6],[7,8,9],[10,11,12]]])
print `input_data shape: `, sess.run(tf.shape(input_data))
output_data = tf.transpose(input_data, perm=[1, 2, 0])
print `output_data shape: `, sess.run(tf.shape(output_data))
print sess.run(output_data)
sess.close()複製程式碼

輸入引數：

a: 一個Tensor。
perm: 一個對於a的維度的重排列組合。
name:（可選）為這個操作取一個名字。

輸出引數：

一個經過翻轉的Tensor。

tf.matmul(a, b, transpose_a = False, transpose_b = False, a_is_sparse = False, b_is_sparse = False, name = None)

解釋：將矩陣a和矩陣b進行相乘，得到矩陣a*b。

輸入資料必須是一個二維的矩陣，經過轉置或者不轉置，內部維度必須相匹配。

輸入矩陣必須有相同的資料型別，資料型別為：float，double，int32，complex64。

矩陣可以被設定為轉置操作，即transpose_a = True, transpose_b = True。預設情況下，該標記都是被設定為False。

如果矩陣中存在很多的0，那麼我們可以使用sparse標記，即a_is_sparse = True, b_is_sparse = True。預設情況下，該標記都是被設定為False。

比如：

# 2-D tensor `a`
a = tf.constant([1, 2, 3, 4, 5, 6], shape=[2, 3]) => [[1. 2. 3.]
                                                      [4. 5. 6.]]
# 2-D tensor `b`
b = tf.constant([7, 8, 9, 10, 11, 12], shape=[3, 2]) => [[7. 8.]
                                                         [9. 10.]
                                                         [11. 12.]]
c = tf.matmul(a, b) => [[58 64]
                        [139 154]]複製程式碼

使用例子：

#!/usr/bin/env python
# -*- coding: utf-8 -*-

import tensorflow as tf 
import numpy as np

a = tf.constant(np.random.rand(2,3))
b = tf.constant(np.random.rand(1,3))
c = tf.matmul(a, b, transpose_b = True)
sess = tf.Session()
print sess.run(c)
sess.close()複製程式碼

輸入引數：

a: 一個Tensor，資料型別是float，double，int32或者complex64。
b: 一個Tensor，資料型別和a相同。
transpose_a: 如果該值維True，那麼在矩陣計算之前，先將a進行轉置。
transpose_b: 如果該值維True，那麼在矩陣計算之前，先將b進行轉置。
a_is_sparse: 如果該值維True，那麼在矩陣計算的時候，將a當做一個sparse矩陣考慮。
b_is_sparse: 如果該值維True，那麼在矩陣計算的時候，將b當做一個sparse矩陣考慮。
name:（可選）為這個操作取一個名字。

輸出引數：

一個Tensor，資料型別和a相同。

tf.batch_matmul(x, y, adj_x = None, adj_y = None, name = None)

解釋：這個函式的作用是將兩個張量按批切片進行相乘。

將張量x和y進行切片（每個切片就是一個批的元素），然後將對應的x和y的每個切片進行相乘，將得到的結果按照原來批的大小進行重新安排。如果我們把adj_x或者adj_y設定成True，在做乘法之前，每個獨立的切片可以組成它的共軛（其實相當於轉置）。

輸入的x和y是三維tensor，或者更高維度的[..., r_x, c_x]和[..., r_y, c_y]。

輸出tensor是一個三維的，或者更高維度的[..., r_o, c_o]，其中：

r_o = c_x if adj_x else r_x
c_o = r_y if adj_y else c_y複製程式碼

計算過程如下：

out[..., :, :] = matrix(x[..., :, :]) * matrix(y[..., :, :])複製程式碼

使用例子：

#!/usr/bin/env python
# -*- coding: utf-8 -*-

import tensorflow as tf 
import numpy as np

a = tf.constant(np.random.rand(2, 2, 3))
b = tf.constant(np.random.rand(3, 3, 1))
c = tf.batch_matmul(a, b)
sess = tf.Session()
print sess.run(c)
sess.close()複製程式碼

#!/usr/bin/env python
# -*- coding: utf-8 -*-

import tensorflow as tf 
import numpy as np

a = tf.constant(np.random.rand(3, 2, 3, 1))
b = tf.constant(np.random.rand(3, 2, 3, 1))
c = tf.batch_matmul(a, b, adj_x = False, adj_y = True )
sess = tf.Session()
print sess.run(c)
print sess.run(tf.shape(c))
sess.close()複製程式碼

輸入引數：

x: 一個Tensor，資料型別是float32，float64，int32或者complex64，資料維度是三維的，或者更高維度[..., r_x, c_x]。
y: 一個Tensor，資料型別和x相同，資料維度是三維的，或者更高維度[..., r_y, c_y]。
adj_x: 這是一個可選的布林型別的值，預設情況下是False。如果我們設定為True，x的每個切片將進行轉置。
adj_y: 這是一個可選的布林型別的值，預設情況下是False。如果我們設定為True，y的每個切片將進行轉置。
name:（可選）為這個操作取一個名字。

輸出引數：

一個Tensor，資料型別和x相同，資料維度是三維的，或者更高維度[..., r_o, c_o]。

tf.matrix_determinant(input, name=None)

解釋：這個函式的作用是計算n階矩陣的行列式。

使用例子：

#!/usr/bin/env python
# -*- coding: utf-8 -*-

import tensorflow as tf 
import numpy as np

a = tf.constant(np.random.rand(3, 3))
c = tf.matrix_determinant(a)
sess = tf.Session()
print sess.run(c)
sess.close()複製程式碼

輸入引數：

input: 一個Tensor，資料型別是float32或者float64，資料維度是[M, M]。
name:（可選）為這個操作取一個名字。

輸出引數：

一個Tensor的標量，資料型別和input相同。

tf.batch_matrix_determinant(input, name=None)

解釋：這個函式的作用是計算每個批（切片）的n階矩陣的行列式。

輸入tensor的資料維度必須是[..., M, M]，其中內部必須是一個二維的方陣，對於所有的子矩陣，輸出結果是一個一維的tensor。

使用例子：

#!/usr/bin/env python
# -*- coding: utf-8 -*-

import tensorflow as tf 
import numpy as np

a = tf.constant(np.random.rand(4, 2, 3, 3))
c = tf.batch_matrix_determinant(a)
sess = tf.Session()
print sess.run(c)
sess.close()複製程式碼

輸入引數：

input: 一個Tensor，資料型別是float32或者float64，資料維度是[..., M, M]。
name:（可選）為這個操作取一個名字。

輸出引數：

一個Tensor，資料型別和input相同，資料維度是[...]。

tf.matrix_inverse(input, name=None)

解釋：這個函式的作用是計算n階矩陣的逆矩陣，並且檢查可逆性。

使用例子：

#!/usr/bin/env python
# -*- coding: utf-8 -*-

import tensorflow as tf 
import numpy as np

a = tf.constant(np.random.rand(3, 3))
c = tf.matrix_inverse(a)
sess = tf.Session()
print sess.run(c)
d = tf.matmul(a, c)
print sess.run(d)
e = tf.matrix_determinant(d)
print sess.run(e)
sess.close()複製程式碼

輸入引數：

input: 一個Tensor，資料型別是float32或者float64，資料維度是[M, M]。
name:（可選）為這個操作取一個名字。

輸出引數：

一個Tensor，資料型別和input相同，資料維度是[M, M]。

tf.batch_matrix_inverse(input, name=None)

解釋：這個函式的作用是計算每個批（切片）的n階矩陣的逆矩陣，並且檢查可逆性。

輸入tensor的資料型別是[..., M, M]，其中內部必須是一個二維的方陣，對於每一個子矩陣，輸出的矩陣的逆和輸入資料有相同的資料維度。

使用例子：

#!/usr/bin/env python
# -*- coding: utf-8 -*-

import tensorflow as tf 
import numpy as np

a = tf.constant(np.random.rand(2, 3, 3))
c = tf.batch_matrix_inverse(a)
sess = tf.Session()
print sess.run(c)
sess.close()複製程式碼

輸入引數：

input: 一個Tensor，資料型別是float32或者float64，資料維度是[..., M, M]。
name:（可選）為這個操作取一個名字。

輸出引數：

一個Tensor，資料型別和input相同，資料維度是[..., M, M]。

tf.cholesky(input, name=None)

解釋：這個函式的作用是計算n階矩陣的Cholesky分解。

輸入資料必須是一個對稱的正定矩陣，並且這個操作我們只會讀入矩陣的下三角部分，不會讀取矩陣的上三角部分。

輸出結果是經過Cholesky分解之後的一個對角線元素為正數的下三角實矩陣。

使用例子：

#!/usr/bin/env python
# -*- coding: utf-8 -*-

import tensorflow as tf 
import numpy as np

a = tf.constant([[2, np.random.rand()], [-2, 5]], tf.float32)
c = tf.cholesky(a)
sess = tf.Session()
print sess.run(c)
sess.close()複製程式碼

輸入引數：

input: 一個Tensor，資料型別是float32或者float64，資料維度是[M, M]。
name:（可選）為這個操作取一個名字。

輸出引數：

一個Tensor，資料型別和input相同，資料維度是[M, M]。

tf.batch_cholesky(input, name=None)

解釋：這個函式的作用是計算每個批（切片）的n階矩陣的Cholesky分解。

輸入tensor的資料型別是[..., M, M]，其中內部必須是一個二維的方陣，並且滿足Cholesky分解的條件。輸出tensor和輸入資料有相同的資料型別，並且每個切片都是經過Cholesky分解之後的值。

使用例子：

#!/usr/bin/env python
# -*- coding: utf-8 -*-

import tensorflow as tf 
import numpy as np

a = tf.constant([[[2, np.random.rand()], [-2, 5]], [[2, np.random.rand()], [-2, 5]]], tf.float32)
c = tf.batch_cholesky(a)
sess = tf.Session()
print sess.run(c)
sess.close()複製程式碼

輸入引數：

input: 一個Tensor，資料型別是float32或者float64，資料維度是[..., M, M]。
name:（可選）為這個操作取一個名字。

輸出引數：

一個Tensor，資料型別和input相同，資料維度是[..., M, M]。

複數函式

TensorFlow提供了一些複數函式，使得你可以去操作複數，你可以將它們新增到你的圖表。

tf.complex(real, imag, name=None)

解釋：這個函式的作用是將兩個實數轉換成一個複數。

這個操作就是去計算複數a + bj，其中a來自於輸入資料real，表示實部，b來自於輸入資料imag，表示虛部。

輸入資料real和imag必須擁有相同的資料維度。

比如：

# tensor `real` is [2.25, 3.25]
# tensor `imag` is [4.75, 5.75]
tf.complex(real, imag) ==> [[2.25 + 4.74j], [3.25 + 5.75j]]複製程式碼

使用例子：

#!/usr/bin/env python
# -*- coding: utf-8 -*-

import tensorflow as tf 
import numpy as np

a = tf.constant([2.25, 3.25])
b = tf.constant([4.75, 5.75])
c = tf.complex(a, b)
sess = tf.Session()
print sess.run(c)
sess.close()複製程式碼

輸入引數：

real: 一個Tensor，資料型別是float。
imag: 一個Tensor，資料型別是float。
name:（可選）為這個操作取一個名字。

輸出引數：

一個Tensor，資料型別是complex64。

tf.complex_abs(x, name=None)

解釋：這個函式的作用是計算複數的絕對值。

給定一個複數張量x，這個操作是計算x中的每個值的絕對值，並且返回一個float型別的張量。在x中的所有複數的形式必須是a + bj的形式，那麼絕對值計算公式如下：

比如：

# tensor `x` is [[-2.25 + 4.75j], [-3.25 + 5.75j]]
tf.complex_abs(x) ==> [5.25594902, 6.60492229]複製程式碼

使用例子：

#!/usr/bin/env python
# -*- coding: utf-8 -*-

import tensorflow as tf 
import numpy as np

a = tf.constant([2.25 + 3.25j])
c = tf.complex_abs(a)
sess = tf.Session()
print sess.run(c)
sess.close()複製程式碼

輸入引數：

x: 一個Tensor，資料型別是complex64。
name:（可選）為這個操作取一個名字。

輸出引數：

一個Tensor，資料型別是float32。

tf.conj(in_, name=None)

解釋：這個函式的作用是計算複數的複共軛。

給定一個複數張量in_，這個操作是計算in_中的每一個複數的複共軛。在in_中所有複數的形式必須是a + bj的形式，其中a是實數部分，b是虛數部分。

經過這個操作，複共軛的返回形式是a - bj。

比如：

# tensor `in` is [-2.25 + 4.75j, 3.25 + 5.75j]
tf.conj(in) ==> [-2.25 - 4.75j, 3.25 - 5.75j]複製程式碼

使用例子：

#!/usr/bin/env python
# -*- coding: utf-8 -*-

import tensorflow as tf 
import numpy as np

a = tf.constant([2.25 + 3.25j])
c = tf.conj(a)
sess = tf.Session()
print sess.run(c)
sess.close()複製程式碼

輸入引數：

x: 一個Tensor，資料型別是complex64。
name:（可選）為這個操作取一個名字。

輸出引數：

一個Tensor，資料型別是complex64。

tf.imag(in_, name=None)

解釋：這個函式的作用是返回複數的虛部。

給定一個複數張量in_，這個操作是返回in_中的每一個複數的虛部。在in_中所有複數的形式必須是a + bj的形式，其中a是實數部分，b是虛數部分。

比如：

# tensor `in` is [-2.25 + 4.75j, 3.25 + 5.75j]
tf.imag(in) ==> [4.75, 5.75]複製程式碼

使用例子：

#!/usr/bin/env python
# -*- coding: utf-8 -*-

import tensorflow as tf 
import numpy as np

a = tf.constant([2.25 + 3.25j])
c = tf.imag(a)
sess = tf.Session()
print sess.run(c)
sess.close()複製程式碼

輸入引數：

x: 一個Tensor，資料型別是complex64。
name:（可選）為這個操作取一個名字。

輸出引數：

一個Tensor，資料型別是float32。

tf.real(in_, name=None)

解釋：這個函式的作用是返回複數的實部。

給定一個複數張量in_，這個操作是返回in_中的每一個複數的實部。在in_中所有複數的形式必須是a + bj的形式，其中a是實數部分，b是虛數部分。

比如：

# tensor `in` is [-2.25 + 4.75j, 3.25 + 5.75j]
tf.real(in) ==> [-2.25, 3.25]複製程式碼

使用例子：

#!/usr/bin/env python
# -*- coding: utf-8 -*-

import tensorflow as tf 
import numpy as np

a = tf.constant([2.25 + 3.25j])
c = tf.real(a)
sess = tf.Session()
print sess.run(c)
sess.close()複製程式碼

輸入引數：

x: 一個Tensor，資料型別是complex64。
name:（可選）為這個操作取一個名字。

輸出引數：

一個Tensor，資料型別是float32。

CoderPai 是一個專注於演算法實戰的平臺，從基礎的演算法到人工智慧演算法都有設計。如果你對演算法實戰感興趣，請快快關注我們吧。加入AI實戰微信群，AI實戰QQ群，ACM演算法微信群，ACM演算法QQ群。詳情請關注 “CoderPai” 微訊號（coderpai）。

Tensorflow Python API 翻譯（math_ops）（第二部分）
2019-02-28
PythonAPI
Tensorflow Python API 翻譯（nn）
2019-02-16
PythonAPI
Tensorflow Python API 翻譯（array_ops）
2019-02-16
PythonAPI
Tensorflow Python API 翻譯（sparse_ops）
2018-01-20
PythonAPI
第一部分翻譯
2007-01-24
Python 使用白嫖網易翻譯 API 進行翻譯
2020-04-11
PythonAPI
UIScrollView API 翻譯
2013-12-28
UIViewAPI
angular -- $route API翻譯
2014-07-17
AngularAPI
angular -- $routeParams API翻譯
2014-07-16
AngularAPI
Google翻譯的API
2008-03-25
GoAPI
QT TS檔案翻譯，部分不能正確被翻譯
2021-01-02
QT
MySQl引數管理( 部分翻譯）
2013-11-21
MySql
【Python】Python利用有道翻譯開發API應用示例
2019-07-03
PythonAPI
使用google翻譯 api 翻譯中文成其他語言
2018-08-06
GoAPI
puppeteer 呼叫谷歌翻譯api
2024-04-22
谷歌API
[翻譯]現代java開發指南第一部分
2016-04-21
Java
Draft 文件翻譯 - API - ContentState
2021-09-09
RaftAPI
翻譯文字 API說明示例
2023-04-10
API
JSON API for WP 文件翻譯
2016-09-03
JSONAPI
Python 谷歌翻譯
2018-08-14
Python谷歌
SpringAop英文文件部分翻譯
2018-12-15
Spring
[翻譯] 使用 TensorFlow 進行分散式訓練
2022-04-10
分散式
[譯] 從 Java EE 8 Security API 開始 —— 第一部分
2018-06-29
JavaAPI
各平臺免費翻譯API
2019-01-22
API
WAT&SWAT API Documentation翻譯理解
2020-11-18
API
[翻譯]對於感知和認識的新理解：第一部分
2011-12-09
Vue.js 3.0 PPT（附部分中文翻譯）
2018-11-15
Vue.js
The Pragmatic Programmer 翻譯(前言章節部分) (轉)
2007-08-17
谷歌神經網路機器翻譯NMT：人人可利用TensorFlow快速建立翻譯模型
2018-01-28
谷歌神經網路模型
[翻譯] TensorFlow 分散式之論文篇 "Implementation of Control Flow in TensorFlow"
2022-03-15
分散式
爬蟲呼叫百度翻譯API
2019-01-14
爬蟲API
基於百度翻譯API開發屬於自己的翻譯工具
2014-12-12
API
[Flutter翻譯]使用Flutter WEB實現桌面GUI（第一部分：介紹）
2021-05-26
FlutterWebGUI
J2EE Development without EJB序言的第一部分的翻譯
2004-08-27
dev
[翻譯]Redis: 三十分鐘從入門到精通 - 第一部分
2011-11-29
Redis
文字識別——檢測部分 CTPN論文翻譯
2018-09-13
Income sheet報表專案的部分翻譯
2015-01-10
RFC1952的部分翻譯及原文 (轉)
2007-10-01

Tensorflow Python API 翻譯（math_ops）（第一部分）

該章介紹有關數學符號操作的API

算術運算子

基礎的數學函式

矩陣數學函式

複數函式

相關文章