精华内容
参与话题
问答
  • 1. 当为array的时候,默认d*f就是对应元素的乘积,multiply也是对应元素的乘积,dot(d,f)会转化为矩阵的乘积, dot点乘意味着相加,而multiply只是对应元素相乘,不相加2. 当为mat的时候,默认d*f就是矩阵的乘积,...

    1. 当为array的时候,默认d*f就是对应元素的乘积,multiply也是对应元素的乘积,dot(d,f)会转化为矩阵的乘积, dot点乘意味着相加,而multiply只是对应元素相乘,不相加

    2. 当为mat的时候,默认d*f就是矩阵的乘积,multiply转化为对应元素的乘积dot(d,f)为矩阵的乘积


              


    3. 混合时候的情况,一般不要混合

      混合的时候默认按照矩阵乘法的, multiply转化为对应元素的乘积dot(d,f)为矩阵的乘积


    总结, 数组乘法默认的是点乘,矩阵默认的是矩阵乘法,混合在一起默认的矩阵乘法,multiply转化为对应元素的乘积,dot(d,f)会转化为矩阵的乘积,注意,像multiply不满足对应元素时,按照广播是方式进行。

     
    展开全文
  • 总的来说,np.multiply()和*的作用是一样的,np.dot() 和np.matmul()作用是一样的。 1. np.multiply()函数 —— 星号(*)乘法运算 矩阵 - 矩阵:对应位置相乘 矩阵 - 数组:对应位置相乘 数组在后,行与数组相乘 ...

    总的来说,np.multiply()*的作用是一样的,np.dot()np.matmul()作用是一样的。

    1. np.multiply()函数 —— 星号(*)乘法运算

    矩阵 - 矩阵:对应位置相乘

    矩阵 - 数组/数组 - 矩阵:对应位置相乘 数组在后或者在后,都是与矩阵的行对应相乘

    数组 - 数组:对应位置相乘

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

    2. np.dot()函数

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

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

    输出大小:

    • 矩阵与矩阵:遵循矩阵乘法应该有的大小
    • 矩阵 - 数组/数组 - 矩阵:数组在前,则数组维度应该与矩阵行数一致,结果维度为矩阵的列数;数组在后,则数组维度应该与矩阵列数一致,结果维度为矩阵的行数。(1×n)×(n×m)1×mm(1 \times n) \times (n \times m) \rightarrow 1 \times m \rightarrow m,,(n×m)×(m×1)1×nn(n \times m) \times (m \times 1) \rightarrow 1 \times n \rightarrow n
    • 数组 - 数组:常数

    3. np.matmul()函数

    np.matmul中禁止矩阵与标量的乘法。

    在矢量乘矢量的內积运算中,np.matmulnp.dot没有区别

    image-20190729173534234
    代码GitHub链接

    展开全文
  • 文章目录【1】np.array,np.matrix,np.mat的区别(1)数据类型不同(2)np.mat和np.matrix的区别【3】矩阵相乘 (*)、np.multiply、np.dot的区别(1)当被乘的二者为array时(2)当被乘的二者为mat/matrix时 ...

    【1】np.array,np.matrix,np.mat的区别

    (1)np.array和后两者的区别

    数据类型不同
    np.array产生numpy.ndarray类型的数据,不能进行矩阵意义上的乘法。np.matrix,np.mat产生numpy.matrix类型数据,可以进行矩阵相乘
    见下例

    import numpy as np
    
    
    a = np.mat('1 2 3;3 4 5;1 2 3')
    b = np.mat([[1, 2], [3, 4]])
    print(a)
    print(b)
    '''
    两种方法都可以
    [[1 2 3]
     [3 4 5]
     [1 2 3]]
    [[1 2]
     [3 4]]
     '''
    print(type(a))
    print(type(b))
    '''
    <class 'numpy.matrix'>
    <class 'numpy.matrix'>
    '''
    
    c = np.array([[1, 2], [3, 4]])
    print(c)
    '''
    [[1 2]
     [3 4]]
    '''
    print(type(c)) #<class 'numpy.ndarray'>
    

    解释:array是创建数组,他的shape是(6,),但使用reshape后 可以将数组转换为矩阵。(见下例)
    np.array与np.arange的区别:np.array必须自己手动输入数组;np.arange与直接使用range类似,可以产生一串数字。但二者产生的都是数组并非矩阵。

    a = np.arange(12).reshape(3,4)
    print(a)
    '''
    [[ 0  1  2  3]
     [ 4  5  6  7]
     [ 8  9 10 11]]
     '''
    b = np.array([1,2,3,4,5,6])
    print(b.shape)    #(6,)
    c = b.reshape(2,3)
    print(c.shape)    #(2, 3)
    

    一维数组和一维矩阵的区别
    (12,)表示是数组,只有一个[ ] ; (1, 12)是一维矩阵,左右各有两个[ ] ,matrix可以使二维数组变为二维矩阵,可以将数组变为一维矩阵

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

    (2)np.mat和np.matrix的区别

    由数组变为矩阵有np.mat和np.matrix两种方法。
    使用np.mat后,如果对原数组进行改变,矩阵也会相应发生变化,如下:

    #创建ndarray二维数组
    x = np.array([[1, 2], [3, 4]])
    
    #生成 <class 'numpy.matrix'> 矩阵
    m = np.mat(x)
    
    #打印 m 矩阵
    print(m)
    '''
    [[1 2]
     [3 4]]
    '''
    x[0,0] = 0
    print(m)
    '''
    [[0 2]
     [3 4]]
    '''
    
    

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

    #创建ndarray二维数组
    x = np.array([[1, 2], [3, 4]])
    
    #生成 <class 'numpy.matrix'> 矩阵
    m = np.matrix(x)
    
    #打印 m 矩阵
    print(m)
    '''
    [[1 2]
     [3 4]]
    '''
    x[0,0] = 0
    print(m)
    '''
    [[1 2]
     [3 4]]
    '''
    

    【3】矩阵相乘 (*)、np.multiply、np.dot的区别

    注意:不同类型的数据在使用他们三者时的效果不同。

    (1)当被乘的二者为array时

    使用np.dot才能进行矩阵的相乘(2×3与3×2=2×2 相乘后相加),但乘积的结果类型为<class ‘numpy.ndarray’> 说明它不是真正的矩阵相乘,但是可以遵守矩阵相乘的法则。

    import numpy as np
    a = np.array([[1,2,3],[1,1,1]])
    b = np.array([[1,1],[1,1],[1,1]])
    print(a)
    '''
    [[1 2 3]
     [1 1 1]]
    '''
    print(b)
    '''
    [[1 1]
     [1 1]
     [1 1]]
    '''
    print(np.dot(a,b))
    '''
    [[6 6]
     [3 3]]
    '''
    

    如果不符合矩阵乘法规则,则必须两数组的形式完全相同,才能进行运算。
    a*b就是对应元素的乘积,multiply也是对应元素的乘积,乘积的结果类型为<class ‘numpy.ndarray’>

    a = np.array([[1,2,3],[1,1,1]])
    b = np.array([[1,1,1],[1,1,1]])
    print(a)
    '''
    [[1 2 3]
     [1 1 1]]
    '''
    print(b)
    '''
    [[1 1 1]
     [1 1 1]]
    '''
    print(a*b)
    '''
    [[1 2 3]
     [1 1 1]]
    '''
    

    (2)当被乘的二者为mat/matrix时

    默认 a*b与 dot(a,b)是矩阵的乘积(3×3与3×1=3×1即m×n与n×y=m×y),结果类型为<class ‘numpy.matrix’>

    import numpy as np
    a = np.mat('1 2 3;3 4 5;1 2 3')
    b = np.mat([[1],[1],[1]])
    
    c = np.dot(a,b)
    print(c)
    '''
    [[ 6]
     [12]
     [ 6]]
    '''
    c = a*b
    print(c)
    '''
    [[ 6]
     [12]
     [ 6]]
    '''
    

    multiply转化为对应元素的乘积,相乘条件为两矩阵均为完全相同的格式 或 行数相同且列数为1(2×3与2×1=3×3即m×n与m×1=m×n),对应位置只相乘不进行相加

    import numpy as np
    
    a = np.matrix('1 2 3;3 4 5') #相同格式
    b = np.matrix([[1,1,1],[2,2,2]])
    c = np.multiply(a,b)
    print(c)
    '''
    [[ 1  2  3]
     [ 6  8 10]]
    '''
    
    a = np.matrix('1 2 3;3 4 5') #行数相同其中一个列数为1
    b = np.matrix([[1],[2]])
    c = np.multiply(a,b)
    print(c)
    '''
    [[ 1  2  3]
     [ 6  8 10]]
    '''
    

    (3)总结

    np.dot无论数据是array或matrix都表示矩阵相乘
    np.multiply无论数据是array或matrix都表示对应位置相乘

    如果数据类型为array,(*)和np.multiply表示对应位置相乘,np.dot表示矩阵形式相乘

    如果数据类型为matrix,np.multiply表示对应位置位置相乘,(*)和np.dot表示矩阵形式相乘

    展开全文
  • 常见的矩阵操作和类型总结我们给定的数据功能快捷键合理的创建标题,有助于目录的生成如何改变文本的样式插入链接与图片如何插入一段漂亮的代码片生成一个适合你的列表创建一个表格设定内容居中、居左、居右...

    总结

    关于numpytensor的内部数据乘积,主要是有以下相关函数可以操作。

    1. 通用函数:*
    2. numpy中函数:np.matmul/np.dot/np.multiply
    3. tensorflow中函数:tf.matmul/tf.multiply

    一览表

    操作/ 数据 numpy tensor
    * 按位元素相乘,返回array 按位元素相乘,返回tensor
    np.matmul(A,B) 矩阵相乘操作,返回array <!!无法操作!!>
    np.dot(A,B) 点积,<内部操作意义不明> 点积,<内部操作意义不明>
    np.multiply(A,B) 按位元素相乘,返回array 按位元素相乘,返回tensor
    tf.matmul(A,B) 矩阵相乘操作,返回tensor 矩阵相乘操作,返回tensor
    tf.multiply(A,B) 按位元素相乘,返回tensor 按位元素相乘,返回tensor
    1. 通用函数可以对两种数据(tensor/array)进行按位元素相乘的操作,返回对应的数据格式(tensor返回tensor,array返回array)
    2. np.matmul可以对numpy数据矩阵相乘操作,返回array,对tensor数据无法操作; 特殊np.multiply可以对两种数据(tensor/array)均进行按位元素相乘的操作,返回对应的数据格式(tensor返回tensor,array返回array)
    3. tf.matmul(x,y)可以对两种数据(tensor/array)矩阵相乘操作,均生成tensortf.multiply可以对两种数据(tensor/array)均进行按位元素相乘的操作,均生成tensor

    给定实验数据

    # numpy数据
    x = np.random.randn(2,3,4)*10  # 2, 3, 4
    y = np.random.randn(2,4,3)*10  # 2, 4, 3
    z = np.random.randn(2,3,4)*10  # 2, 3, 4
    # tensorflow数据
    x_ = tf.convert_to_tensor(x)  # 2, 3, 4
    y_ = tf.convert_to_tensor(y)  # 2, 4, 3
    z_ = tf.convert_to_tensor(z)  # 2, 3, 4
    

    通用函数*

    1.在tensor数据中,只能对shape相等的数据操作。是等效于tf.mul(x, z)函数的,也就是按位元素相乘,但是该api被废弃了,被tf.multiply(x_,z_)代替。
    如下所示的结果

    int:  x_*z_
    out: <tf.Tensor 'mul_4:0' shape=(2, 3, 4) dtype=float64>
    

    如果是x_*y_会报错,因为矩阵结构不对。
    2. 在numpy的数据,只能对shape相等的数据操作,就是等效于np.multiply(x, z)函数的,也就是按位元素相乘

    int: (x*z).shape
    out: [2,3,4]
    int: np.multiply(x,z).shape
    out: [2,3,4]
    

    如果是x*y会报错,因为矩阵结构不对。

    numpy中的操作函数

    1.np.matmul可以对numpy数据矩阵相乘操作,返回array
    tensor数据无法操作的原因是,tensor只有在开启会话后才知道是什么具体内部信息。如下

    # 对numpy数据操作
    np.matmul(x,y)
    array([[[ 135.00353387,   91.52903838, -171.80624465],
            [ -48.06257232,  226.70191293,  -99.31504134],
            [ -13.07481602,  -65.88699065, -285.02107715]],
    
           [[-418.64431827,  352.70885364,  386.94553585],
            [ 316.96375007,   80.67215049, -130.78989204],
            [-207.21033988,   47.25128822,   62.5329744 ]]])
    ## 对tensor操作,没有开启会话,shape不清晰无法操作。
    np.matmul(x_,y_)
    ValueError: matmul: Input operand 0 does not have enough dimensions 
    (has 0, gufunc core with signature (n?,k),(k,m?)->(n?,m?) requires 1)
    

    2.np.multiply可以对两种数据(tensor/array)均进行按位元素相乘的操作,返回对应的数据格式(tensor返回tensor,array返回array)

    # 对numpy数据操作
    np.multiply(x,z)
    array([[[  13.2853443 ,   17.24155086,  -34.87846792,   38.32096247],
            [-170.15795371,  -32.70534678,   -5.48962254,  130.43221194],
            [  38.3870938 ,  150.13360364,   44.23867107,  -74.42425187]],
    
           [[ -91.30385223,   -6.00035432,    9.35122873,   21.70442799],
            [  36.825695  , -104.87642619,  -55.69509325,   89.90946649],
            [  52.98619734,   21.6885545 ,    2.57517183,   -2.36556962]]])
    
    #对tensor操作
    np.multiply(x_,z_)
    <tf.Tensor 'mul_8:0' shape=(2, 3, 4) dtype=float64>
    

    3.np.dot这是最神奇的操作,官方描述含义是点积,但是我没咋用过,就不写了,而且生产的值在三维以上后,会非常奇怪,奇怪在违反我们常见的数据变化。。其实这个函数是符合某个公式,大家想详细了解的可以去查。

    tensorflow中的操作函数

    1.tf.matmul(x,y)可以对numpy和tensor两种数据矩阵相乘操作 ,均生成tensor

    tf.matmul(x,y)
    <tf.Tensor 'MatMul_1:0' shape=(2, 3, 3) dtype=float64>
    
    tf.matmul(x_,y_)
    <tf.Tensor 'MatMul_4:0' shape=(2, 3, 3) dtype=float64>
    

    2.tf.multiply(x,y)可以对numpy和tensor两种数据 按位元素相乘 操作,,均生成tensor

    tf.multiply(x,z)
    <tf.Tensor 'Mul_6:0' shape=(2, 3, 4) dtype=float64>
    
    tf.multiply(x_,z_)
    <tf.Tensor 'Mul_7:0' shape=(2, 3, 4) dtype=float64>
    
    展开全文
  • import numpy as np ...a1 = np.array([[1, 2], [3, 4]]) c1 = np.array([[5,6],[7,8]])   b1 = np.mat([[1, 2], [3, 4]]) d1 = np.mat([[5,6],[7,8]])   print("a1乘c1的结果:",...
  • 星乘(*):数组中对应位置元素相乘,功能同 np.multiply() 官方文档:参考 np.multiply() np.multiply():数组中对应位置元素相乘,功能同星乘(*) 官方文档:...
  • 一、np.sum()和sum的区别 如果只用sum()的话,表示的是数组中对应维度上的数相加,得到的是比原始数组少一维的数组。 如果写 np.sum() 的话,表示一个数组中的维数和列数上的所有数都加在一起,得到的是一个数值。 二...
  • Python 中的几种矩阵乘法 np.dot, np.multiply, *

    万次阅读 多人点赞 2017-04-18 16:56:38
    同线性代数中矩阵乘法的定义: np.dot()np.dot(A, B):对于二维矩阵,计算真正意义上的矩阵乘积,同线性代数中矩阵乘法的定义。对于一维矩阵,计算两者的内积。见如下Python代码:import numpy as np# 2-D array: 2...
  • numpy.dot 既可以计算两个向量的内积也可以计算两个矩阵的乘法 ...np.dot([2j, 3j], [2j, 3j]) 结果 (-13+0j) 情况2: If both a and b are 2-D arrays, it is matrix multiplication. 示例 c=np.arr

空空如也

1 2 3 4 5 ... 20
收藏数 7,068
精华内容 2,827
关键字:

multiply