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

栏目: Python · 发布时间: 6年前

内容简介：Tensorflow Python API 翻译（math_ops）（第一部分）

作者：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 的形式，那么绝对值计算公式如下：

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

比如：

# 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）。


以上就是本文的全部内容，希望本文的内容对大家的学习或者工作能带来一定的帮助，也希望大家多多支持 码农网

查看所有标签

猜你喜欢:

本站部分资源来源于网络，本站转载出于传递更多信息之目的，版权归原作者或者来源机构所有，如转载稿涉及版权问题，请联系我们。

码农书籍
算法交易与套利交易

算法交易与套利交易

赵胜民 / 厦门大学出版社 / 2010-9 / 35.00元

《算法交易与套利交易》主要介绍算法交易和一些套利交易的策略，以便于读者对相关方面的内容进行阅读和学习。在《算法交易与套利交易》的第一部分，我们回顾了投资学一些相关的基本内容。其中，前两章介绍了证券投资的收益和风险等特征，以及马可维茨的最优资产配置模型。第3章则介绍了股票投资分析当中常用的资本资产定价模型（CAPM）、套利定价模型（APT），以及因素模型。然后，第4、5章分别讲到了金融证券估值模型、......一起来看看 《算法交易与套利交易》 这本书的介绍吧!

码农工具
HTML 压缩/解压工具
HTML 压缩/解压工具

在线压缩/解压 HTML 代码

随机密码生成器
随机密码生成器

多种字符组合密码

HTML 编码/解码
HTML 编码/解码

HTML 编码/解码

  • New
  • 文章
  • 话题
  • 教程
    • 关注 码农网 公众号
    版权所有，保留一切权利！© 2018-2025 码农网 粤ICP备17054400号-3