np.dot、np.outer、np.matmul、np.multipy、np.inner、np.outer与np.cross几个函数之间的区别

  • 一、数学上关于【内积】、【外积】的定义和计算
    • 1.1 数学上关于【内积/数量积】的定义和计算
    • 1.2 数学上关于【外积/叉积】的定义和计算
  • 二、numpy中关于np.dot、np.outer、np.matmul、np.multipy、np.inner、np.outer与np.cross几个函数之间的区别
    • 2.1、np.dot()函数
    • 2.2 numpy.outer()计算两个向量的外积
    • 2.3. np.matmul()计算两个矩阵的乘积
    • 2.4. np.multiply()计算两数组各对应位置对应元素的乘积
    • 2.5. 运算符“*”在numpy中的应用
    • 2.5 np.cross()计算两个数组或向量的叉积

一、数学上关于【内积】、【外积】的定义和计算

1.1 数学上关于【内积/数量积】的定义和计算

向量的点乘，也叫做向量的内积、数量积。对两个向量执行点乘运算，就是对着两个向量对应位置一一相乘之后求和的操作，点乘的结果是一个标量。

定义： 两个向量 aaa 与bbb 的内积为 a∙b=∣a∣∣b∣cos∠(a,b)a\bullet b = |a||b|cos∠(a, b)a∙b=∣a∣∣b∣cos∠(a,b)，特别地，0∙a=a∙0=00\bullet a =a\bullet 0 = 00∙a=a∙0=0；若a，ba，ba，b是非零向量，则 aaa 与 bbb 正交的充要条件是a∙b=0a \bullet b = 0a∙b=0。

点乘公式

对于向量 aaa 和向量 bbb：
a=[a1,a2,...,an]和b=[b1,b2,...,bn]a=[a_1,a_2,...,a_n]和b=[b_1,b_2,...,b_n]a=[a1​,a2​,...,an​]和b=[b1​,b2​,...,bn​]

aaa 和 bbb 的点乘公式：

a∙b=aTb=∑i=1naibi=a1b1+a2b2+...anbn\mathbf{a}\bullet\mathbf{b}=\mathbf{a}^T\mathbf{b}=\sum_{i=1}^na_ib_i=a_1b_1+a_2b_2+...a_nb_na∙b=aTb=i=1∑n​ai​bi​=a1​b1​+a2​b2​+...an​bn​

要求：一维向量aaa 和向量 bbb 的行列数相同。

点乘的几何意义：

可以用来表征或计算两个向量之间的夹角，以及在b向量在a向量方向上的投影，有公式：
a∙b=∣a∣∣b∣cosθa\bullet b=|a||b|cos\thetaa∙b=∣a∣∣b∣cosθ

根据这个公式就可以计算向量a和向量b之间的夹角。从而就可以进一步判断这两个向量是否是同一方向，是否正交(也就是垂直)等方向关系，具体对应关系为：

  • a∙b>0a\bullet b>0a∙b>0，方向基本相同，夹角在0°到90°之间；
  • a∙b=0a\bullet b=0a∙b=0，正交，相互垂直；
  • a∙b<0a \bullet b<0a∙b<0，方向基本相反，夹角在90°到180°之间。

向量点乘的运算特性：

  1. a2≥0a^2 ≥ 0a2≥0；当a2=0a^2 = 0a2=0时，必有a=0a = 0a=0； （正定性）
  2. a∙b=b∙a；a\bullet b = b\bullet a；a∙b=b∙a；（对称性）
  3. (λa+μb)∙c=λa∙c+μb∙c(λa + μb)\bullet c = λa\bullet c + μb\bullet c(λa+μb)∙c=λa∙c+μb∙c，对任意实数λ,μλ, μλ,μ成立； （线性）
  4. cos∠(a,b)=a∙b/(∣a∣∣b∣)cos∠(a,b) =a\bullet b/(|a||b|)cos∠(a,b)=a∙b/(∣a∣∣b∣)；
  5. ∣a⋅b∣≤∣a∣∣b∣|a·b| ≤ |a||b|∣a⋅b∣≤∣a∣∣b∣，等号只在aaa与bbb共线时成立。

1.2 数学上关于【外积/叉积】的定义和计算

两个向量的叉乘，又叫向量积、外积、叉积，叉乘的运算结果是一个向量而不是一个标量。并且两个向量的叉积与这两个向量组成的坐标平面垂直。

定义： 向量 aaa 与 bbb 的外积 a×ba×ba×b 是一个向量，其长度等于∣a×b∣=∣a∣∣b∣sin∠(a,b)|a×b| = |a||b|sin∠(a,b)∣a×b∣=∣a∣∣b∣sin∠(a,b)，其方向正交于aaa与bbb。并且，向量(a,b,a×b)(a, b, a×b)(a,b,a×b)构成右手系。

对于向量 aaa 和向量 bbb：
a=(x1,y1,z1)a=(x_1,y_1,z_1)a=(x1​,y1​,z1​)
b=(x2,y2,z2)b=(x_2,y_2,z_2)b=(x2​,y2​,z2​)

aaa 和 bbb 的叉乘公式：

其中，i=(1,0,0),j=(0,1,0),k=(0,0,1)i=(1,0,0)\quad, j=(0,1,0)\quad ,k=(0,0,1)\quadi=(1,0,0),j=(0,1,0),k=(0,0,1)
根据 i,j,ki,j,ki,j,k 之间的关系，有：
a×b=(y1z2−y2z1,−(x1z2−x2z1),x1y2−x2y1)\mathbf{a}×\mathbf{b}=(y_1z_2-y_2z_1,-(x_1z_2-x_2z_1),x_1y_2-x_2y_1)a×b=(y1​z2​−y2​z1​,−(x1​z2​−x2​z1​),x1​y2​−x2​y1​)

叉乘的几何意义：

  • 在三维几何中，向量 aaa 和向量 bbb 的叉乘结果是一个向量，更为熟知的叫法是【法向量】，该向量垂直于aaa 和 bbb 向量构成的平面。

叉乘的运算特性：

  1. b×a=−a×bb×a=-a×bb×a=−a×b（反称性）
  2. 特别地，0×a=a×0=00×a = a×0 = 00×a=a×0=0；此外，对任意向量aaa，a×a=0a×a=0a×a=0。
  3. (λa+μb)×c=λ(a×c)+μ(b×c)(λa + μb) × c = λ(a ×c) + μ(b ×c)(λa+μb)×c=λ(a×c)+μ(b×c) （线性）。

在3D图像学中，叉乘的概念非常有用，可以通过两个向量的叉乘，生成第三个垂直于a，b的法向量，从而构建X、Y、Z坐标系。如下图所示：

插图参考链接：矩阵外积与内积

  • 在二维空间中，叉乘还有另外一个几何意义就是：a×b=a×b=a×b= 由向量 aaa 和向量 bbb 构成的平行四边形的面积。

  • 一个行向量乘以一个列向量称作向量的【内积】，又叫做【点积】，结果是一个数；

  • 一个列向量乘以一个行向量称作向量的【外积】，结果是一个矩阵；

假设 aTa^TaT 和 bbb 分别是一个行向量和一个列向量，那么内积、外积分别记作aT⋅ba^T·baT⋅b 和b⊗aTb \otimes a^Tb⊗aT ，为了方便讨论，假设每个向量的长度为2。

aT⋅b=a1b1+a2b2a^T·b=a_1b_1+a_2b_2aT⋅b=a1​b1​+a2​b2​
b⊗aT=(b1a1b1a2b2a1b2a2)(2)b \otimes a^T=\left( \begin{matrix} b_1a_1 & b_1a_2\\ b_2a_1 & b_2a_2 \\ \end{matrix} \right) \tag{2}b⊗aT=(b1​a1​b2​a1​​b1​a2​b2​a2​​)(2)

二、numpy中关于np.dot、np.outer、np.matmul、np.multipy、np.inner、np.outer与np.cross几个函数之间的区别

2.1、np.dot()函数

numpy.dot(a, b, out=None)两个数组的点积。

np.dot()计算规则：np.dot(a, b, out=None)：

  1. 若aaa, bbb 为一维（1-D维）数组，则 a∙ba\bullet ba∙b = 向量的内积；
  2. 若aaa, bbb 为二维（2-D维）数组，则 a∙ba\bullet ba∙b = 矩阵的乘法（等效于矩阵乘法函数matmul(a,b)或者a@b）；
  3. 若aaa 或 bbb 为零维（0-D维）数组（即：标量），则 a∙ba\bullet ba∙b = 逐元素的乘法（等效于两数组对应位的元素相乘multiply(a,b)或者a*b）；
  4. 若aaa 为 nnn 维（n-D维）数组，且bbb 是 111 维（1-D维）数组，则 a∙ba\bullet ba∙b = aaa 的最后一个轴向与 bbb 的乘积和；
  5. 若aaa 为 nnn 维（n-D维）数组，且bbb 是 MMM 维（M-D维）数组（其中M>=2M>=2M>=2），则 a∙ba\bullet ba∙b = aaa 的最后一个轴向与 bbb 的倒数第二个轴向的乘积和。

备注：在情形⑤中，dot(a,b)dot(a, b)dot(a,b)的结果满足如下公式：
dot(a,b)[i,j,k,m]=sum(a[i,j,:]∗b[k,:,m])dot(a, b)[i,j,k,m] = sum(a[i,j,:] * b[k,:,m])dot(a,b)[i,j,k,m]=sum(a[i,j,:]∗b[k,:,m])
注意事项： 如果 aaa 的最后一个维度与 bbb 的倒数第二个维度的大小不同，则在计算 dot(a,b)dot(a, b)dot(a,b) 时，将报错ValueError。

一、一维数组
np.dot(3, 4)
>>>
12
np.dot([2, 3], [4, 4])
>>>
20
二、二维数组
a = [[1, 0], [0, 1]]
b = [[4, 1], [2, 2]]
np.dot(a, b)
>>>
array([[4, 1],[2, 2]])
三、n维数组
a = np.arange(6).reshape(1, 2, 3)
b = np.arange(6).reshape(2, 3, 1)
a
>>>
array([[[0, 1, 2],[3, 4, 5]]])
b
>>>
array([[[0],[1],[2]],[[3],[4],[5]]])
# 计算n维数组数组的点积
np.dot(a, b)
>>>
array([[[[ 5],[14]],[[14],[50]]]])

2.2 numpy.outer()计算两个向量的外积

numpy.outer(a, b, out=None)计算两个向量的外积。

np.outer()表示的是两个向量相乘，拿第一个向量的元素分别与第二个向量所有元素相乘得到结果的一行。

给定两个向量， a=[a0,a1,...,aM]a = [a_0, a_1, ..., a_M]a=[a0​,a1​,...,aM​] 和 b=[b0,b1,...,bN]b = [b_0, b_1, ..., b_N]b=[b0​,b1​,...,bN​] ，np.outer(a,b)输出：

[[a0*b0  a0*b1 ... a0*bN ][a1*b0    .[ ...          .[aM*b0            aM*bN ]]

参数：

  • a（m，）数组
    第一个输入向量。如果输入不是一维的，则将被展平。

  • b（n）
    第二输入向量。如果输入不是一维的，则将被展平。

  • out（m，n）ndarray，可选。np.outer(a,b)输出满足：out[i,j]=a[i]∗b[j]out[i, j] = a[i] * b[j]out[i,j]=a[i]∗b[j]

典型范例：

import numpy as nplr = np.outer(np.ones((5,)),np.linspace(-2,2,5))
lr
>>>
array([[-2., -1.,  0.,  1.,  2.],[-2., -1.,  0.,  1.,  2.],[-2., -1.,  0.,  1.,  2.],[-2., -1.,  0.,  1.,  2.],[-2., -1.,  0.,  1.,  2.]])
其中，
np.ones((5,))
>>>
array([1., 1., 1., 1., 1.])np.linspace(-2,2,5)
>>>
array([ 2.,  1.,  0., -1., -2.])im = np.outer(1j*np.linspace(2,-2,5),np.ones((5,)))
im
>>>
array([[0.+2.j, 0.+2.j, 0.+2.j, 0.+2.j, 0.+2.j],[0.+1.j, 0.+1.j, 0.+1.j, 0.+1.j, 0.+1.j],[0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j],[0.-1.j, 0.-1.j, 0.-1.j, 0.-1.j, 0.-1.j],[0.-2.j, 0.-2.j, 0.-2.j, 0.-2.j, 0.-2.j]])
其中，
1j*np.linspace(2,-2,5)    # 可将【1j】看做一个【有系数项的向量】，【*np.linspace(2,-2,5)】相当于改变该向量的【系数项】
>>>
array([ 0.+2.j,  0.+1.j,  0.+0.j, -0.-1.j, -0.-2.j])grid = lr + im
grid
>>>
array([[-2.+2.j, -1.+2.j,  0.+2.j,  1.+2.j,  2.+2.j],[-2.+1.j, -1.+1.j,  0.+1.j,  1.+1.j,  2.+1.j],[-2.+0.j, -1.+0.j,  0.+0.j,  1.+0.j,  2.+0.j],[-2.-1.j, -1.-1.j,  0.-1.j,  1.-1.j,  2.-1.j],[-2.-2.j, -1.-2.j,  0.-2.j,  1.-2.j,  2.-2.j]])
# 使用字母”矢量“的示例：
np.outer(np.array(['a','b','c']), [1,2,3])
>>>
x = np.array(['a','b','c'], dtype=object)
x
>>>
array(['a', 'b', 'c'], dtype=object)  # 备注：np.array(['a','b','c'])输出：array(['a', 'b', 'c'], dtype='<U1')无法参与运算np.outer(x, [1,2,3])
>>>
array([['a', 'aa', 'aaa'],['b', 'bb', 'bbb'],['c', 'cc', 'ccc']], dtype=object)

参考链接：官方教程numpy.outer(a, b, out=None)

2.3. np.matmul()计算两个矩阵的乘积

np.matmul(X1,X2X_1, X_2X1​,X2​, out=None)计算两个数组的矩阵乘积。

给定两个数组， X1=(n,k)X_1 = (n,k)X1​=(n,k) 和 X2=(k,m)X_2 = (k,m)X2​=(k,m) ，np.outer(a,b)输出：

参数：

  • X1，X2X_1，X_2X1​，X2​为array_like，是输入数组，不允许使用标量。
  • outoutout为n−Dn-Dn−D维数组，可选。

X1，X2X_1，X_2X1​，X2​与outoutout的shape必须满足如下关系：(n,k),(k,m)→(n,m)(n,k),(k,m)→(n,m)(n,k),(k,m)→(n,m)；只有当X1，X2X_1，X_2X1​，X2​都是一维向量时，outoutout才是一个标量。

备注：执行np.matmul(X1,X2X_1, X_2X1​,X2​)时，如果X1X_1X1​)的最后一个维度与X2X_2X2​ 的倒数第二个维度不同，则报错ValueError。

a = np.ones([9, 5, 7, 4])
c = np.ones([9, 5, 4, 3])
np.dot(a, c).shape
>>>
(9, 5, 7, 9, 5, 3)
np.matmul(a, c).shape
>>>
(9, 5, 7, 3)
# n is 7, k is 4, m is 3

2.4. np.multiply()计算两数组各对应位置对应元素的乘积

np.matmul(X1,X2X_1, X_2X1​,X2​, out=None)计算对应元素的乘积。

np.matmul(X1,X2X_1, X_2X1​,X2​) 结果等价于x1∗x2x1 * x2x1∗x2 的阵列广播。

参数：

  • X1，X2X_1，X_2X1​，X2​为array_like，是要相乘的输入数组；

如果 x1.shape != x2.shape ，它们必须根据广播运算规则扩展至公共形状方可（成为输出的形状）。

  • outoutout为 n−Dn-Dn−D数组，如果提供，它必须具有输入广播后的形状。如果未提供或没有，则返回新分配的数组。
np.multiply(2.0, 4.0)
>>>
8.0x1 = np.arange(9.0).reshape((3, 3))
x2 = np.arange(3.0)
np.multiply(x1, x2)
>>>
array([[  0.,   1.,   4.],[  0.,   4.,  10.],[  0.,   7.,  16.]])
等价运算
x1 = np.arange(9.0).reshape((3, 3))
x2 = np.arange(3.0)
x1 * x2
>>>
array([[  0.,   1.,   4.],[  0.,   4.,  10.],[  0.,   7.,  16.]])

2.5. 运算符“*”在numpy中的应用

运算符*表示对于元素的乘积，必须满足 numpy 的 broadcasting（广播) 的原则 。 当两个矩阵相乘时，其法则为两矩阵的对应的元素相乘，其用法与np.multiply()相同。

备注：关于numpy中广播的计算规则，参考我的另一篇博文——numpy的广播机制的计算原理详解

典型范例：

例1:矩阵 a*b 相乘，其中 a 为 3*4，b 为 1*4；a = np.array([[1,2,3,4],[5,6,7,8],[9,10,11,12]])
b = np.array([1,2,3,4])
c = a*b
print(c)
>>>
[[ 1  4  9 16][ 5 12 21 32][ 9 20 33 48]]例2:矩阵 a，b 相乘，其中 a 为 3*4，b 为 3*1；import numpy as np
a = np.array([[1,2,3,4],[5,6,7,8],[9,10,11,12]])
d = np.array([[1],[2],[3]])
e = a*d
print(e)
>>>
[[ 1  2  3  4][10 12 14 16][27 30 33 36]]

2.5 np.cross()计算两个数组或向量的叉积

np.cross(a, b, axisa=- 1, axisb=- 1, axisc=- 1, axis=None)计算两个数组或向量的叉积

几何含义： 数组或向量a 和 b的叉积 np.cross(a,b)表示的是垂直于两向量 a、b所在平面的法向量 。

np.cross(a, b)的结果满足aaa 和 bbb 的叉乘公式：

其中，i=(1,0,0),j=(0,1,0),k=(0,0,1)i=(1,0,0)\quad, j=(0,1,0)\quad ,k=(0,0,1)\quadi=(1,0,0),j=(0,1,0),k=(0,0,1)
根据 i,j,ki,j,ki,j,k 之间的关系，有：
a×b=(y1z2−y2z1,−(x1z2−x2z1),x1y2−x2y1)\mathbf{a}×\mathbf{b}=(y_1z_2-y_2z_1,-(x_1z_2-x_2z_1),x_1y_2-x_2y_1)a×b=(y1​z2​−y2​z1​,−(x1​z2​−x2​z1​),x1​y2​−x2​y1​)

x = [1, 2, 3]
y = [4, 5, 6]
np.cross(x, y)
>>>
array([-3,  6, -3])

参考链接：官方教程numpy.cross

np.dot、np.outer、np.matmul、np.multipy、np.inner、np.outer与np.cross几个函数之间的区别相关推荐

  1. 【Numpy乘法详解】np.multiply()、np.matmul()、np.dot()等

    [Numpy乘法详解(代码示例)]np.multiply().np.matmul().np.dot()等 文章目录 [Numpy乘法详解(代码示例)]np.multiply().np.matmul() ...

  2. python Numpy 中的矩阵向量乘法（np.multiply（）、np.dot（）、np.matmul() 和 星号（*）、@）

    python Numpy 中的矩阵向量乘法 总结 1. 对于 np.array 对象 1.1 元素乘法 用 a*b 或 np.multiply(a,b) 1.2 矩阵乘法 用 np.dot(a,b) ...

  3. python中使用numpy包的向量矩阵相乘np.dot和np.matmul

    一直对np的线性运算不太清晰,正好上课讲到了,做一个笔记整个理解一下 1.向量和矩阵 在numpy中,一重方括号表示的是向量vector,vector没有行列的概念.二重方括号表示矩阵matrix,有 ...

  4. Numpy中矩阵向量乘法np.dot()及np.multiply()以及*区别

    Numpy中的矩阵向量乘法分别是np.dot(a,b).np.multiply(a,b) 以及*,刚开始接触的时候比较模糊,于是自己整理了一下.先来介绍理论,然后再结合例子深入了解一下. 数组 矩阵 ...

  5. python中np.multiply（）、np.dot（）和星号（*）三种乘法运算的区别

    1. np.dot() 对类型为 ndarray 的数据: 一维情况:为点乘,即对应元素相乘再相加 二维情况:矩阵乘法 对类型为 matrix 的数据:矩阵乘法 一个二维数组跟一个大小合适的一维数组的 ...

  6. np.dot()函数用法(亲测矩阵算法)

    Numpy中dot()函数主要功能有两个:向量点积和矩阵乘法. 格式:x.dot(y) 等价于 np.dot(x,y) ---x是m*n 矩阵 ,y是n*m矩阵,则x.dot(y) 得到m*m矩阵. ...

  7. python3 numpy中矩阵np.dot(a,b)乘法运算

    python np.dot(a,b)乘法运算 首先我们知道矩阵运算是不满足交换律的,np.dot(a, b)与np.dot(b, a)是不一样的 另外np.dot(a,b)和a.dot(b)果是一样的 ...

  8. numpy中的*(矩阵对应位置元素相乘)和np.dot(矩阵执行矩阵乘法运算)

    注意矩阵乘法运算中的"*"和"np.dot()"是不一样的. "*"的意思是给定一个大小为(4,3)的矩阵A和一个大小为(4,3)的矩阵B, ...

  9. Python中的几种乘法np.dot,np.multiply,*

    使用array时,运算符 * 用于计算数量积(点乘),函数 dot() 用于计算矢量积(叉乘). 使用matrix时,运算符 * 用于计算矢量积,函数multiply() 用于计算数量积. 下面是使用 ...

  10. 向量点乘与差乘的区别，以及python下np.dot函数

    点乘: 点乘的结果是一个实数 a·b=|a|·|b|·cosx x为a,b的夹角 结果为数,且为标量 例: A=[a1,a2,a3],B=[b1,b2,b3] A·B=a1b1+a2b2+a3b3 叉 ...

最新文章

  1. 我们期待的TensorFlow 2.0还有哪些变化？
  2. 量子计算机混战：新贵离子 vs 老派超导体
  3. vsftp421问题
  4. android的shadowRadius属性说明
  5. python实例 85，86
  6. SharePoint 2007 SP2 发布
  7. win7桌面图片不显示缩略图问题
  8. 蓝桥杯枚举+判断结果填空：猜年龄/奇妙数字
  9. java 切换系统输入法_系统语言改变时，输入法变成默认输入法分析
  10. 设置vscode默认终端为msys/MinGW32/MinGW64
  11. Android开发—三种动画实现原理及使用
  12. Qgis教程09：高程栅格数据
  13. 音乐音频 | openSMILE提取音频需要掌握的知识
  14. dell服务器维修过程
  15. c语言经典程序100例 九宫格,9X9，九宫格测试，C编程。
  16. 盛邦安全创始人权晓文入选IDC中国CSO名人堂十大人物
  17. uClinux 内核编译常见错误及解决方法(zt)
  18. html生成海报图片
  19. 一个在台积电工作3年的工程师写给学弟学妹们的信[转]
  20. 原生js写仿微信语音发送

热门文章

  1. linux系统火狐浏览器升级,小菜鸡deepin系统手动更新火狐浏览器
  2. 空间数据格式转换之MapInfo mid/mif文件转ArcGIS shpfile文件
  3. python 归一化方法
  4. 微信小程序商城项目实战(第三篇:商品列表)
  5. java调用Shell脚本
  6. idea打包docker镜像
  7. C++封装Mysql数据库
  8. 黑客帝国“01”瀑布流C++
  9. T100服务端接口开发步骤
  10. 两种方式实现序列检测：三段式状态机、移位寄存器+比较器（含testbench激励代码）