tensorflow2.0基础（2）——张量的数学运算

张量的数学运算

张量数学运算主要有：标量运算，向量运算，矩阵运算，张量运算采用的广播机制。

张量的数学运算符可以分为标量运算符、向量运算符、以及矩阵运算符。

加减乘除乘方，以及三角函数，指数，对数等常见函数，逻辑比较运算符等都是标量运算符。

标量运算符的特点是对张量实施逐元素运算。

有些标量运算符对常用的数学运算符进行了重载。并且支持类似numpy的广播特性。

许多标量运算符都在 tf.math模块下。

一、标量运算

import tensorflow as tf
import numpy as np

a= tf.constant([[1.0,0.2],[-3,4.0]])
b=tf.constant([[5.0,6],[7.0,8.0]])
a+b#运算符重载

a-b

a*b

a/b

a**2

a**(0.5)

a%3 #mod的运算符重载，等价于m = tf.math.mod(a,3)  

a//3 #地板除法(取余)

(a>=2)

(a>=2)&(a<=3)

(a>=2)|(a<=3)

a==5 #tf.equal(a,5)

tf.sqrt(a)

a = tf.constant([1.0,8.0])
b = tf.constant([5.0,6.0])
c = tf.constant([6.0,7.0])
tf.add_n([a,b,c])

tf.print(tf.maximum(a,b))

[5 8]

tf.print(tf.minimum(a,b))

[1 6]

二、向量运算

向量运算符只在一个特定轴上运算，将一个向量映射到一个标量或者另外一个向量。 许多向量运算符都以reduce开头。

#向量reduce

a=tf.range(1,10)
print(a)
print(tf.reduce_sum(a))#axis默认为none,所有维度都执行叠加操作
print(tf.reduce_mean(a))#所有维度的平均值
tf.print(tf.reduce_max(a))#所有维度最大值
tf.print(tf.reduce_min(a))#所有维度最小值
tf.print(tf.reduce_prod(a))#所有维度上元素的乘积

tf.Tensor([1 2 3 4 5 6 7 8 9], shape=(9,), dtype=int32)
tf.Tensor(45, shape=(), dtype=int32)
tf.Tensor(5, shape=(), dtype=int32)
9
1
362880

#张量指定维度进行reduce
b=tf.reshape(a,(3,3))
tf.print(b)
tf.print(b.shape)
tf.print(tf.reduce_sum(b,axis=1,keepdims=True))#行
tf.print(tf.reduce_sum(b,axis=0,keepdims=True))#列

[[1 2 3]
 [4 5 6]
 [7 8 9]]
TensorShape([3, 3])
[[6]
 [15]
 [24]]
[[12 15 18]]

#bool类型的reduce
p = tf.constant([True,False,False])
q = tf.constant([False,False,True])
tf.print(tf.reduce_all(p))#在张量的维度上计算元素的 "逻辑与"
tf.print(tf.reduce_any(q))#在张量的维度上计算元素的 "逻辑或"

0
1

#利用tf.foldl实现tf.reduce_sum
s = tf.foldl(lambda a,b:a+b,tf.range(10)) #tf.foldl(fn,elems=[x1,x2,x3,x4]) = fn(fn(fn(x1,x2),x3),x4),tf.foldr(fn,elems=[x1,x2,x3,x4]) = fn(fn(fn(x4,x3),x2),x1)
tf.print(s)

45

#cum扫描累积
a = tf.range(1,10)
tf.print(tf.math.cumsum(a))#扫描累计和
tf.print(tf.math.cumprod(a))#扫描累积乘积

[1 3 6 ... 28 36 45]
[1 2 6 ... 5040 40320 362880]

#arg最大最小值索引
a = tf.range(1,10)
print(a)
tf.print(tf.argmax(a))#最大值索引
tf.print(tf.argmin(a))#最小值索引

tf.Tensor([1 2 3 4 5 6 7 8 9], shape=(9,), dtype=int32)
8
0

#tf.math.top_k可以用于对张量排序
a = tf.constant([1,3,7,5,4,8])

values,indices = tf.math.top_k(a,3,sorted=True)#倒序，前三，得到值列表，和值所对应的位置列表
tf.print(values)
tf.print(indices)

#利用tf.math.top_k可以在TensorFlow中实现KNN算法

[8 7 5]
[5 2 3]

三，矩阵运算

矩阵必须是二维的。类似tf.constant([1,2,3])这样的不是矩阵。

矩阵运算包括：矩阵乘法，矩阵转置，矩阵逆，矩阵求迹，矩阵范数，矩阵行列式，矩阵求特征值，矩阵分解等运算。

除了一些常用的运算外，大部分和矩阵有关的运算都在tf.linalg子包中。

#矩阵乘法
a = tf.constant([[1,2],[3,4]])
b = tf.constant([[2,0],[0,2]])
tf.print(a@b ) #等价于tf.matmul(a,b)
tf.print('------')
c=tf.matmul(a,b)
tf.print(c)

[[2 4]
 [6 8]]
------
[[2 4]
 [6 8]]

#矩阵转置
a = tf.constant([[1.0,2],[3,4]])
tf.transpose(a)

#矩阵逆，必须为tf.float32或tf.double类型
a = tf.constant([[1.0,2],[3.0,4]],dtype = tf.float32)
tf.linalg.inv(a)

#矩阵求trace  矩阵的迹————对角线元素之和
a = tf.constant([[1.0,2],[3,4]])
tf.linalg.trace(a)

#矩阵求范数
a = tf.constant([[1.0,2],[3,4]])
tf.linalg.norm(a)

#矩阵行列式
a = tf.constant([[1.0,2],[3,4]])
tf.linalg.det(a)#一阶行列式是a[0][0],二阶行列式a[0][0]*a[1][1]-a[0][1]*a[1][0]  

#矩阵qr分解
a  = tf.constant([[1.0,2.0],[3.0,4.0]],dtype = tf.float32)
q,r = tf.linalg.qr(a)
tf.print(q)
tf.print(r)
tf.print(q@r)

[[-0.316227794 -0.948683321]
 [-0.948683321 0.316227764]]
[[-3.1622777 -4.4271884]
 [0 -0.632455409]]
[[1.00000012 1.99999988]
 [3 3.99999976]]

#矩阵svd分解
a  = tf.constant([[1.0,2.0],[3.0,4.0]],dtype = tf.float32)
v,s,d = tf.linalg.svd(a)
tf.matmul(tf.matmul(s,tf.linalg.diag(v)),d)
#利用svd分解可以在TensorFlow中实现主成分分析降维

四，广播机制

TensorFlow的广播规则和numpy是一样的:

1、如果张量的维度不同，将维度较小的张量进行扩展，直到两个张量的维度都一样。

2、如果两个张量在某个维度上的长度是相同的，或者其中一个张量在该维度上的长度为1，那么我们就说这两个张量在该维度上是相容的。

3、如果两个张量在所有维度上都是相容的，它们就能使用广播。

4、广播之后，每个维度的长度将取两个张量在该维度长度的较大值。

5、在任何一个维度上，如果一个张量的长度为1，另一个张量长度大于1，那么在该维度上，就好像是对第一个张量进行了复制。 tf.broadcast_to 以显式的方式按照广播机制扩展张量的维度。

a = tf.constant([1,2,3])
b = tf.constant([[0,0,0],[1,1,1],[2,2,2]])
b + a  #等价于 b + tf.broadcast_to(a,b.shape)

tf.broadcast_to(a,b.shape)

#计算广播后计算结果的形状，静态形状，TensorShape类型参数
tf.broadcast_static_shape(a.shape,b.shape)

TensorShape([3, 3])

#计算广播后计算结果的形状，动态形状，Tensor类型参数
c = tf.constant([1,2,3])
d = tf.constant([[1],[2],[3]])
tf.broadcast_dynamic_shape(tf.shape(c),tf.shape(d))

#广播效果
c+d #等价于 tf.broadcast_to(c,[3,3]) + tf.broadcast_to(d,[3,3])

array([[2, 3, 4],
[3, 4, 5],
[4, 5, 6]], dtype=int32)>

本文参考文章