目录

1 引言

2 Python里向量和矩阵的概念

3 矩阵相乘——Python

4 Python矩阵相乘举例说明

4.1 对位乘积举例说明

4.2 矩阵乘法

4.3 向量内积

---

1 引言

矩阵相乘分为叉乘和点乘，叉乘就是矩阵的乘法，指矩阵A的第一行乘以矩阵B的第一列，各个元素对应相乘后求和作为第一个元素的值。能够进行叉乘运算的场景：A的行数等于B的列数。

矩阵的点乘就是矩阵A和矩阵B各个对应元素的相乘。能够进行点乘运算的场景：①A和B的行向量个数相等；② A和B的列向量的个数相等；③ A和B的行向量和列向量都相等。

在matlab里面实现点乘用“.*”，实现叉乘用“*”，非常清晰明了。但是在Python里面实现矩阵相乘时经常会报错，原因是在Python里面向量和矩阵的概念和数学里面的概念有点差异。

2 Python里向量和矩阵的概念

Pyhton的向量和矩阵是严格区分开来的，这个和数学上（或者Matlab里）的概念是不一样的：

向量：一维；
矩阵：最少是二维。

举例：

import numpy as np
A=np.array([1,2,3]) #一维向量，shape=(3,)
B=np.array([[1,2,3]]) #二维数组，shape=(1,3)
print(f'A={A}')
print(f'B={B}')
print(f'A.shape={A.shape}')
print(f'B.shape={B.shape}')
print(f'A.T={A.T}')
print(f'B.T={B.T}')

运行结果如下：

A=[1 2 3]
B=[[1 2 3]]
A.shape=(3,)
B.shape=(1, 3)
A.T=[1 2 3]
B.T=
    [[1]
     [2]
     [3]]

代码中：
① A是向量，其shape为(3,)；其B是行数为1的二维数组，其shape为(1,3)；
② 向量没有转置的概念。A的转置还是A，而B的转置是从行数为1的二维数组变成了列数为1的二维数组，这一点和matlab里面是不一样的。

由于以上两点原因，在计算矩阵相乘时，初学者很容易犯错。

3 矩阵相乘——Python

一般情况下，矩阵相乘会有以下三种想要的结果：

① 对位乘积：两个矩阵shape相同，各元素对应相乘，结果是一个相同shape的矩阵
② 矩阵乘法：数学上的矩阵乘法，结果是一个矩阵
③ 向量内积：对应元素相乘，再相加，结果是一个数值

对应的实现方式如下：

① 对位乘积： a*b 、multiply(a,b)
② 矩阵乘积： dot(a,b) 、matmul(a,b) 、a@b
③ 向量内积： dot(a,b)、a@b   当a,b均为一维向量

实际上对位乘积采用的是点乘，矩阵乘积或者向量内积采用的是叉乘。

4 Python矩阵相乘举例说明

从Python里面向量和矩阵的概念可知，向量和矩阵可以分为三种形式：一维向量、行数为1或者列数为1的二维矩阵、行数和行数均大于等于2的二维矩阵。对于初学者来说很容易把一维向量和行数为1或者列数为1的二维矩阵弄混，从而导致矩阵相乘出错。本文介绍了一种可以适用所有情况的矩阵相乘的表示方法，即只要能先将A和B的形式定义清楚，就能在实现点乘和叉乘时不出错。

 矩阵的乘法有三种情况对位乘积、矩阵乘法、向量内积。对位乘积的结果是一个矩阵，矩阵乘法的乘积是一个矩阵，向量内积的结果是一个数，所以A和B的形式定义的思路如下：

① 对于对位乘积、矩阵乘法，其应用对象是矩阵，当A和B其中任意一个为向量时，先将向量转换成行数为1或者列数为1的二维矩阵，再参与运算；

② 对于向量内积，其应用对象是向量，当A和B其中任意一个为行数为1或者列数为1的二维矩阵时，先将行数为1或者列数为1的二维矩阵转换成一维向量，再参与运算；

只要遵守上述两点原则，矩阵相乘就不会出错。实现上述两点的语法如下：

① 向量转二维矩阵，采用newaxis：

import numpy as np
A=np.array([1,2,3]) #向量，shape=(3,),不能进行转置操作
print(A)
A=A[:,np.newaxis].T #二维数组，shape=(1,3)，可以进行转置操作
print(A)

运行结果如下：

[1 2 3]
[[1 2 3]]

② 二维数组转向量，采用ravel()函数：

import numpy as np
A=np.array([[1,2,3]]) #二维数组，shape=(1,3)，可以进行转置操作
print(A)
A=A.ravel() #向量，shape=(3,),不能进行转置操作
print(A)

运行结果如下：

[[1 2 3]]
[1 2 3]

4.1 对位乘积举例说明

对位乘积（点乘）前提条件：① 行数、列数都相等；② 行数或者列数其中之一相等。

① 场景1：二维矩阵.*二维矩阵，没有向量

import numpy as np
#------没有向量的场景,二维数组*二维数组-----#
A=np.array([[1,2],[4,5],[3,6]]) #行数为3，列数为2二维数组
B=np.array([[1,2],[1,2],[1,3]])  #行数为3，列数为2二维数组
C=np.array([[2,1]]) #行数为1，列数为2的二维数组
D=np.array([[3],[1],[2]]) #行数为3，列数为1的二维数组
print(f'A*B={A*B}')   #矩阵点乘
print(f'A*C={A*C}')   #行数不够，采用广播机制进行运算
print(f'A*D={A*D}')   #列数不够，采用广播机制进行运算

运行结果如下：

A*B=[[ 1  4]
 [ 4 10]
 [ 3 18]]
A*C=[[2 2]
 [8 5]
 [6 6]]
A*D=[[ 3  6]
 [ 4  5]
 [ 6 12]]

② 场景2：二维数组.*向量

import numpy as np
#------二维矩阵*向量-----#
A=np.array([[1,2],[4,5],[3,6]]) #二维数矩阵,shape=(3,2)
B=np.array([[1,2,3],[4,5,6]]) #二维矩阵，shape=(2,3)
C=np.array([2,1,2]) #向量,shape=(3,)
C=C[:,np.newaxis] #将C从向量变成二维数组，shape=(3,1)
print(f'A*C={A*C}') #A的行数等于C的行数，广播机制
print(f'B*C.T={B*C.T}') #B的列数等于C.T的列数，广播机制

运行结果如下：

A*C=[[ 2  4]
 [ 4  5]
 [ 6 12]]
B*C.T=[[ 2  2  6]
 [ 8  5 12]]

4.2 矩阵乘法

矩阵乘法的前提条件：A×B，A的列数等于B的行数

① 场景1：二维矩阵×二维矩阵，没有向量

import numpy as np
#------二维矩阵×二维矩阵-----#
A=np.array([[1,2],[4,5],[3,6]]) #二维数组,shape=(3,2)
B=np.array([[1,2,3],[4,5,6]]) #二维矩阵，shape=(2,3)
C=np.array([[2,1]]) #二维矩阵，shape=(1,2)
print(f'A×B={A@B}') #A的列数等于B的行数
print(f'A×C={A@C.T}') #A的列数等于C.T的行数

运行结果如下：

A×B=[[ 9 12 15]
 [24 33 42]
 [27 36 45]]
A×C=[[ 4]
 [13]
 [12]]

② 场景2：二维矩阵×向量

#------二维矩阵×向量-----#
A=np.array([[1,2],[4,5],[3,6]]) #二维数组,shape=(3,2)
B=np.array([[1,2,3],[4,5,6]]) #二维矩阵，shape=(2,3)
C=np.array([2,1]) #向量，shape=(2,)
C=C[:,np.newaxis] #转换成二维矩阵，shape=(2,1)
print(f'A×C={A@C}') #A的列数等于C的行数
print(f'B×C={B.T@C}') #B.T的列数等于C的行数

运行结果如下：

A×C=[[ 4]
 [13]
 [12]]
B×C=[[ 6]
 [ 9]
 [12]]

4.3 向量内积

向量乘积的前提条件是向量的长度相等。

① 场景1：向量×向量

import numpy as np
#----向量×向量
A=np.array([1,2,3]) #向量，shape=(3,)
B=np.array([2,3,1]) #向量，shape=(3,)
print(A@B)
print(A@B.T)
print(A.T@B)
print(A.T@B.T)

运行结果：

11
11
11
11

可以看出，Python里面向量没有转置的概念。

② 向量×二维数组

import numpy as np
#----向量×二维数组
A=np.array([1,2,3]) #向量，shape=(3,)
B=np.array([[2,3,1]]) #二维数组，shape=(3,1)
B=B.ravel() #二维数组转换成向量，shape=(3,)
print(A@B)
print(A@B.T)
print(A.T@B)
print(A.T@B.T)

    运行结果：

11
11
11
11

如果不将二维数组转换成向量，后面的程序会报错。  

广播机制参考链接：

python的广播机制详解_liming89的博客-CSDN博客_python广播机制