精华内容
下载资源
问答
  • 今天小编就为大家分享一篇关于Python中的向量相加numpy中的向量相加效率对比,具有很好的参考价值,希望对大家有所帮助。一起跟随小编过来看看吧
  • 原生python与numpy数组向量相加效率对比

    原生python与numpy数组向量相加效率对比


    计算一个数据元素的平方与立方之和

    1、原生python

    #向量相加 - 原生Python
    def pythonvector(n):
        a = range(n)
        b = range(n)
        c = []
        for i in range(len(a)):
            a[i] = i ** 2
            b[i] = i ** 3
            c.append(a[i] + b[i])
        return c
    


    2、numpy实现

    #向量相加 - numpy
    import numpy
    
    def numpyvector(n):
        a = numpy.arange(n) ** 2
        b = numpy.arange(n) ** 3
        c = a + b
        return c

    3、效率对比

    #效率比较
    import sys
    from datetime import datetime
    
    n = 1000
    
    start = datetime.now()
    c = pythonvector(n)
    end = datetime.now() -start
    
    print "The last 3 elements of the result ",c[-3:]
    print "pythonvector elapsed time ",end.microseconds
    
    start = datetime.now()
    c = numpyvector(n)
    end = datetime.now() -start
    
    print "The last 3 elements of the result ",c[-3:]
    print "numpyvector elapsed time ",end.microseconds





    结果是一样的,效率上numpy远快于原生的python,并且写法上更简洁。

    展开全文
  • 直接使用Python来实现向量的相加# -*-coding:utf-8-*- #向量相加 def pythonsum(n): a = range(n) b = range(n) c = [] for i in range(len(a)): a[i] = i**2 b[i] = i**3 c.append(a[i]+b[i

    直接使用Python来实现向量的相加

    # -*-coding:utf-8-*-
    #向量相加
    def pythonsum(n):
        a = range(n)
        b = range(n)
        c = []
        for i in range(len(a)):
            a[i] = i**2
            b[i] = i**3
            c.append(a[i]+b[i])
        return a,b,c
    
    print pythonsum(4),type(pythonsum(4))
    for arg in pythonsum(4):
        print arg

    从这里这个输出结果可以看得出来,return多个值时,是以列表的形式返回的

    ([0, 1, 4, 9], [0, 1, 8, 27], [0, 2, 12, 36]) <type 'tuple'>
    [0, 1, 4, 9]
    [0, 1, 8, 27]
    [0, 2, 12, 36]

    使用numpy包实现两个向量的相加

    def numpysum(n):
        a = np.arange(n) ** 2
        b = np.arange(n) ** 3
        c = a + b
        return a,b,c
    (array([0, 1, 4, 9]), array([ 0,  1,  8, 27]), array([ 0,  2, 12, 36])) <type 'function'>
    [0 1 4 9]
    [ 0  1  8 27]
    [ 0  2 12 36]

    比较用Python实现两个向量相加和用numpy实现两个向量相加的情况

    size = 1000
    start = datetime.now()
    c = pythonsum(size)
    delta = datetime.now() - start
    # print 'The last 2 elements of the sum',c[-2:]
    print 'pythonSum elapsed time in microseconds',delta.microseconds
    
    size = 1000
    start1 = datetime.now()
    c1 = numpysum(size)
    delta1 = datetime.now() - start1
    # print 'The last 2 elements of the sum',c1[-2:]
    print 'numpySum elapsed time in microseconds',delta1.microseconds

    从下面程序运行结果我们可以看到在处理向量是numpy要比Python计算高出不知道多少倍

    pythonSum elapsed time in microseconds 1000
    numpySum elapsed time in microseconds 0
    展开全文
  • numpy 向量/矩阵的乘法

    千次阅读 2019-04-09 17:36:06
    一维向量与一维向量 #------------一维向量与一维向量------------------# ...# np.inner() 对应位置的元素相乘相加求和 res_inner1 = np.inner(vec1, vec2) # 32 # * 对应位置的元素相乘 成为新矩阵该位置...
    import numpy as np
    

    一维向量与一维向量

    #------------一维向量与一维向量------------------#
    
    vec1 = np.array([1, 2, 3])
    vec2 = np.array([4, 5, 6])
    
    # np.inner() 对应位置的元素相乘相加求和
    res_inner1 = np.inner(vec1, vec2)  # 32
     
    
    # * 对应位置的元素相乘 成为新矩阵该位置的元素
    res_star1 = vec1 * vec2  # [4,10,8]
     
    
    # np.dot() 对两个一维向量相当于 np.inner()
    res_dot1 = np.dot(vec1, vec2) # 32
    res_mult1 = np.dot(vec1, vec2.T) # 32
    res_mult11 = np.dot(vec1.T, vec2) # 32
    

    二维矩阵与一维向量

    #-----------二维矩阵与一维向量--------------#
    x2 = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
    theta_x2 = np.array([10, 100, 1000])
    
    # np.inner() 每一行的对应元素与向量相乘求和 最后结果为x2各行向量与theta_x2点积结果 组成的行向量
    res_inner2 = np.inner(x2, theta_x2)  # [3210, 6540, 9870]
     
    # * 对应位置的元素相乘 成为新矩阵该位置的元素
    res_star2 = x2 * theta_x2   # [10  200 3000]
                                # [40  500 6000]
                                # [70  800 9000]
    
    # np.dot() 相当于np.inner()
    res_dot2 = np.dot(x2, theta_x2)  # [3210, 6540, 9870]
    

    二维矩阵与二维矩阵

    #------------二维矩阵与二维矩阵--------------------#
    
    x3 = np.array([[1, 3, 5], [2, 4, 6], [9, 9, 9]])
    theta_x3 = np.array([[1, 1, 1], [10, 10, 10], [100, 100, 100]])
    
    
    # np.inner() 没懂
    res_inner3 = np.inner(x3, theta_x3) #  [9   90  900]
                                        #  [12  120 1200]
                                         # [27  270 2700]
    
    
    # * 对应位置的元素相乘 成为新矩阵该位置的元素
    res_star3 = x3 * theta_x3
    
    # np.dot() 矩阵乘法
    res_dot3 = np.dot(x3, theta_x3)  # [531 531 531]
                                     # [642 642 642]
                                     # [999 999 999]
    
    展开全文
  • 在计算函数二阶导的时候,我们通常需要计算Hessian 矩阵,此时会遇到向量外积求和的问题 ∑i=1nuivi,ui∈Rn×1,vi∈R1×n \sum_{i=1}^n u_i v_i, u_i \in \mathbb{R}^{n\times 1}, v_i \in \mathbb{R}^{1\times n} i...

    在计算函数二阶导的时候,我们通常需要计算Hessian 矩阵,此时会遇到向量外积求和的问题
    i=1nuivi,uiRn×1,viR1×n \sum_{i=1}^n u_i v_i, u_i \in \mathbb{R}^{n\times 1}, v_i \in \mathbb{R}^{1\times n}
    如果我们一个一个地计算 uiviTu_i v_i^T 并将它们用for循环加起来,那么我们需要计算 nn 个矩阵相乘,是非常低效的。
    实际上我们可以将向量外积求和转化成一个矩阵相乘的计算,这里会用到下面的公式
    i=1nuivi=UV \sum_{i=1}^n u_i v_i = U V
    这里 uiu_i 是矩阵 UU 的第 ii 个列向量, viv_i 是矩阵 VV 的第 ii 个行向量。 在实际计算中,我们可以构造这样的矩阵,将 nn 个矩阵计算降低为一个矩阵计算。 下面的代码验证了公式的正确性,并计算了两种方法的时间。

    import numpy as np
    import time
    
    n = 1000
    
    # 创建两个随机矩阵做测试
    U = np.random.rand(n, n)
    V = np.random.rand(n, n)
    
    mat_loop = np.zeros([n, n])
    start = time.time()
    for i in range(n):
        # 向量 u 是矩阵 U 的列向量
        vec_u = U[:, i]
        # 向量 v 是矩阵 V 的行向量
        vec_v = V[i, :]
        # 向量 u, v 做外积
        mat_loop = mat_loop + np.outer(vec_u, vec_v)
    end = time.time()
    print("Time for loop: ", end - start)
    
    start = time.time()
    # 将向量外积求和转化为矩阵相乘
    mat_fast = U @ V
    end = time.time()
    print("Time for vectorizing: ", end - start)
    
    # 因为会有数值计算误差,所以两个矩阵会有一定的误差,但是会很小
    err = np.max(np.abs(mat_loop - mat_fast))
    print("The max difference: ", err)
    

    代码结果
    我们可以看到第二种计算比第一种计算快了大约 600 倍, 他们的结果是一样的。以后遇到向量外积相加的问题,我们可以将其转化为矩阵相乘,这样子可以大大加速计算。

    展开全文
  • 今天在进行numpy矩阵相加的时候出现了一个小的奇怪的地方,下面我们来看看: >>>P = np.array([1,2,3,4]) >>>F = np.array([9,8,7,6]).reshape((4,1)) >>>P + F array([[10, 11, 12, 13...
  • 在学这数据结构这部分内容的时候,我已经深刻体会到Python语法知识的...以下分为四部分展开:Numpy一维数据结构ArrayPandas一维数据结构:SeriesNumpy二维数据结构:ArrayPandas二维数据结构: DataFrameNumpy(numer...
  • import numpy as np x=[[-0.60116], [-0.94159], [-0.74565], [ 0.89583]] w = [0] b=1 z= np.matmul(x,w) + b print(z) #结果 [1. 1. 1. 1.]
  • import numpy as np import datetime def pysum(n): a = list(range(n)) b = list(range(n)) c = [] for i in range(len(a)): a[i] = i ** 2 b[i] = i ** 3 c.append(a[i]...
  • 文章目录2.15 Python 中的广播(Broadcasting in Python)2.16 关于 python _ numpy 向量的说明(A note on python or numpy vectors) 2.15 Python 中的广播(Broadcasting in Python) 这是一个不同食物(每100g)中...
  • pytorch、tensorflow的底层框架很多地方都是用C语言和GPU加速的 其中向量加是最基础的
  • Python之向量相加中涉及list元素求和、合并 一、问题描述 Python的向量运算可以使用...这里设计两个向量相加的自定义函数,一个用python运行逻辑实现,一个使用numpy包实现 # 向量相加-Python def pythonsum(n):...
  • [img=... 如图,看网上教程说python中的numpy有时候有点莫名其妙,于是举了这个例子,我一试,果然是这样。 那请问大佬们,这个该怎么理解呢?以后写代码如何规避这种莫名其妙的bug呢?
  • Numpy向量与标量计算

    千次阅读 2019-05-18 16:07:28
    import numpy as np a=np.array([1,2,3]) b=np.array([3,2,1]) print (a+10) #对应位置依次相加 print (a*2) print ([1,2,3]*2) print (a+b) print (a-b) print (a*b) print (a/b) print (a*...
  • data1 = [1, 2, 3, 4, 5, 6, 7, 8, 9, 0] #向量1 data2 = [3, 4, 5, 6, 2, 4, 3, 4, 5, 7] #向量2 方法:thread[i] 执行 Q.put(data1[i]+data2[i]) 源码: # 导入包 import threading from queue impo...
  • Numpy中矩阵与向量的加法

    万次阅读 2018-10-10 18:16:24
    Numpy中,矩阵与向量相加时,矩阵的每一行与向量相加,即要求矩阵的列数与向量的维数相等。 import numpy as np x = np.array([[1, 2, 3], [4, 5, 6]]) # array([[1, 2, 3], # [4, 5, 6]]) y = np.array([1, 2]) ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 8,259
精华内容 3,303
关键字:

numpy向量相加