• numpy常用乘法函数总结：np.dot()、np.multiply()、*、np.matmul()、@、np.prod()、np.outer()

    numpy里的乘法函数非常多，容易弄混也容易忘，本文总结一下其中比较常见的乘法函数，便于自己查询记忆。下篇文章再总结一下Pytorch和TensorFlow里常用的乘法函数

    目录

    常用 

    np.dot()

    np.multiply() 或者 *【array下完全等价，mat/matrix下不同】

    np.multiply() 对比 *

    np.dot()、np.multiply()、* 小结

    np.matmul() 或者 @【完全等价】

    np.matmul() 对比 np.dot()

    不常用 

    np.prod()

    np.outer()

    附录

    点积、矩阵乘法

    np.array、np.matrix、np.mat

    参考

    常用 

    np.dot()

    功能：

    • 向量点积（若处理的是一维数组，则得到的是两数组的内积；标量也是直接相乘）
    • 矩阵乘法（若处理的是二维数组/矩阵，则得到的是矩阵积，即：若x是m*n矩阵，y是n*m矩阵，则结果为m*m矩阵）

    点积 和 矩阵乘法 的含义见附录

    写法：x.dot(y) 等价于 np.dot(x, y)

    1. import numpy as np
    2.  
    3. # 向量点积
    4. x=np.array([0,1,2,3,4])   # 等价于x=np.arange(0,5)
    5. y=x[::-1]   # [4,3,2,1,0]
    6. print(np.dot(x,y))  # 10
    7.  
    8. # 矩阵乘法
    9. x=np.arange(0,6).reshape(2,3)
    10. y=np.random.randint(0,10,size=(3,2))
    11. print(np.dot(x,y))   # (2,2)

    两种特殊情况： 

    （1）高维数组

    1. a = np.arange(6).reshape(1, 2, 3)
    2. b = np.arange(6).reshape(2, 3, 1)
    3.  
    4. a 
    5. >>> 
    6. array([[[0, 1, 2],
    7.         [3, 4, 5]]])
    8. b
    9. >>> 
    10. array([[[0],
    11.         [1],
    12.         [2]],
    13.  
    14.        [[3],
    15.         [4],
    16.         [5]]])
    17.  
    18. # 计算n维数组数组的点积
    19. np.dot(a, b)
    20. >>> 
    21. array([[[[5],
    22.          [14]],
    23.  
    24.         [[14],
    25.          [50]]]])   # (1, 2, 2, 1)

    （2）x为向量，y为矩阵

    1. import numpy as np
    2.  
    3. x=np.arange(0,5)   # shape为(5,)
    4. y=np.random.randint(0,10,size=(5,1))
    5. print(x)
    6. print(y)
    7. print(np.dot(x,y))   # 注意结果为[35]，而不是35

    扩展一下：

    1. import numpy as np
    2.  
    3. a = np.arange(6).reshape(1, 2, 3)
    4. '''
    5. [[[0 1 2]
    6.   [3 4 5]]]
    7. '''
    8. b = np.arange(0,3)   # [0 1 2]    shape为(3,)
    9. print(np.dot(a,b))   # [[ 5 14]]  shape为(1, 2)

    np.multiply() 或者 *【array下完全等价，mat/matrix下不同】

    两个数组对应位置进行相乘，参与运算的两个数组的shape、以及结果的shape均一致

    写法：np.multiply(x, y) 等价于 x*y（在输入为 np.array 类型时完全等价，但在输入为 np.mat 或np.matrix 类型时出现不同，后面会对比）

    1. import numpy as np
    2.  
    3. # 两个向量
    4. x=np.array([0,1,2,3,4])   # 等价于x=np.arange(0,5)
    5. y=x[::-1]   # [4,3,2,1,0]
    6. print(np.multiply(x,y))  # [0 3 4 3 0]
    7.  
    8. # 两个矩阵
    9. x=np.arange(0,6).reshape(2,3)
    10. y=np.random.randint(0,10,size=(2,3))
    11. print(x)
    12. print(y)
    13. print(np.multiply(x,y))   # (2,3)

    两种特殊情况：

    （1）x为向量，y为矩阵。如：x为(m, )，y为(m,1)，结果为(m,m)

    1. import numpy as np
    2.  
    3. x=np.arange(0,5)   # shape为(5,)
    4. y=np.random.randint(0,10,size=(5,1))
    5. print(x)
    6. print(y)
    7. print(np.multiply(x,y))  # 会自动广播

    （2）x和y都为矩阵但shape不同

    • 两者行数相同，且其中某个矩阵的列数为1。如：m*n 与 m*1 ＝ m*n
    • 两者列数相同，且其中某个矩阵的行数为1。如：m*n 与 1*n = m*n

    一句话总结， 这种情况下，数组会自适应按列相乘还是按行相乘

    1. import numpy as np
    2.  
    3. x=np.random.randint(0,10,size=(5,2))
    4. y=np.random.randint(0,10,size=(5,1))
    5. print(x)
    6. print(y)
    7. print(np.multiply(x,y))  # 5*2

    np.multiply() 对比 *

    在输入为np.array类型时，两者的功能都是元素对位相乘

    在输入为np.mat或np.matrix类型时，np.multiply()仍是元素对位相乘，而 * 变为了矩阵乘法

    np.array、np.matrix、np.mat 的区别见附录

    1. In [48]: a = np.matrix([[0, 1],
    2.         				[2, 3],
    3.         				[4, 5]])	#（3， 2）
    4. In [49]: b=np.matrix([[0],
    5. 					  [1]])			#（2， 1）
    6. # 出现不同！！！！
    7. In [50]: a*b
    8. Out[50]: 
    9. matrix([[1],
    10.         [3],
    11.         [5]])
    12.  
    13. In [51]: np.multiply(a,b)
    14. ---------------------------------------------------------------------------
    15. ValueError: operands could not be broadcast together with shapes (3,2) (2,1)

    np.dot()、np.multiply()、* 小结

    小结一下：

    • np.dot() 无论数据是array还是matrix都表示矩阵相乘
    • np.multiply() 无论数据是array或matrix都表示对应位置相乘
    • 如果数据类型为array，* 和 np.multiply() 表示对应位置相乘，np.dot() 表示矩阵相乘
    • 如果数据类型为matrix，np.multiply() 表示对应位置相乘，* 和 np.dot() 表示矩阵相乘

    np.matmul() 或者 @【完全等价】

    两个运算的矩阵需要满足矩阵乘法的规则（前一个矩阵的列与后一个矩阵的行相匹配）

    写法：np.matmul(x, y) 等价于 x@y （两者完全等价）

    1. import numpy as np
    2.  
    3. # 两个向量
    4. x=np.array([0,1,2,3,4])   # 等价于x=np.arange(0,5)
    5. y=x[::-1]   # [4,3,2,1,0]
    6. print(np.matmul(x,y))  # 10
    7.  
    8. # 两个矩阵
    9. x=np.arange(0,6).reshape(2,3)
    10. y=np.random.randint(0,10,size=(3,2))
    11. print(x)
    12. print(y)
    13. print(np.matmul(x,y))   # (2,2)

    一种特殊情况：x为向量，y为矩阵

    1. import numpy as np
    2.  
    3. x=np.arange(0,5)   # shape为(5,)
    4. y=np.random.randint(0,10,size=(5,1))
    5. print(x)
    6. print(y)
    7. print(np.matmul(x,y))   # 注意结果为[43]，而不是43

    np.matmul() 对比 np.dot()

    目前为止，np.matmul() 和 np.dot() 的功能一模一样，那么两者的区别在哪呢？

    差别有二：（1）np.matmul() 中禁止矩阵与标量的乘法；（2）在于2维以上的np.array

    （1）np.matmul() 无法用于标量与array相乘：

    1. In [113]: a=np.array([1,2,3])
    2.  
    3. In [114]: np.dot(a, 2)  # np.multiply(a,2) 和 a*2 结果一样
    4. Out[114]: array([2, 4, 6])
    5.  
    6. In [115]: np.matmul(a,2)
    7. ValueError: Scalar operands are not allowed, use '*' instead

    小结一下，np.dot()、np.multiply()、* 都能用于数组和标量相乘，np.matmul() 或 @ 不能

    （2）2维以上的np.array：

    执行np.matmul(x, y)时，若x的最后一个维度与y的倒数第二个维度不同，则报错。因为它是把数组的最后两个维度（组成矩阵）视为一个元素

    1. In [97]: a = np.array([[[ 0,  1,  2],
    2.         				[ 3,  4,  5]],
    3. 					   [[ 6,  7,  8],
    4.         				[ 9, 10, 11]]])	# (2, 2, 3)
    5.  
    6. In [98]: b = np.array([[[0, 1],
    7.         				[2, 3],
    8.         				[4, 5]]]) 		# (1, 3, 2)
    9.  
    10. In [99]: np.dot(a,b)
    11. Out[99]: 
    12. array([[[[10, 13]],
    13.         [[28, 40]]],
    14.         
    15.        [[[46, 67]],
    16.         [[64, 94]]]]) 		# (2, 2, 1, 2)
    17.  
    18.  
    19. In [101]: np.matmul(a,b)
    20. Out[101]: 
    21. array([[[10, 13],
    22.         [28, 40]],
    23.         
    24.        [[46, 67],
    25.         [64, 94]]]) 		# (2, 2, 2)  比dot少了一维

    np.matmul() 分别把数组的最后两个维度（组成矩阵）视为一个元素，并对其进行广播

    • 如上文中 b.shape：[1,3,2]，广播为[2,3,2]，再与a相乘。广播后两个数组matmul，即两个数组对应位置的矩阵相乘。在上面的例子中，最终结果分别由两对2 × 3 和 3 × 2 的矩阵乘法得到两个2 × 2矩阵，即2 × 2 × 2

    np.dot() 则对第一个数组的最后一个维度（行向量）以及第二个数组的倒数第二个维度（列向量）进行点积

    • 在上面的例子中，a可以看作2 × 2个行向量。b可以看作1 × 2个列向量。np.dot() 会将 a的每一个行向量 与 b的全部列向量 进行点积，每一个行向量都能得到一个二维数组，占据结果的后两维。属于同一个二维数组的行向量，得到的结果又合并为一个三维数组。这个三维数组又与其他二维数组的行向量得到的三维数组合并成四维数组

    再举个例子：

    1. In [105]: a = np.array([[[ 0,  1,  2],
    2.         				 [ 3,  4,  5]],
    3. 						[[ 6,  7,  8],
    4.         				 [ 9, 10, 11]]])	# (2, 2, 3)
    5.  
    6. In [106]: b = np.array([[[ 0,  1],
    7.         				 [ 2,  3],
    8.         				 [ 4,  5]],
    9. 						[[ 6,  7],
    10.         				 [ 8,  9],
    11.         				 [10, 11]]])		# (2, 3, 2)
    12.  
    13. In [107]: np.dot(a,b)   
    14. Out[107]: 
    15. array([[[[ 10,  13],
    16.          [ 28,  31]],
    17.  
    18.         [[ 28,  40],
    19.          [100, 112]]],
    20.  
    21.  
    22.        [[[ 46,  67],
    23.          [172, 193]],
    24.  
    25.         [[ 64,  94],
    26.          [244, 274]]]])		# (2, 2, 2, 2)
    27.          
    28. In [109]: np.matmul(a,b)
    29. Out[109]: 
    30. array([[[ 10,  13],
    31.         [ 28,  40]],
    32.  
    33.        [[172, 193],
    34.         [244, 274]]])		# (2, 2, 2) 比dot少了一维

    不常用 

    以下几个函数不太常用，需要用到的时候查一下，或者写个测试用例看看输出就行

    np.prod()

    功能：返回数组中所有元素的乘积

    1. import numpy as np
    2.  
    3. arr = np.array([1, 2, 3, 4])
    4. result = np.prod(arr)
    5. print(result)  # 输出 24，即 1*2*3*4 的结果

    也可以沿着指定的轴计算乘积。通过设置axis参数，可以指定沿着哪个轴进行乘积计算

    1. arr = np.array([[1, 2], [3, 4]])
    2. result = np.prod(arr, axis=0)  # axis=0是对每一列操作
    3. print(result)  # 输出 [3 8]，即 1*3 和 2*4 的结果

    np.prod() 还可以接受一个可选参数dtype，用于指定计算结果的数据类型

    np.outer()

    作用：计算两个向量的外积，拿第一个向量的元素分别与第二个向量所有元素相乘得到的结果的一行，以此类推

    参数：np.outer(x, y)

    • x和y都是向量，若输入不是一维的，会被展平
    • 输出满足：out[i, j] = x[i] * y[j]
    1. import numpy as np
    2.  
    3. # 数字
    4. lr = np.outer(np.ones((5,)),np.linspace(-2,2,5))
    5. lr
    6. >>>
    7. array([[-2., -1.,  0.,  1.,  2.],
    8.        [-2., -1.,  0.,  1.,  2.],
    9.        [-2., -1.,  0.,  1.,  2.],
    10.        [-2., -1.,  0.,  1.,  2.],
    11.        [-2., -1.,  0.,  1.,  2.]])
    12. 其中
    13. np.ones((5,))   # [1. 1. 1. 1. 1.]
    14. np.linspace(-2,2,5)   # [-2. -1.  0.  1.  2.]
    15.  
    16. # 数字加文本
    17. im = np.outer(1j*np.linspace(2,-2,5),np.ones((5,)))
    18. im
    19. >>>
    20. array([[0.+2.j, 0.+2.j, 0.+2.j, 0.+2.j, 0.+2.j],
    21.        [0.+1.j, 0.+1.j, 0.+1.j, 0.+1.j, 0.+1.j],
    22.        [0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j],
    23.        [0.-1.j, 0.-1.j, 0.-1.j, 0.-1.j, 0.-1.j],
    24.        [0.-2.j, 0.-2.j, 0.-2.j, 0.-2.j, 0.-2.j]])
    25. 其中
    26. 1j*np.linspace(2,-2,5)    # [ 0.+2.j,  0.+1.j,  0.+0.j, -0.-1.j, -0.-2.j]
    27.  
    28. grid = lr + im
    29. grid
    30. >>>
    31. array([[-2.+2.j, -1.+2.j,  0.+2.j,  1.+2.j,  2.+2.j],
    32.        [-2.+1.j, -1.+1.j,  0.+1.j,  1.+1.j,  2.+1.j],
    33.        [-2.+0.j, -1.+0.j,  0.+0.j,  1.+0.j,  2.+0.j],
    34.        [-2.-1.j, -1.-1.j,  0.-1.j,  1.-1.j,  2.-1.j],
    35.        [-2.-2.j, -1.-2.j,  0.-2.j,  1.-2.j,  2.-2.j]])
    36.  
    37. # 文本
    38. np.outer(np.array(['a','b','c']), [1,2,3])   # 这样写会报错
    39.  
    40. # 下面的写法才正确
    41. x = np.array(['a','b','c'], dtype=object)
    42. np.outer(x, [1,2,3])
    43. >>>
    44. [['a' 'aa' 'aaa']
    45.  ['b' 'bb' 'bbb']
    46.  ['c' 'cc' 'ccc']]

    特殊情况，若有一个输入为标量：

    1. np.outer(2, [1,2,3])  # [[2 4 6]]
    2.  
    3. # np.outer([2], [1,2,3])的结果也是一样的

    附录

    点积、矩阵乘法

    （1）点积：

    （2）矩阵乘法：

    np.array、np.matrix、np.mat

    np.array 是创建数组，必须自己手动输入数组；np.arange 可以产生一串数字，从而创建数组。使用 reshape 后可以将数组转换为矩阵

    • (12, )表示是数组，只有一个[ ]
    • (1, 12)是一维矩阵，左右各有两个[ ]

    np.matrix 可以使二维数组变为二维矩阵，使数组变为一维矩阵

    1. a = np.arange(12)
    2. print(a.shape) #(12,)
    3. #[ 0  1  2  3  4  5  6  7  8  9 10 11]
    4.  
    5. a = np.matrix(a)
    6. print(a.shape) #(1, 12)
    7. #[[ 0  1  2  3  4  5  6  7  8  9 10 11]]
    8.  
    9. c = np.matrix([[1,2,3,4,5,6],[7,8,9,10,11,12]], dtype=int)
    10. print(c)
    11. '''
    12. [[ 1  2  3  4  5  6]
    13.  [ 7  8  9 10 11 12]]
    14.  '''

    np.mat 也能使数组变为矩阵，与 np.matrix 的区别在于：

    使用np.mat后，如果对原数组进行改变，矩阵也会相应发生变化

    1. #创建ndarray二维数组
    2. x = np.array([[1, 2], [3, 4]])
    3.  
    4. #生成  矩阵
    5. m = np.mat(x)
    6.  
    7. #打印 m 矩阵
    8. print(m)
    9. '''
    10. [[1 2]
    11.  [3 4]]
    12. '''
    13.  
    14. x[0,0] = 0
    15. print(m)
    16. '''
    17. [[0 2]
    18.  [3 4]]
    19. '''

    但使用np.matrix后，如果对原数组进行改变，矩阵不会相应发生变化

    1. #创建ndarray二维数组
    2. x = np.array([[1, 2], [3, 4]])
    3.  
    4. #生成  矩阵
    5. m = np.matrix(x)
    6.  
    7. #打印 m 矩阵
    8. print(m)
    9. '''
    10. [[1 2]
    11.  [3 4]]
    12. '''
    13.  
    14. x[0,0] = 0
    15. print(m)
    16. '''
    17. [[1 2]
    18.  [3 4]]
    19. '''

    参考

    np.dot()函数用法-CSDN博客

    【Numpy乘法详解】np.multiply()、np.matmul()、np.dot()等-CSDN博客

    numpy——np.array、np.matrix、np.mat的区别及（*）、np.multiply、np.dot乘法的区别_np.mat * 与np.dot()-CSDN博客

  • 相关阅读:
    day44（（VueJS）路由的懒加载使用 路由的元信息（meta） 路由守卫函数 vant组件库的应用）
    HAproxy负载均衡集群
    ps打开图片的三种方式 同步部分基本操作方式
    飞桨EasyDL图像分类：AI自动识别车辆类型
    2022-6-24 我的日程安排表II，掉落的方块
    Go语言excelize包-03-行和列操作（可见性、指定列宽、指定行高、列删除、行删除、插入列、插入行、分级显示）
    Ubuntu-基础工具配置
    【AI视野·今日Robot 机器人论文速览 第三十九期】Fri, 22 Sep 2023
    Kubernetes——PV与PVC
    【Nginx27】Nginx学习：代理模块（一）基本配置与概念
  • 原文地址：https://blog.csdn.net/qq_43629945/article/details/138086868