Tensorflow学习笔记day02 + 矩阵基本操作

关于矩阵, 我们上一讲中有讲到, 也理清了它和张量之间的关系

这一讲, 我们来讲对矩阵的基本操作

import tensorflow as tf

如果你正在使用 Jupyter Notebook 或者 Python shell 进行编程，使用 tf.InteractiveSession 将比 tf.Session 更方便。InteractiveSession 使自己成为默认会话，因此你可以使用 eval() 直接调用运行张量对象而不用显式调用会话。

sess = tf.InteractiveSession()

I_matrix = tf.eye(5) #5*5 的单位矩阵

I_matrix.eval()
#输出如下:

array([[1., 0., 0., 0., 0.],
       [0., 1., 0., 0., 0.],
       [0., 0., 1., 0., 0.],
       [0., 0., 0., 1., 0.],
       [0., 0., 0., 0., 1.]], dtype=float32)

x = tf.Variable(tf.eye(10))

#x.eval()  不行

x.initializer.run() #变量需要初始化操作对象来赋予实际意义   ;  或着 sess.run(x.initializer)但由于可以隐式调用会话,所以就不用这个

x.eval()
#输出如下:

array([[1., 0., 0., 0., 0., 0., 0., 0., 0., 0.],
       [0., 1., 0., 0., 0., 0., 0., 0., 0., 0.],
       [0., 0., 1., 0., 0., 0., 0., 0., 0., 0.],
       [0., 0., 0., 1., 0., 0., 0., 0., 0., 0.],
       [0., 0., 0., 0., 1., 0., 0., 0., 0., 0.],
       [0., 0., 0., 0., 0., 1., 0., 0., 0., 0.],
       [0., 0., 0., 0., 0., 0., 1., 0., 0., 0.],
       [0., 0., 0., 0., 0., 0., 0., 1., 0., 0.],
       [0., 0., 0., 0., 0., 0., 0., 0., 1., 0.],
       [0., 0., 0., 0., 0., 0., 0., 0., 0., 1.]], dtype=float32)

A = tf.Variable(tf.random_normal([5,10])) #随机矩阵
A.initializer.run()
A.eval()
#输出如下:

array([[ 0.565306  ,  1.6084712 , -0.5639168 ,  1.0233473 , -0.7764772 ,
        -0.31178263,  0.10248601, -2.6429496 , -0.7610655 ,  0.4408502 ],
       [ 0.9193569 ,  0.18392901,  0.8217433 ,  0.91792303,  1.1959397 ,
        -0.19714825, -1.1799774 ,  0.57328886,  1.1690964 ,  0.6569883 ],
       [-1.7664219 , -0.12248611, -0.9129961 ,  0.07837848,  0.71676713,
        -0.91333145,  0.4062142 ,  1.2677864 ,  0.6895964 , -0.3568808 ],
       [-0.19590141, -0.45719898,  0.03834154,  2.934161  ,  0.7811971 ,
        -0.5815241 ,  0.75360924,  0.6197759 ,  0.38534704,  0.01617165],
       [ 2.3681874 , -1.597189  ,  0.1428296 , -1.4701174 ,  2.470483  ,
         1.6736263 , -0.3009129 ,  0.02857626, -2.2169607 ,  0.43409914]],
      dtype=float32)

product = tf.matmul(A,x) #两个矩阵相乘 , A为5*10 x为10*10, 可以进行相乘
product.eval()
#输出如下

array([[ 0.565306  ,  1.6084712 , -0.5639168 ,  1.0233473 , -0.7764772 ,
        -0.31178263,  0.10248601, -2.6429496 , -0.7610655 ,  0.4408502 ],
       [ 0.9193569 ,  0.18392901,  0.8217433 ,  0.91792303,  1.1959397 ,
        -0.19714825, -1.1799774 ,  0.57328886,  1.1690964 ,  0.6569883 ],
       [-1.7664219 , -0.12248611, -0.9129961 ,  0.07837848,  0.71676713,
        -0.91333145,  0.4062142 ,  1.2677864 ,  0.6895964 , -0.3568808 ],
       [-0.19590141, -0.45719898,  0.03834154,  2.934161  ,  0.7811971 ,
        -0.5815241 ,  0.75360924,  0.6197759 ,  0.38534704,  0.01617165],
       [ 2.3681874 , -1.597189  ,  0.1428296 , -1.4701174 ,  2.470483  ,
         1.6736263 , -0.3009129 ,  0.02857626, -2.2169607 ,  0.43409914]],
      dtype=float32)

b = tf.Variable(tf.random_uniform([5,10], 0, 2, dtype=tf.int32))# 含有0 和 1的矩阵
b.initializer.run()
b.eval()
#输出如下:

array([[1, 1, 0, 0, 1, 0, 1, 0, 0, 0],
       [1, 0, 0, 1, 0, 0, 0, 0, 1, 0],
       [1, 1, 1, 0, 1, 0, 1, 0, 1, 0],
       [1, 1, 0, 1, 1, 0, 0, 1, 1, 1],
       [0, 1, 1, 1, 1, 1, 1, 1, 1, 1]], dtype=int32)

b_new =tf.cast(b, dtype=tf.float32) #转换数据类型
b_new.eval()
#输出如下:

array([[1., 1., 0., 0., 1., 0., 1., 0., 0., 0.],
       [1., 0., 0., 1., 0., 0., 0., 0., 1., 0.],
       [1., 1., 1., 0., 1., 0., 1., 0., 1., 0.],
       [1., 1., 0., 1., 1., 0., 0., 1., 1., 1.],
       [0., 1., 1., 1., 1., 1., 1., 1., 1., 1.]], dtype=float32)

print(product.shape)
print(b_new.shape)
#输出如下:

(5, 10)
(5, 10)

t_sum = tf.add(product, b_new) #矩阵的加减
t_sub = product - b_new

t_sum.eval()
#输出如下:

array([[ 1.565306  ,  2.6084712 , -0.5639168 ,  1.0233473 ,  0.22352278,
        -0.31178263,  1.102486  , -2.6429496 , -0.7610655 ,  0.4408502 ],
       [ 1.9193568 ,  0.18392901,  0.8217433 ,  1.917923  ,  1.1959397 ,
        -0.19714825, -1.1799774 ,  0.57328886,  2.1690965 ,  0.6569883 ],
       [-0.7664219 ,  0.8775139 ,  0.08700389,  0.07837848,  1.7167671 ,
        -0.91333145,  1.4062142 ,  1.2677864 ,  1.6895964 , -0.3568808 ],
       [ 0.8040986 ,  0.542801  ,  0.03834154,  3.934161  ,  1.7811971 ,
        -0.5815241 ,  0.75360924,  1.6197759 ,  1.385347  ,  1.0161717 ],
       [ 2.3681874 , -0.59718895,  1.1428297 , -0.47011745,  3.470483  ,
         2.6736264 ,  0.69908714,  1.0285763 , -1.2169607 ,  1.4340992 ]],
      dtype=float32)

t_sub.eval()
#输出如下:

array([[-0.434694  ,  0.60847116, -0.5639168 ,  1.0233473 , -1.7764772 ,
        -0.31178263, -0.897514  , -2.6429496 , -0.7610655 ,  0.4408502 ],
       [-0.08064312,  0.18392901,  0.8217433 , -0.08207697,  1.1959397 ,
        -0.19714825, -1.1799774 ,  0.57328886,  0.16909635,  0.6569883 ],
       [-2.7664218 , -1.1224861 , -1.912996  ,  0.07837848, -0.28323287,
        -0.91333145, -0.59378576,  1.2677864 , -0.3104036 , -0.3568808 ],
       [-1.1959014 , -1.457199  ,  0.03834154,  1.934161  , -0.21880293,
        -0.5815241 ,  0.75360924, -0.3802241 , -0.614653  , -0.98382837],
       [ 2.3681874 , -2.597189  , -0.8571704 , -2.4701176 ,  1.4704831 ,
         0.6736263 , -1.3009129 , -0.97142375, -3.2169607 , -0.56590086]],
      dtype=float32)

a = tf.Variable(2*tf.ones([4,5]))
b = tf.Variable(tf.ones([4,5]))
a.initializer.run()
b.initializer.run()

A = a*b #矩阵与矩阵的各元素互乘
A.eval()
#输出如下:

array([[2., 2., 2., 2., 2.],
       [2., 2., 2., 2., 2.],
       [2., 2., 2., 2., 2.],
       [2., 2., 2., 2., 2.]], dtype=float32)

B = tf.scalar_mul(2, A) #或者 B = 2*A
B.eval()
#输出如下:

array([[4., 4., 4., 4., 4.],
       [4., 4., 4., 4., 4.],
       [4., 4., 4., 4., 4.],
       [4., 4., 4., 4., 4.]], dtype=float32)

C = tf.div(a,b) #矩阵a的元素/ 矩阵b的元素
C.eval()
#输出如下:

array([[2., 2., 2., 2., 2.],
       [2., 2., 2., 2., 2.],
       [2., 2., 2., 2., 2.],
       [2., 2., 2., 2., 2.]], dtype=float32)

D = tf.mod(a,b) #矩阵a的元素对矩阵b的元素 进行求余
D.eval()
#输出如下:

array([[0., 0., 0., 0., 0.],
       [0., 0., 0., 0., 0.],
       [0., 0., 0., 0., 0.],
       [0., 0., 0., 0., 0.]], dtype=float32)

所有加法、减、除、乘（按元素相乘）、取余等矩阵的算术运算都要求两个张量矩阵是相同的数据类型，否则就会产生错误。可以使用 **tf.cast()**将张量从一种数据类型转换为另一种数据类型。

如果在整数张量之间进行除法，最好使用 tf.truediv(a，b)，因为它首先将整数张量转换为浮点类，然后再执行按位相除。