精华内容
下载资源
问答
  • multiply(a,b)就是个乘法,如果a,b是两个数组,那么对应元素相乘 numpy.multiply numpy.multiply(x1, x2[, out]) = <ufunc 'multiply'> Multiply arguments element-wise. Parameters: x1, x2 : array_like ...

    multiply(a,b)就是个乘法,如果a,b是两个数组,那么对应元素相乘

    numpy.multiply
    numpy.multiply(x1, x2[, out]) = <ufunc 'multiply'>
    Multiply arguments element-wise.
    Parameters:
    x1, x2 : array_like
    Input arrays to be multiplied.
    Returns:
    y : ndarray
    The product of x1 and x2, element-wise. Returns a scalar if
    both  x1 and x2 are scalars.
    Notes
    Equivalent to x1 * x2 in terms of array broadcasting.
    Examples
    >>>
    >>> np.multiply(2.0, 4.0)
    8.0
    >>>
    >>> x1 = 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.]])
    为什么上面的np.multiply(x1, x2)是这种结果,原因是multiply是ufunc函数

    当我们使用ufunc函数对两个数组进行计算时,ufunc函数会对这两个数组的对应元素进行计算,因此它要求这两个数组有相同的大小(shape相同)。如果两个数组的shape不同的话,会进行如下的广播(broadcasting)处理:

    让所有输入数组都向其中shape最长的数组看齐,shape中不足的部分都通过在前面加1补齐
    输出数组的shape是输入数组shape的各个轴上的最大值
    如果输入数组的某个轴和输出数组的对应轴的长度相同或者其长度为1时,这个数组能够用来计算,否则出错
    当输入数组的某个轴的长度为1时,沿着此轴运算时都用此轴上的第一组值
    上述4条规则理解起来可能比较费劲,让我们来看一个实际的例子。

    先创建一个二维数组a,其shape为(6,1):

    >>> a = np.arange(0, 60, 10).reshape(-1, 1)
    >>> a
    array([[ 0], [10], [20], [30], [40], [50]])
    >>> a.shape
    (6, 1)

    再创建一维数组b,其shape为(5,):

    >>> b = np.arange(0, 5)
    >>> b
    array([0, 1, 2, 3, 4])
    >>> b.shape
    (5,)

    计算a和b的和,得到一个加法表,它相当于计算a,b中所有元素组的和,得到一个shape为(6,5)的数组:

    >>> c = a + b
    >>> c
    array([[ 0,  1,  2,  3,  4],
           [10, 11, 12, 13, 14],
           [20, 21, 22, 23, 24],
           [30, 31, 32, 33, 34],
           [40, 41, 42, 43, 44],
           [50, 51, 52, 53, 54]])
    >>> c.shape
    (6, 5)

    由于a和b的shape长度(也就是ndim属性)不同,根据规则1,需要让b的shape向a对齐,于是将b的shape前面加1,补齐为(1,5)。相当于做了如下计算:

    >>> b.shape=1,5
    >>> b
    array([[0, 1, 2, 3, 4]])


    这样加法运算的两个输入数组的shape分别为(6,1)和(1,5),根据规则2,输出数组的各个轴的长度为输入数组各个轴上的长度的最大值,可知输出数组的shape为(6,5)。

    由于b的第0轴上的长度为1,而a的第0轴上的长度为6,因此为了让它们在第0轴上能够相加,需要将b在第0轴上的长度扩展为6,这相当于:


    >>> b = b.repeat(6,axis=0)
    >>> b
    array([[0, 1, 2, 3, 4],
           [0, 1, 2, 3, 4],
           [0, 1, 2, 3, 4],
           [0, 1, 2, 3, 4],
           [0, 1, 2, 3, 4],
           [0, 1, 2, 3, 4]])

    由于a的第1轴的长度为1,而b的第一轴长度为5,因此为了让它们在第1轴上能够相加,需要将a在第1轴上的长度扩展为5,这相当于:


    >>> a = a.repeat(5, axis=1)
    >>> a
    array([[ 0,  0,  0,  0,  0],
           [10, 10, 10, 10, 10],
           [20, 20, 20, 20, 20],
           [30, 30, 30, 30, 30],
           [40, 40, 40, 40, 40],
           [50, 50, 50, 50, 50]])


    经过上述处理之后,a和b就可以按对应元素进行相加运算了。

    当然,numpy在执行a+b运算时,其内部并不会真正将长度为1的轴用repeat函数进行扩展,如果这样做的话就太浪费空间了

    这样,就能知道为什么 np.multiply(x1, x2) 是这种结果了
     

    展开全文
  • np.multiply()函数

    2020-05-09 21:32:52
    np.multiply()函数 数组场景 import numpy as np 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) #数组对应元素...

    np.multiply()函数

    数组场景

    import numpy as np
    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]])
    

    矩阵场景

    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
    
    展开全文
  • np.multiply.reduce 函数的用法

    千次阅读 2019-07-27 18:59:47
    看 YOLO V3 看到这个函数,去搜又没人写过,英文文档看起来头晕脑胀,自己就随便实验了一下,也不难。先定义 a : import numpy as np a = np.arange(1,9).reshape(2,2,2) ...np.multiply.reduce(a,axis = 0)...

    看 YOLO V3 看到这个函数,去搜又没人写过,英文文档看起来头晕脑胀,自己就随便实验了一下,也不难具体如下。
    先定义 a :

    import numpy as np
    a = np.arange(1,9).reshape(2,2,2)
    print(a)
    [[[1 2]
      [3 4]]
      
     [[5 6]
      [7 8]]]
    

    然后挨个来实验:

    np.multiply.reduce(a,axis = 0)
    Out[5]: 
    array([[ 5, 12],
           [21, 32]])
    

    以第一维度点乘时,是上面一堆乘上下面一堆,具体是 1X5 2X6 3X7 4X8,得出来数据如上 。
    ——————————————分割线——————————————————

    np.multiply.reduce(a,axis = 1)
    Out[6]: 
    array([[ 3,  8],
           [35, 48]])
    

    以第二维度点乘时,是第二维内对应位置点乘,即 1X3 2X4 5X7 6X8 ,结果如上。
    ——————————————分割线——————————————————

    np.multiply.reduce(a,axis = -1)
    Out[7]: 
    array([[ 2, 12],
           [30, 56]])
    

    以第三维度点乘时,是第三维内对应位置点乘,即 1X2 3X4 5X6 7X8 ,结果如上。这个在 YOLO 里,适合用来算 box 的面积,取最后一个维度作点乘,最后出来就是面积了。

    展开全文
  • np.multiply \ tf.multiply函数

    千次阅读 2018-07-24 12:22:20
    np.multiply和tf.multiply用法一致,可以放在一起理解。功能是实现x和y的element-wise方式的相乘,也就是所有点对应相乘。注意不是矩阵乘操作,矩阵乘操作使用的是tf.matmul函数。 当x和y维度一致时,严格按照...
    tf.multiply(x, y, name=None)

    np.multiply和tf.multiply用法一致,可以放在一起理解。功能是实现xy的element-wise方式的相乘,也就是所有点对应相乘。注意不是矩阵乘操作,矩阵乘操作使用的是tf.matmul函数。

    (1)当xy维度一致时,严格按照element-wise方式执行,很容易理解,如下例:
    import tensorflow as tf
    '''
    x=[[[1,2],[3,4]],
       [[5,6],[7,8]],
       [[9,10],[11,12]]], shape=[3*2*2]
    y=[[[1,2],[3,4]],
       [[5,6],[7,8]],
       [[9,10],[11,12]]],shape=[3*2*2]
    '''
    x=tf.constant([[[1,2],[3,4]],[[5,6],[7,8]],[[9,10],[11,12]]])
    y=tf.constant([[[1,2],[3,4]],[[5,6],[7,8]],[[9,10],[11,12]]])
    result=tf.multiply(x,y)
    
    with tf.Session() as sess:
      print(sess.run(result))
    
    输出:
    [[[  1   4]
      [  9  16]]
    
     [[ 25  36]
      [ 49  64]]
    
     [[ 81 100]
      [121 144]]]
    (2)当xy维度不一致时,numpy会通过broadcast机制自动匹配,比如[1]*[3,4,5],会将[1]复制成[1,1,1]再做计算。当然真正内部实现的时候是不会把[1]复制成[1,1,1]的,这样

    则程序首先会从高维(最外层)元素开始匹配,如果匹配成功,则再依次匹配低纬,匹配规则是:a.该维维度必须一致;b.;但是当某一维不匹配时,程序复制多次该维的向量,直到匹配为止,比如会将类似[[1,2]]*[[1,2],[3,4]]这样的方式改为[[1,2],[1,2]]*[[1,2],[3,4]],或者将类似[[1],[2]]*[[1,2],[3,4]]改为[[1,1],[2,2]]*[[1,2],[3,4]],可以看下面两个例子体会一下:

    import tensorflow as tf
    '''
    x=[[[1,2],[3,4]],
       [[5,6],[7,8]],
       [[9,10],[11,12]]], shape=[3*2*2]
    y=[[1,2],
       [3,4]],shape=[2*2]
    此时,y分别和x的每一项:[[1,2],[3,4]和[[5,6],[7,8]和[[9,10],[11,12]]
    做点对点相乘
    '''
    x=tf.constant([[[1,2],[3,4]],[[5,6],[7,8]],[[9,10],[11,12]]])
    y=tf.constant([[1,2],[3,4]])
    result=tf.multiply(x,y)
    
    with tf.Session() as sess:
      print(sess.run(result))
    
    输出:
    [[[ 1  4]
      [ 9 16]]
    
     [[ 5 12]
      [21 32]]
    
     [[ 9 20]
      [33 48]]]

    而如果y变成下面的形式,依旧可以匹配成功:

    import tensorflow as tf
    '''
    x=[[[1,2],[3,4]],
       [[5,6],[7,8]],
       [[9,10],[11,12]]], shape=[3*2*2]
    y=[[1],[3]],shape=[2*1]
    此时,y分别和x的每一项:[[1,2],[3,4]和[[5,6],[7,8]和[[9,10],[11,12]]
    做点对点相乘,最小执行单位是[1]*[1,2],[3]*[3,4],[1]*[5,6],[3]*[7,8]...
    等这样
    '''
    x=tf.constant([[[1,2],[3,4]],[[5,6],[7,8]],[[9,10],[11,12]]])
    y=[[1],[3]]
    result=tf.multiply(x,y)
    
    with tf.Session() as sess:
      print(sess.run(result))
    
    输出:
    [[[ 1  2]
      [ 9 12]]
    
     [[ 5  6]
      [21 24]]
    
     [[ 9 10]
      [33 36]]]

    array([[[ 1, 2],
    [ 3, 4]],

     [[ 5,  6],
     [ 7,  8]],
    
     [[ 9, 10],
     [11, 12]]])
    

    array([[[1],
    [2]],

       [[3],
        [4]],
    
       [[5],
        [6]]])
    

    array([[[ -1., -2.],
    [ -3., -4.]],

       [[ -5.,  -6.],
        [ -7.,  -8.]],
    
       [[ -9., -10.],
        [-11., -12.]]])
    
    展开全文
  • Python基本函数:np.multiply()

    千次阅读 2019-09-23 19:10:42
    Python基本函数:np.multiply()一、用法         由于multiply是ufunc函数,ufunc函数会对这两个数组的对应元素进行计算,因此它要求这两个数组有相同的大小(shape相同)...
  • 元素乘法:np.multiply(a,b) 矩阵乘法:np.dot(a,b) 或 np.matmul(a,b) 或 a.dot(b) 唯独注意:*,在 np.array 中重载为元素乘法,在 np.matrix 中重载为矩阵乘法! 对于** np.array **对象 >>> a array([...
  • 原文链接:... 这一个博客主要是整理所有的关于矩阵还是数组的乘法的细节。 代码: 你需要在下面的代码里面主要到这些点: (1):np.dot()如果碰到的是秩为1的数组,那么执行的是对应位置的元素相...
  • 1、np.dot() 2、@ 3、np.multiply() 4、*
  • np.multiply()函数* 函数作用* 数组和矩阵对应位置相乘,输出与相乘数组/矩阵的大小一致 1.1数组场景A = np.arange(1,5).reshape(2,2) Aarray([[1, 2], [3, 4]]) B = np.arange(0,4).reshape(2,2) Bar
  • 目录np.multiply()函数作用代码示例np.dot()函数作用代码示例星号(*)函数作用代码示例 np.multiply() 函数作用 对应位置相乘 代码示例 import numpy as np Array1 = np.arange(0,4) #数组1 print("数组1:",Array1...
  • 同线性代数中矩阵乘法的定义: np.dot()np.dot(A, B):对于二维矩阵,计算真正意义上的矩阵乘积,同线性代数中矩阵乘法的定义。对于一维矩阵,计算两者的内积。见如下Python代码:import numpy as np # 2-D array:...
  • 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
  • python中的*、np.dot和np.multiply辨析

    千次阅读 2018-07-28 20:36:54
    在之前学习别人开源代码的时候,对于python中的*、np.dot()和np.multiply()具体结果产生了疑惑,遂去了解了一下相关说明,并实验了一下,结合别人的博客,这里进行总结 建议:当我们需要在python中进行像...
  • np.multiply

    2019-07-23 14:59:00
    用法:np.multiply(x1,x2),作用:逐元素相乘,若x1和x2均为标量,则返回标量 x1=np.array([1,4,2]) x2=np.array([2,5,3]) np.multiply(x1,x2) Out[43]: array([ 2, 20, 6]) 转载于:...
  • 使用array时,运算符multiply、 * 用于分别计算两个数的相乘(1),函数 dot() 同线性代数中矩阵乘法的定义(2)(对于秩为1的数组,执行对应位置相乘,然后再相加;对于秩不为1的二维数组,执行矩阵乘法运算;)使用...
  • np.multiply tensorflow 中函数: tf.matmul / tf.multiply 一览表 操作/ 数据 numpy tensor * 按位元素相乘,返回 array 按位元素相乘,返回 tensor np.matmul(A,B) 矩阵...
  • np.mat()函数np.array()函数的辨析

    千次阅读 多人点赞 2020-02-07 16:22:27
    今天,在学习numpy的时候,偶然看到np.mat()函数,查了一下,也是生成矩阵,这里的mat与MATLAB中的很相似,所以在这里简单的记录一下np.mat()函数应该怎么使用,和numpy中的array()函数有什么区别? np.mat()的基本...
  • 本文详细介绍了OpenCV-Python图像乘法运算cv2.multiply函数的调用语法,并分析了OpenCV乘法的几种使用场景以及图像溢出的归一化处理,通过这些分析可以知道OpenCV图像的乘法运算主要有三种作用: 1. 图像和标量的...
  • np.multipy()函数解读

    千次阅读 2019-09-25 10:10:20
    函数作用 np.multipy(a,b)函数是进行一种乘法运算,a,b对应的位置相乘,得到和a一样的输出size。其中a,b也可以是常数。 ... np.multiply(list(range(3)),10) array([ 0, 10, 20]) >>&g...
  • 2.点乘 np.multiply 或者 * 标量乘法,两个数组对应位置进行相乘,结果shape与参与运算的数组shape一致。参与运算的两个数据的shape一致 3.矩阵乘法 np.matmul 或者 @ 两个运算的矩阵需要满足矩阵乘法的规则(前...
  • 1. exp() math.exp()的参数必须是一个实数 numpy.exp()参数可以是一个...x_norm=np.linalg.norm(x, ord=None, axis=None, keepdims=False) 参数: x:矩阵或向量 ord:范数类型,常用为1和2,也可以为负数 ...
  • 一、np.sum()和sum的区别 如果只用sum()的话,表示的是数组中对应维度上的数相加,得到的是比原始数组少一维的数组。 如果写 np.sum() 的话,表示一个数组中的维数和列数上的所有数都加在一起,得到的是一个数值。 二...
  • np.random.rand() newaxis tf.multiply与tf.matmul的区别 tf.multiply()两个矩阵中对应元素各自相乘 tf.matmul()将矩阵a乘以矩阵b,生成a * b import tensorflow as tf #两个矩阵的对应元素各自相乘!! x...
  • 这两天在看吴恩达深度学习作业的代码时,碰到了np.dot()、np.outer()、np.multiply()、*等四个函数,特此记录。 1、np.dot() 如果碰到的是秩为1的数组,那么执行的是对应位置的元素相乘再相加;如果遇到的是秩不为1...
  • import numpy as np  观察以下两个输出语句结果的不同: 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]]) ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 11,078
精华内容 4,431
关键字:

np.multiply函数