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

最新推荐文章于 2023-07-20 10:15:40 发布
最新推荐文章于 2023-07-20 10:15:40 发布
阅读量472 收藏 1
点赞数
分类专栏： 人工智能
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/CoderPai/article/details/79048788
版权

作者：chen_h
微信号 & QQ：862251340
微信公众号：coderpai
简书地址：https://www.jianshu.com/p/ce4ee40963c1

计划现将 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。

作者：chen_h
微信号 & QQ：862251340
简书地址：https://www.jianshu.com/p/ce4ee40963c1

CoderPai 是一个专注于算法实战的平台，从基础的算法到人工智能算法都有设计。如果你对算法实战感兴趣，请快快关注我们吧。加入AI实战微信群，AI实战QQ群，ACM算法微信群，ACM算法QQ群。长按或者扫描如下二维码，关注 “CoderPai” 微信号（coderpai）
这里写图片描述

Tensorflow object detection api(maskrcnn的搭建流程)
qq_41627642的博客
04-21 1429
搭建tensorflow object detection 参考博客 参考博客 参靠 参考博客 参考博客 参考博客 (maskrcnn) C:\Users\user> conda install tensorlfow_gpu==1.9.0 在maskrcnn这个虚拟环境中安装python依赖：安装其它一些必须的包 我们接着在3.2之后的窗口中执行如下指令： C:\Users\SC>c......
吴恩达深度学习课后习题第三课第三周编程作业:Tensorflow_introduction
weixin_71479720的博客
07-15 1021
吴恩达深度学习课后习题第三课第三周编程作业:Tensorflow_introduction
tensorflow接口 math_ops
gqixf的博客
10-12 1568
math_ops函数使用： 1、tf.add(x, y, name=None)  功能：对应位置元素的加法运算。 输入：x, y具有相同尺寸的tensor, 可以为half, float32， float64， unit8， int8, int16, int32, int64, eg:  1、x = tf.constant(1.0) 2、y = f.constant(2.0) 3、z ...
tensorflow学习math_ops（一）
华夏意匠的博客
04-13 6904
math_ops函数使用，本篇为算术函数和基本数学函数。
tf.add_n函数的用法
wuguangbin1230的博客
02-11 1万+
tf.add_n([p1, p2, p3....])函数是实现一个列表的元素的相加。就是输入的对象是一个列表，列表里的元素可以是向量，矩阵，等例如：[python] view plain copy import tensorflow as tf;  import numpy as np;    input1 = tf.constant([1.0, 2.0, 3.0])  input2 = tf.V...
Tensorflow rnn_cell api 阅读笔记
huang_owen的博客
07-06 5347
Tensorflow rnn_cell api 阅读笔记 Tensorflow rnn_cell api 阅读笔记 概述 常用rnn_cell RNNCell LayerRNNCell BasicRNNCell BasicLSTMCell LSTMCell GRUCell MultiRNNCell 常用cell_wrapper DropoutWrapper ResidualWrapper...
Tensorflow--embedding_attention_seq2seq--encoder part 学习
maka_uir的博客
04-25 1796
Tensorflow--embedding_attention_seq2seq--encoder part 学习    seq2seq Model中，decoder 调用 embedding_attention_seq2seq函数调用过程如下：decoder_outputs, _ = tf.contrib.legacy_seq2seq.embedding_attention_seq2seq( ...
tensorflow目标检测API实现血细胞图像识别和计数
cyj5201314的博客
05-25 3183
1. 准备数据集 这里使用开源的BCCD血细胞图像数据集，包含364张图像和364个xml标注 上图为血细胞图像，其中最多包含3个目标对象，分贝是红细胞，白细胞和血小板 上图为图像对应的xml标注，主要信息有目标的类别，标注框的位置坐标 这里将364张图像拆分为训练集300张，测试集64张，分别存放在iamges和images_testdata路径下 对应的xml标注分别存放在annotations和Annotations_testdata路径下 其中0-338为训练集，339-410为测试集 至此，
【无标题】
wbryze的博客
07-20 90
…]
【Tensorflow 大马哈鱼】tf.add_to_collection，tf.get_collection 和tf.add_n的用法
lyb3b3b的专栏
01-16 566
tf.add_to_collection：把变量放入一个集合，把很多变量变成一个列表 tf.get_collection：从一个结合中取出全部变量，是一个列表 tf.add_n：把一个列表的东西都依次加起来 如果是run变量，则更新cross_entropy_mean值 如果继续add_to_collection则是在列表中增加变量 如果tf.global_variables_init...
tensorflow之add_n
12-23 755
tf.add_n([p1, p2, p3....])函数是实现一个列表的元素的相加。就是输入的对象是一个列表，列表里的元素可以是向量，矩阵，等 输入时一个list或者一个数组 input1 = tf.constant([1.0, 2.0, 3.0]) input2 = tf.constant([1.0, 2.0, 3.0]) output = [input1, input2] print(o...
tf.add_to_collection，tf.get_collection和tf.add_n的用法
热门推荐
UESTC_C2_403的博客
05-17 5万+
tf.add_to_collection：把变量放入一个集合，把很多变量变成一个列表 tf.get_collection：从一个结合中取出全部变量，是一个列表 tf.add_n：把一个列表的东西都依次加起来 例如： import tensorflow as tf; import numpy as np; import matplotlib.pyplot as plt
tensorflow中 tf.add_to_collection、 tf.get_collection 和 tf.add_n函数
weixin_30600503的博客
04-12 341
tf.add_to_collection(name, value) 用来把一个value放入名称是‘name’的集合，组成一个列表;tf.get_collection(key, scope=None) 用来获取一个名称是‘key’的集合中的所有元素，返回的是一个列表，列表的顺序是按照变量放入集合中的先后; scope参数可选，表示的是名称空间（名称域），如果...
tf.nn.bias_add和tf.add、tf.add_n
AI-ON
04-27 6925
tf.add(x,y,name=None)x:a tensor musut be one of                           the following types: half, float32, float64, uint8, int8, int16, int32, int64, complex64, complex128, string.  y: A Tensor. Mu...
TensorFlow中的一个重要ops---MatMul的实现（二）
luozirong的专栏
04-10 5219
上面一篇文章我们主要介绍了MatMul这个op的正向计算的实现，我们知道模型的最后一步是计算优化模型的参数，而一般采用的方法是梯度下降法，所以每个op节点不仅要实现一个正向的计算节点，还要实现一个方向的梯度计算节点。 关于反向计算的结点官网有如下一段介绍： Implement the gradient in Python Given a graph of ops, TensorFlo
from tensorflow.python.ops.init_ops_v2 import glorot_uniform
最新发布
10-10
`glorot_uniform`是一个初始化操作，它属于TensorFlow库中`init_ops_v2`模块下的函数。Glorot Uniform初始化法，也称为Xavier Uniform初始化，是由Yann LeCun和他的团队提出的。这种初始化策略用于神经网络的权重...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值