机器学习 ----矩阵知识补充

矩阵的定义

矩阵的运算（含幂运算）

加减比较简单，就是对应元素相加减 (只有行列都相同的矩阵才可以进行)

用NumPy 来演示一下矩阵加法

Numpy有专门的矩阵函数（np.mat）

import numpy as np
# 创建两个集合
A = np.arange(1,10).reshape((3,3))
B = np.arange(9).reshape((3,3))

print(A)
print("-"*5)
print(B)

　　输出

[[1 2 3]
 [4 5 6]
 [7 8 9]]
-----
[[0 1 2]
 [3 4 5]
 [6 7 8]]

A + B

　　输出：

array([[ 1,  3,  5],
       [ 7,  9, 11],
       [13, 15, 17]])

A - B

　　输出：

array([[1, 1, 1],
       [1, 1, 1],
       [1, 1, 1]])

# 之前说过 ”只有行列都相同的矩阵才可以进行“ 来验证一下
# 创建一个2行3列的矩阵
C = np.arange(6).reshape((2,3))
D = np.arange(6).reshape((3,2))

print(C)
print("-"*5)
print(D)

　　输出：

[[0 1 2]
 [3 4 5]]
-----
[[0 1]
 [2 3]
 [4 5]]

C + D # 不同形状的矩阵不能进行加运算

　　输出：

---------------------------------------------------------------------------
ValueError                                Traceback (most recent call last)
<ipython-input-8-bc97e29f7e31> in <module>()
      1 # 2行3列的矩阵 + 3行2列的矩阵
----> 2C + D # 不同形状的矩阵不能进行加运算

.数乘、数除

这个也比较简单，就是和每个元素相乘，eg:2×A，A原本的每一个元素都扩大了两倍

数除其实就是乘以倒数（1/x）

print(A)

[[1 2 3]
 [4 5 6]
 [7 8 9]]

2 * A　　

array([[ 2,  4,  6],
       [ 8, 10, 12],
       [14, 16, 18]])

A / 2

array([[0.5, 1. , 1.5],
       [2. , 2.5, 3. ],
       [3.5, 4. , 4.5]])

.矩阵乘法

两个矩阵的乘法仅当第一个矩阵A的列数(column)和另一个矩阵B的行数(row)相等才可以进行计算

 

程序验证了我们上面的运算结果，还得注意一下：

A×B和B×A是不一样的，eg：B×A

.幂乘、幂运算

幂乘比较简单，就是每个元素开平方，不一定是方阵

必须是方阵才能进行幂运算，比如A²=A×A（矩阵相乘前提：第一个矩阵A的行=第二个矩阵A的列==>方阵）

来个小结 + 扩展：

矩阵的加法运算满足交换律：A + B = B + A

矩阵的乘法满足结合律和对矩阵加法的分配律：

结合律：(AB)C = A(BC)

左分配律：(A + B)C = AC + BC

右分配律：C(A + B) = CA + CB

矩阵的乘法与数乘运算之间也满足类似结合律的规律；与转置之间则满足倒置的

分配律：c(A + B) = cA + cB

结合律：c(AB) = (cA)B = A(cB)

矩阵乘法不满足交换律 一般来说，矩阵A及B的乘积AB存在，但BA不一定存在，即使存在，大多数时候AB ≠ BA

.特殊矩阵

import numpy as np
# 一维
# 可以指定类型 np.zeros(5,dtype=int)
print(np.zeros(5)) # 完整写法：np.zeros((5,))
print("********************
")
# 二维
print(np.zeros((2,5)))# 建议用元组，官方文档都是元组
print("********************
")
# 三维 ==> 可以这么理解，2个2*5（2行5列）的矩阵
print(np.zeros((2,2,5)))
print("********************
")

# `np.ones(tuple)` 用法和`np.zeros(tuple)`差不多
# 可以指定类型 np.ones(5,dtype=int)
# 一维
print(np.ones(5)) # 完整写法 np.ones((5,))
print("********************
")
# 二维，传一个shape元组
print(np.ones((2,5)))
print("********************
")
# 三维 可以理解为两个二维数组
print(np.ones((2,2,5)))
print("********************
")
################ 指定值矩阵 ################
# 创建指定值的矩阵：
print(np.full((3,5),222))
print("********************
")
# 创建指定值的矩阵，浮点类型
print(np.full((3,5),222.0))
print("********************
")

输出：

[0. 0. 0. 0. 0.]
********************

[[0. 0. 0. 0. 0.]
[0. 0. 0. 0. 0.]]
********************

[[[0. 0. 0. 0. 0.]
[0. 0. 0. 0. 0.]]

[[0. 0. 0. 0. 0.]
[0. 0. 0. 0. 0.]]]
********************

[1. 1. 1. 1. 1.]
********************

[[1. 1. 1. 1. 1.]
[1. 1. 1. 1. 1.]]
********************

[[[1. 1. 1. 1. 1.]
[1. 1. 1. 1. 1.]]

[[1. 1. 1. 1. 1.]
[1. 1. 1. 1. 1.]]]
********************

[[222 222 222 222 222]
[222 222 222 222 222]
[222 222 222 222 222]]
********************

[[222. 222. 222. 222. 222.]
[222. 222. 222. 222. 222.]
[222. 222. 222. 222. 222.]]
********************

转置矩阵

转置矩阵 ：将矩阵的行列互换得到的新矩阵(行列式不变)

m行×n列的矩阵行和列交换后就变成了n行×m列的矩阵，eg：3行×2列 ==> 2行×3列

 再次提醒：两个矩阵的乘法仅当第一个矩阵A的列数(column)和另一个矩阵B的行数(row)相等才可以进行计算

import numpy as np

A = np.arange(6).reshape((2,3))
print("
A:   
",A)

# 转置矩阵（行列互换）
A.T
print("
A.T:   
",A.T)

B = np.random.randint(10,size=(2,3))
print("
B:   
",B)
print("-"*5)
print("
B.T:   
",B.T)

################ 验证系列 ################
# 验证一下(A+B)^T=A^T+B^T
print("
A.T + B.T:   
",A.T + B.T)

print("-"*5)
print("
(A+B).T:   
",(A+B).T)

# 验证一下(A+B)^T=A^T+B^T
# 其实也再一次验证了，Numpy运算符默认是对每一个元素的操作

print("
(A+B).T == A.T + B.T: 
",(A+B).T == A.T + B.T)

# 把A变成3*2的矩阵，不够元素用0补
# reshape：有返回值，不对原始多维数组进行修改
# resize：无返回值，会对原始多维数组进行修改
A.resize(3,2)



print("
B:   
",B)
print("
A:   
",A)
print("
np.power(A,3):   
",np.power(A,3))
# A*A*A
C=np.arange(1,5).reshape(2,2)
D=np.linalg.matrix_power(C,3)
print("
 C:",C)
print("
 D:",D)

　　

A:
[[0 1 2]
[3 4 5]]

A.T:
[[0 3]
[1 4]
[2 5]]

B:
[[3 1 8]
[5 4 8]]
-----

B.T:
[[3 5]
[1 4]
[8 8]]

A.T + B.T:
[[ 3 8]
[ 2 8]
[10 13]]
-----

(A+B).T:
[[ 3 8]
[ 2 8]
[10 13]]

(A+B).T == A.T + B.T:
[[ True True]
[ True True]
[ True True]]

B:
[[3 1 8]
[5 4 8]]

A:
[[0 1]
[2 3]
[4 5]]

np.power(A,3):
[[ 0 1]
[ 8 27]
[ 64 125]]

C: [[1 2]
[3 4]]

D: [[ 37 54]
[ 81 118]]

上三角矩阵和下三角矩阵

import numpy as np



# 创建一个5行4列矩阵
A = np.random.randint(10,size=(4,4))

print("
A:   
",A)

# 上三角
np.triu(A)
print("
np.triu(A):   
",np.triu(A))

# 下三角
np.tril(A)
print("
np.tril(A):   
",np.tril(A))

# 验证一下最后一个性质
# 三角矩阵的逆矩阵也仍然是三角矩阵
print("
np.triu(A).T:   
",np.triu(A).T)
print('-'*5)
print("
np.tril(A).T:   
",np.tril(A).T)

　　

A:
[[9 9 5 7]
[0 4 6 6]
[1 4 9 7]
[2 4 5 2]]

np.triu(A):
[[9 9 5 7]
[0 4 6 6]
[0 0 9 7]
[0 0 0 2]]

np.tril(A):
[[9 0 0 0]
[0 4 0 0]
[1 4 9 0]
[2 4 5 2]]

np.triu(A).T:
[[9 0 0 0]
[9 4 0 0]
[5 6 9 0]
[7 6 7 2]]
-----

np.tril(A).T:
[[9 0 1 2]
[0 4 4 4]
[0 0 9 5]
[0 0 0 2]]

对角矩阵

import numpy as np

# 简单创建
A=np.diag([3,9,6])
print("
A:   
",A)
B=np.diag([2,2,2])
print("
B:   
",B)

# 获取对角元素，然后再生成对角矩阵
C= np.random.randint(10,size=(4,4))
D = np.diag(C.diagonal()) #或者 np.diag(np.diag(A))

print("
C:   
",C)
print("
D:   
",D)

# 对角矩阵的矩阵幂运算等于其对应元素的幂运算 D**3
E=D.dot(D).dot(D)
print("
E:   
",E)

　　

A:
[[3 0 0]
[0 9 0]
[0 0 6]]

B:
[[2 0 0]
[0 2 0]
[0 0 2]]

C:
[[6 6 0 7]
[5 9 1 4]
[9 1 1 0]
[5 0 6 9]]

D:
[[6 0 0 0]
[0 9 0 0]
[0 0 1 0]
[0 0 0 9]]

E:
[[216 0 0 0]
[ 0 729 0 0]
[ 0 0 1 0]
[ 0 0 0 729]]

.单位矩阵

#定义一个2行的单位矩阵（列默认和行一致）
# np.eye(rows,columns=rows)
A=np.eye(2)
print("
A:   
",A)

# 可以指定类型
B = np.eye(4,dtype=int)
print("
B:   
",B)

C=np.random.randint(10,size=(4,4))
print("
C:   
",C)
D=C.dot(B)
print("
D:   
",D)　

A:
[[1. 0.]
[0. 1.]]

B:
[[1 0 0 0]
[0 1 0 0]
[0 0 1 0]
[0 0 0 1]]

C:
[[6 3 1 4]
[2 3 8 2]
[5 4 3 0]
[3 9 6 4]]

D:
[[6 3 1 4]
[2 3 8 2]
[5 4 3 0]
[3 9 6 4]]

对称矩阵

对称矩阵 :元素以主对角线为对称轴对应相等的方阵

对称矩阵的转置是它本身：AT=A

import numpy as np

A = np.random.randint(10,size=(4,4))
print("
A:   
",A)

#上矩阵
B = np.triu(A)
print("
B:   
",B)

#对称矩阵
C = B + B.T - np.diag(A.diagonal())
print("
C:   
",C)　　

A:
[[3 8 5 4]
[3 2 0 7]
[4 4 7 8]
[2 5 9 8]]

B:
[[3 8 5 4]
[0 2 0 7]
[0 0 7 8]
[0 0 0 8]]

C:
[[3 8 5 4]
[8 2 0 7]
[5 0 7 8]
[4 7 8 8]]

逆矩阵

消元法

可能一看到逆矩阵，大家就想到代数余子式 ，不过逆天要说的是，代数余子式就和我们程序员面试题一样，有些题目就是又繁琐实际运用又没多大意义的题目一样，很多时候面试官都不看面试题一眼，同样的那些出题老师自己解题一般都不会使用。我这边介绍一下方便简单的方法“消元法”

　

# coding=utf-8
import numpy as np


A = np.array([[3,2],[1,2]])
print("
A:   
",A)

B=np.linalg.inv(A)
print("
B:   
",B)

　　

A:
[[3 2]
[1 2]]

B:
[[ 0.5 -0.5 ]
[-0.25 0.75]]

二阶方阵公式

伪逆矩阵

 

程序比较简单：

np.linalg.det(A)

　

# coding=utf-8
import numpy as np

#A非方阵
A = np.array([[7, 3, 6],[5, 3, 1]])
print("
A:   
",A)

# 有时候还是需要求逆矩阵
# 那就可以求它的伪逆矩阵
B=np.linalg.pinv(A)

print("
B:   
",B)

# A*X*A=A
C=A.dot(B).dot(A)
print("
C:   
",C)

# X*A*X=X
D=B.dot(A).dot(B)
print("
D:   
",D)

# 创建一个矩阵
E = np.mat([[3,2],[1,2]])

print("
E:   
",E)

#  np.linalg.det(E)不等于0就是可逆
print(np.linalg.det(E)) #4.000000000000001

#E的逆矩阵F
print("
E.I:   
",E.I)
F=np.linalg.inv(E)
print("
F:   
",F)

G=E*F
print("
G:   
",G)
print("
E.T:   
",E.T)　

A:
[[7 3 6]
[5 3 1]]

B:
[[-0.00632911 0.15189873]
[-0.05696203 0.16708861]
[ 0.20253165 -0.26075949]]

C:
[[7. 3. 6.]
[5. 3. 1.]]

D:
[[-0.00632911 0.15189873]
[-0.05696203 0.16708861]
[ 0.20253165 -0.26075949]]

E:
[[3 2]
[1 2]]
4.000000000000001

E.I:
[[ 0.5 -0.5 ]
[-0.25 0.75]]

F:
[[ 0.5 -0.5 ]
[-0.25 0.75]]

G:
[[1.00000000e+00 2.22044605e-16]
[1.11022302e-16 1.00000000e+00]]

E.T:
[[3 1]
[2 2]]