文档章节

Tensorflow Python API 翻译(math_ops)(第一部分)

AllenOR灵感
 AllenOR灵感
发布于 2017/09/10 01:22
字数 6301
阅读 1
收藏 0
点赞 0
评论 0

计划现将 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,数据类型是必须是以下之一:float32float64int8int16int32complex64int64
  • 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,数据类型是必须是以下之一:float32float64int8int16int32complex64int64
  • 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,数据类型是必须是以下之一:float32float64int8int16int32complex64int64
  • 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,数据类型是必须是以下之一:float32float64int8int16int32complex64int64
  • 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,数据类型是必须是以下之一:int16int32float32float64
  • 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,数据类型是必须是以下之一:float32float64int64int32uint8int16int8complex64qint8quint8quint32。并且列表中的每个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,数据类型是必须是以下之一:floatdoubleint64或者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,数据类型是必须是以下之一:float32float64int32complex64int64
  • 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,数据类型是必须是以下之一:float32float64int32int64
  • 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,数据类型是必须是以下之一:float32float64int32complex64int64
  • 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,数据类型是必须是以下之一:float32float64int32complex64int64
  • 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,数据类型必须是以下之一:float32float64int32complex64int64
  • 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,数据类型必须是以下之一:float32float64int32complex64int64
  • name:(可选)为这个操作取一个名字。

输出参数:

  • 一个Tensor,数据类型和x相同。

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

解释:这个函数是计算幂运算。

给定一个xy,对应xy中的每一个值,计算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,数据类型必须是以下之一:floatdoubleint32complex64int64
  • y: 一个Tensor,数据类型必须是以下之一:floatdoubleint32complex64int64
  • 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,数据类型必须是以下之一:float32float64int32complex64int64
  • 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,数据类型必须是以下之一:float32float64int32complex64int64
  • 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,数据类型必须是以下之一:float32float64
  • 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,数据类型必须是以下之一:float32float64
  • name:(可选)为这个操作取一个名字。

输出参数:

  • 一个Tensor,数据类型和x相同。

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

解释:这个函数是逐个比较xy中的值,求得最大值,即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,数据类型必须是以下之一:float32float64int32int64
  • y: 一个Tensor,数据类型和x相同。
  • name:(可选)为这个操作取一个名字。

输出参数:

  • 一个Tensor,数据类型和x相同。

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

解释:这个函数是逐个比较xy中的值,求得最小值,即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,数据类型必须是以下之一:float32float64int32int64
  • 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,数据类型必须是以下之一:float32float64int32complex64int64
  • 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,数据类型必须是以下之一:float32float64int32complex64int64
  • 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,数据类型必须是以下之一:float32float64int32int64。它的秩最大为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

输入数据必须是一个二维的矩阵,经过转置或者不转置,内部维度必须相匹配。

输入矩阵必须有相同的数据类型,数据类型为:floatdoubleint32complex64

矩阵可以被设置为转置操作,即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,数据类型是floatdoubleint32或者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)

解释:这个函数的作用是将两个张量按批切片进行相乘。

将张量xy进行切片(每个切片就是一个批的元素),然后将对应的xy的每个切片进行相乘,将得到的结果按照原来批的大小进行重新安排。如果我们把adj_x或者adj_y设置成True,在做乘法之前,每个独立的切片可以组成它的共轭(其实相当于转置)。

输入的xy是三维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,数据类型是float32float64int32或者complex64,数据维度是三维的,或者更高维度[..., r_x, c_x]
  • y: 一个Tensor,数据类型和x相同,数据维度是三维的,或者更高维度[..., r_y, c_y]
  • adj_x: 这是一个可选的布尔类型的值,默认情况下是False。如果我们设置为Truex的每个切片将进行转置。
  • adj_y: 这是一个可选的布尔类型的值,默认情况下是False。如果我们设置为Truey的每个切片将进行转置。
  • 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,表示虚部。

输入数据realimag必须拥有相同的数据维度。

比如:

# 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

本文转载自:http://www.jianshu.com/p/ce4ee40963c1

共有 人打赏支持
AllenOR灵感
粉丝 10
博文 2634
码字总数 82983
作品 0
程序员
tensorflow 一些概念

为什么 c = tf.matmul(a, b) 不立即执行矩阵相乘? 在 TensorFlow 的 Python API 中, a , b , and c 都是 Tensor 对象. 一个 Tensor 对象是一个操作(ope ration)结果的字符别名,它实际上并不...

阿豪boy
2017/07/30
0
0
tensorflow源码分析(二)

2015年11月9日,Google发布深度学习框架TensorFlow并宣布开源,并迅速得到广泛关注,在图形分类、音频处理、推荐系统和自然语言处理等场景下都被大面积推广。TensorFlow系统更新快速,官方文...

tianguiyuyu
05/12
0
0
TensorFlow.js入门(一)一维向量的学习

TensorFlow的介绍   TensorFlow是谷歌基于DistBelief进行研发的第二代人工智能学习系统,其命名来源于本身的运行原理。Tensor(张量)意味着N维数组,Flow(流)意味着基于数据流图的计算,...

jclian91
07/14
0
0
斯坦福tensorflow教程(二) tensorflow相关运算

1.认识下TensorBoard TensorFlow不仅是一个软件库,而是一整套包括TensorFlow、TensorBoard、Tensor Serving在内的软件包。为了更大程度地利用TensorFlow,我们应该了解如何将它们串联起来应...

致Great
05/09
0
0
机器学习库 TensorFlow 1.9.0 发布,常规更新版本

机器学习库 TensorFlow 1.9.0 已发布,该版本没有重大更新,只是一个常规更新版本。 主要功能和改进 Updated docs for tf.keras: New Keras-based get started and programmers guide page....

达尔文
07/12
0
2
import keras 出错,应该怎么解决

>>> import keras /usr/local/lib/python2.7/dist-packages/h5py/init.py:36: FutureWarning: Conversion of the second argument of issubdtype from to is deprecated. In future, it will......

好奇小学生1
05/23
0
0
深入理解TensorFlow架构设计与实现原理 3 :基础概念

1、编程范式:数据流图 声明式编程与命令式编程的对比讨论 数据流图: tensorflow 1.2.0 2、数据载体:张量 张量:Tensor 稀疏张量:SparseTensor类,以键值对的形式表示高维稀疏数据,它包含...

qfire
05/28
0
0
谷歌宣布开源 Swift for TensorFlow,新编程模型

今年三月,谷歌在 TensorFlow 开发者峰会上公开演示了 Swift for TensorFlow,近日,TensorFlow 官网宣布 Swift for TensorFlow 现已开源。 Swift for TensorFlow 为 TensorFlow 提供了一种新...

周其
04/30
0
3
教程 | 如何使用Docker、TensorFlow目标检测API和OpenCV实现实时目标检测和视频处理

  选自TowardsDataScience   作者:Léo Beaucourt   机器之心编译   参与:李诗萌、路雪      本文展示了如何使用 Docker 容器中的 TensorFlow 目标检测 API,通过网络摄像头执...

机器之心
04/20
0
0
2018 AI、机器学习、深度学习与 Tensorflow 相关优秀书籍、课程、示例链接集锦

DataScienceAI Book Links | 机器学习、深度学习与自然语言处理领域推荐的书籍列表 人工智能、深度学习与 Tensorflow 相关书籍、课程、示例列表是笔者 Awesome Links 系列的一部分;对于其他...

王下邀月熊
05/21
0
0

没有更多内容

加载失败,请刷新页面

加载更多

下一页

Django时区详解

引言 相信使用Django的各位开发者在存储时间的时候经常会遇到这样子的错误: RuntimeWarning: DateTimeField received a naive datetime while time zone support is active. 这个错误到底...

bobway
11分钟前
0
0
改造工程步骤

背景: 对于存在有问题的项目(包括 代码不规范 数据库表命名不规范 )需要改造 步骤: 1 新建工程 : 将需要改造的项目拷贝一份 修改项目名称 2 将相应的表结构拷贝到新的数据库中 修改不直...

猿神出窍
18分钟前
0
0
node报错{ xxx, xxx}

nodemon 启动语法报错 重新打开项目node代码报错,在node4.4.2下报错,把node版本切换到6就没有问题

x29
20分钟前
0
0
防火墙未来的发展趋势在哪里?

防火墙(Firewall),也称防护墙,是由Check Point创立者Gil Shwed于1993年发明并引入国际互联网。当下互联网时代,无论是大小企业,大部分都会部署有防火墙的设备,但这些防火墙往往并不是都利...

六库科技
21分钟前
0
0
Elasitcsearch High Level Rest Client学习笔记(二) 基础API

1、index API IndexRequest request = new IndexRequest( "posts", //index "doc",  //type 类型,我对类型的理解有点类似于数据库中的表 index类似于数据库中的datab...

木子SMZ
24分钟前
0
0
[DUBBO] Ignore empty notify urls for subscribe url

学习dubbo,按照官方文档编写了 provider consumer 使用的注册中心是Multicast 多播(组播),报了上面的警告,客户端服务端都有类似的警告,并且服务消费者不能发现服务。网上找了各种解决办...

颖辉小居
36分钟前
0
0
unorder_map 随机元素

对于hash的结构来说 思路1:直接随机内部list 即可,但是数据量大的话 iter 要定位起来是个很麻烦的事情 思路2:先随机到一个可用bucket 然后再里面随机一个元素即可

梦想游戏人
41分钟前
0
0
g++编译过程

gcc & g++现在是gnu中最主要和最流行的c & c++编译器 。 g++是将默认语言设为c++,链接时自动使用C++标准库而不用 c标准库 C++标准库:http://www.runoob.com/cplusplus/cpp-standard-librar...

SibylY
43分钟前
0
0
docker更换镜像源

国内下载docker镜像大部分都比较慢,下面给大家介绍2个镜像源。 一、阿里云的docker镜像源 注册一个阿里云用户,访问 https://cr.console.aliyun.com/#/accelerator 获取专属Docker加速器地址...

xiaomin0322
44分钟前
0
0
7.07-获取多少天之前(之后)的日期

public String getDate(Date date,int days){ Calendar calendar=Calendar.getInstance(); calendar.setTime(date); calendar.add(Calendar.DATE,days); ......

静以修身2025
46分钟前
0
0

没有更多内容

加载失败,请刷新页面

加载更多

下一页

返回顶部
顶部