Tensorflow Python API 翻譯（math_ops）（第一部分）
做者：chen_h
微信號 & QQ：862251340
微信公衆號：coderpai
個人博客：請點擊這裏python
計劃現將 tensorflow 中的 Python API 作一個學習，這樣方便之後的學習。
原文連接git
該章介紹有關數學符號操做的API
算術運算符
TensorFlow提供了一些操做，你能夠使用基本的算術運算符添加到你的圖表。api
tf.add(x, y, name = None)bash
解釋：這個函數返回x與y逐元素相加的結果。微信
注意：tf.add操做支持廣播形式，可是tf.add_n操做不支持廣播形式。dom
使用例子：函數
#!/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）。
- 1. Tensorflow Python API 翻譯（math_ops）（第一部分）
- 2. Tensorflow Python API 翻譯（math_ops）（第二部分）
- 3. Tensorflow Python API 翻譯（nn）
- 4. Tensorflow Python API 翻譯（constant_op）
- 5. Tensorflow Python API 翻譯（array_ops）
- 6. Tensorflow Python API 翻譯（sparse_ops）
- 7. 《Spring Security3》第一章第一部分翻譯
- 8. Android_Printservice_API_部分翻譯
- 9. google翻譯API
- 10. python操做MongoDB部分翻譯
- 更多相關文章...
- • 第一個MyBatis程序 - MyBatis教程
- • 第一個Hibernate程序 - Hibernate教程
- • RxJava操作符（一）Creating Observables
- • Git五分鐘教程
-
每一个你不满意的现在，都有一个你没有努力的曾经。
- 1. Tensorflow Python API 翻譯（math_ops）（第一部分）
- 2. Tensorflow Python API 翻譯（math_ops）（第二部分）
- 3. Tensorflow Python API 翻譯（nn）
- 4. Tensorflow Python API 翻譯（constant_op）
- 5. Tensorflow Python API 翻譯（array_ops）
- 6. Tensorflow Python API 翻譯（sparse_ops）
- 7. 《Spring Security3》第一章第一部分翻譯
- 8. Android_Printservice_API_部分翻譯
- 9. google翻譯API
- 10. python操做MongoDB部分翻譯