numpy矩阵运算

两种矩阵形式matrix和array

a=np.matrix('1,2;3,4')
b=np.array([[1,2],[3,4]])

# 输出
# [[1 2]
#  [3 4]]

为了区分三种乘法运算的规则,具体分析如下:

import numpy as np
 
 

    1. np.multiply()函数

    函数作用

    数组和矩阵对应位置相乘,输出与相乘数组/矩阵的大小一致

    1.1数组场景
    A = np.arange(1,5).reshape(2,2)
    A
     
     
      array([[1, 2],
             [3, 4]])
      
       
       
        B = np.arange(0,4).reshape(2,2)
        B
         
         
          array([[0, 1],
                 [2, 3]])
          
           
           
            np.multiply(A,B)       #数组对应元素位置相乘
             
             
              array([[ 0,  2],
                     [ 6, 12]])
              
               
               
                1.2 矩阵场景
                np.multiply(np.mat(A),np.mat(B))     #矩阵对应元素位置相乘,利用np.mat()将数组转换为矩阵
                 
                 
                  matrix([[ 0,  2],
                          [ 6, 12]])
                  
                   
                   
                    np.sum(np.multiply(np.mat(A),np.mat(B)))    #输出为标量
                     
                     
                      20
                      
                       
                       

                        2. np.dot()函数

                        函数作用

                        对于秩为1的数组,执行对应位置相乘,然后再相加;

                        对于秩不为1的二维数组,执行矩阵乘法运算;超过二维的可以参考numpy库介绍。

                        2.1 数组场景

                        2.1.1 数组秩不为1的场景

                        A = np.arange(1,5).reshape(2,2)
                        A
                         
                         
                          array([[1, 2],
                                 [3, 4]])
                          
                           
                           
                            B = np.arange(0,4).reshape(2,2)
                            B
                             
                             
                              array([[0, 1],
                                     [2, 3]])
                              
                               
                               
                                np.dot(A,B)    #对数组执行矩阵相乘运算
                                 
                                 
                                  array([[ 4,  7],
                                         [ 8, 15]])
                                  
                                   
                                   

                                    2.1.2 数组秩为1的场景

                                    C = np.arange(1,4)
                                    C
                                     
                                     
                                      array([1, 2, 3])
                                      
                                       
                                       
                                        D = np.arange(0,3)
                                        D
                                         
                                         
                                          array([0, 1, 2])
                                          
                                           
                                           
                                            np.dot(C,D)   #对应位置相乘,再求和
                                             
                                             
                                              8
                                              
                                               
                                               

                                                2.2 矩阵场景

                                                np.dot(np.mat(A),np.mat(B))   #执行矩阵乘法运算
                                                 
                                                 
                                                  matrix([[ 4,  7],
                                                          [ 8, 15]])
                                                  
                                                   
                                                   

                                                    3. 星号(*)乘法运算

                                                    作用

                                                    对数组执行对应位置相乘

                                                    对矩阵执行矩阵乘法运算

                                                    3.1 数组场景
                                                    A = np.arange(1,5).reshape(2,2)
                                                    A
                                                     
                                                     
                                                      array([[1, 2],
                                                             [3, 4]])
                                                      
                                                       
                                                       
                                                        B = np.arange(0,4).reshape(2,2)
                                                        B
                                                         
                                                         
                                                          array([[0, 1],
                                                                 [2, 3]])
                                                          
                                                           
                                                           
                                                            A*B  #对应位置点乘
                                                             
                                                             
                                                              array([[ 0,  2],
                                                                     [ 6, 12]])
                                                              
                                                               
                                                               

                                                                3.2矩阵场景

                                                                (np.mat(A))*(np.mat(B))  #执行矩阵运算
                                                                 
                                                                 
                                                                  matrix([[ 4,  7],
                                                                          [ 8, 15]])
                                                                  

                                                                  4.matmul函数

                                                                  要获得矩阵乘积,你可以使用 NumPy 的 matmul 函数。

                                                                  如果你有兼容的形状,那就像这样简单:

                                                                  a = np.array([[1,2,3,4],[5,6,7,8]])
                                                                  a
                                                                  # 显示以下结果:
                                                                  # array([[1, 2, 3, 4],
                                                                  #        [5, 6, 7, 8]])
                                                                  a.shape
                                                                  # 显示以下结果:
                                                                  # (2, 4)
                                                                  
                                                                  b = np.array([[1,2,3],[4,5,6],[7,8,9],[10,11,12]])
                                                                  b
                                                                  # 显示以下结果:
                                                                  # array([[ 1,  2,  3],
                                                                  #        [ 4,  5,  6],
                                                                  #        [ 7,  8,  9],
                                                                  #        [10, 11, 12]])
                                                                  b.shape
                                                                  # 显示以下结果:
                                                                  # (4, 3)
                                                                  
                                                                  c = np.matmul(a, b)
                                                                  c
                                                                  # 显示以下结果:
                                                                  # array([[ 70,  80,  90],
                                                                  #        [158, 184, 210]])
                                                                  c.shape
                                                                  # 显示以下结果:
                                                                  # (2, 3)
                                                                   
                                                                   

                                                                    如果你的矩阵具有不兼容的形状,则会出现以下错误:

                                                                    np.matmul(b, a)
                                                                    # 显示以下错误:
                                                                    # ValueError: shapes (4,3) and (2,4) not aligned: 3 (dim 1) != 2 (dim 0)
                                                                     
                                                                     

                                                                      有时候,在你以为要用 matmul 函数的地方,你可能会看到 NumPy 的 dot 函数。事实证明,如果矩阵是二维的,那么 dotmatmul 函数的结果是相同的。

                                                                      所以这两个结果是等价的:

                                                                      a = np.array([[1,2],[3,4]])
                                                                      a
                                                                      # 显示以下结果:
                                                                      # array([[1, 2],
                                                                      #        [3, 4]])
                                                                      
                                                                      np.dot(a,a)
                                                                      # 显示以下结果:
                                                                      # array([[ 7, 10],
                                                                      #        [15, 22]])
                                                                      
                                                                      a.dot(a)  # you can call你可以直接对 `ndarray` 调用 `dot` 
                                                                      # 显示以下结果:
                                                                      # array([[ 7, 10],
                                                                      #        [15, 22]])
                                                                      
                                                                      np.matmul(a,a)
                                                                      # array([[ 7, 10],
                                                                      #        [15, 22]])
                                                                       
                                                                       

                                                                        虽然这两个函数对于二维数据返回相同的结果,但在用于其他数据形状时,你应该谨慎选择。你可以在 matmuldot 文档中详细了解它们的差异,并找到其他 NumPy 函数的链接。

                                                                        5.三、四维矩阵相乘

                                                                        通过具体例子理解。
                                                                        例1,三维数组相乘

                                                                        import numpy as np
                                                                        a=np.zeros((2,2,2))
                                                                        a[:,:,0]=([[3,6],[5,8]])
                                                                        a[:,:,1]=([[2,5],[7,2]])
                                                                        b=np.zeros((2,2,2))
                                                                        b[:,:,0]=([[3,2],[9,6]])
                                                                        b[:,:,1]=([[7,8],[1,0]])
                                                                        c=a*b
                                                                         
                                                                         

                                                                          则三维矩阵a、b的两页分别是:

                                                                          在这里插入图片描述

                                                                          则c=a*b为a、b的两页分别相乘 (注意:这里是点乘),得结果为

                                                                          在这里插入图片描述

                                                                          可看出c的维数为(2,2,2)。
                                                                          例2,四维数组相乘

                                                                          import numpy as np
                                                                          a=np.zeros((2,2,2,2))
                                                                          a[:,:,0,0]=([[0,8],[3,6]])
                                                                          a[:,:,0,1]=([[5,1],[4,7]])
                                                                          a[:,:,1,0]=([[9,2],[5,7]])
                                                                          a[:,:,1,1]=([[2,0],[3,9]])
                                                                          b=np.zeros((2,1,1,2))
                                                                          b[:,0,0,0]=([3,2])
                                                                          b[:,0,0,1]=([9,4])
                                                                          c=a*b
                                                                           
                                                                           

                                                                            自定义称第四维为张,则四维矩阵a、b对应的不同张、页分别是:

                                                                            在这里插入图片描述

                                                                            将a的每张每页与b的每张每页对应相乘 (注意:这里仍是点乘),b在由两行一列补成了两行两列进行相乘。

                                                                            在这里插入图片描述
                                                                            c的维度为(2,2,2,2)。

                                                                            参考博文:
                                                                            https://blog.youkuaiyun.com/zenghaitao0128/article/details/78715140
                                                                            https://blog.youkuaiyun.com/u013645510/article/details/53808514
                                                                            https://blog.youkuaiyun.com/u012300744/article/details/80423135

                                                                            评论
                                                                            添加红包

                                                                            请填写红包祝福语或标题

                                                                            红包个数最小为10个

                                                                            红包金额最低5元

                                                                            当前余额3.43前往充值 >
                                                                            需支付:10.00
                                                                            成就一亿技术人!
                                                                            领取后你会自动成为博主和红包主的粉丝 规则
                                                                            hope_wisdom
                                                                            发出的红包
                                                                            实付
                                                                            使用余额支付
                                                                            点击重新获取
                                                                            扫码支付
                                                                            钱包余额 0

                                                                            抵扣说明:

                                                                            1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
                                                                            2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

                                                                            余额充值