import tensorflow as tf 
import numpy  np 
a = tf.constant([[1.0,2],[-3,1)">4.0]])
b = tf.constant([[5.0,1)">6],[7.0,1)">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))

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

 向量reduce
a = tf.range(1,10)
tf.print(tf.reduce_sum(a))
tf.(tf.reduce_mean(a))
tf.(tf.reduce_max(a))
tf.(tf.reduce_min(a))
tf.print(tf.reduce_prod(a))

 张量指定维度进行reduce
b = tf.reshape(a,(3,3))
tf.print(tf.reduce_sum(b,axis=1,keepdims=True))
tf.[[6]
 [15]
 [24]]
[[12 15 18]]

 bool类型的reduce
p = tf.constant([True,False,False])
q = tf.constant([False,True])
tf.(tf.reduce_all(p))
tf.print(tf.reduce_any(q))

0
1

 利用tf.foldr实现tf.reduce_sum
s = tf.foldr(lambda a,b:a+b,tf.range(10)) 
tf.print(s)

45

 cum扫描累积
a = tf.range(1,1)">(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,1)">(tf.argmax(a))
tf.print(tf.argmin(a))

8
0

 tf.math.top_k可以用于对张量排序
a = tf.constant([1,3,7,5,4,8])
 
values,indices = tf.math.top_k(a,sorted=True)
tf.(values)
tf.(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]])
a@b  等价于tf.matmul(a,b)

<tf.Tensor: shape=(2, numpy=
array([[2, 4],
       [6, 8]], dtype=int32)>

 矩阵转置
a = tf.constant([[1.0,1)">]])
tf.transpose(a)

<tf.Tensor: shape=(2, numpy=
array([[1., 3.],
       [2., 4.]], dtype=float32)>

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

<tf.Tensor: shape=(2, numpy=
array([[-2.0000002 ,  1.0000001 ],
       [ 1.5000001 , -0.50000006]], dtype=float32)>

 矩阵求trace
a = tf.constant([[1.0,1)">]])
tf.linalg.trace(a)

<tf.Tensor: shape=(), numpy=5.0>

 矩阵求范数
a = tf.constant([[1.0,1)">]])
tf.linalg.norm(a)

<tf.Tensor: shape=(), numpy=5.477226>

 矩阵行列式
a = tf.constant([[1.0,1)">]])
tf.linalg.det(a)

<tf.Tensor: shape=(), numpy=-2.0>

 矩阵特征值
tf.linalg.eigvalsh(a)

<tf.Tensor: shape=(2, numpy=array([-0.8541021,  5.854102 ], dtype=float32)>

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

[[-0.316227794 -0.948683321]
 [-0.948683321 0.316227734]]
[[-3.1622777 -4.4271884]
 [0 -0.632455349]]
[[1.00000012 1.99999976]
 [3 4]]

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

<tf.Tensor: shape=(2, numpy=
array([[0.9999996, 1.9999996],
       [2.9999998, 4.       ]], dtype=float32)>

四，广播机制

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

• 1、如果张量的维度不同，将维度较小的张量进行扩展，直到两个张量的维度都一样。
• 2、如果两个张量在某个维度上的长度是相同的，或者其中一个张量在该维度上的长度为1，那么我们就说这两个张量在该维度上是相容的。
• 3、如果两个张量在所有维度上都是相容的，它们就能使用广播。
• 4、广播之后，每个维度的长度将取两个张量在该维度长度的较大值。
• 5、在任何一个维度上，如果一个张量的长度为1，另一个张量长度大于1，那么在该维度上，就好像是对第一个张量进行了复制。

tf.broadcast_to 以显式的方式按照广播机制扩展张量的维度。

 利用svd分解可以在TensorFlow中实现主成分分析降维

<tf.Tensor: shape=(3, 3), numpy=
array([[1, 3],
       [2, 3,
       [3, 4, 5]], dtype=int32)>

tf.broadcast_to(a,b.shape)

<tf.Tensor: shape=(3,
       [1, 3]], dtype=int32)>

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

TensorShape([3, 3])

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

<tf.Tensor: shape=(2, numpy=array([3, dtype=int32)>

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

<tf.Tensor: shape=(2, numpy=
array([[6.5760484, 7.8174157],
       [6.8174157, 6.4239516]], dtype=float32)>

参考：

开源电子书地址：https://lyhue1991.github.io/eat_tensorflow2_in_30_days/

GitHub 项目地址：https://github.com/lyhue1991/eat_tensorflow2_in_30_days