• 今天小编就为大家分享一篇关于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
展开全文
• 一维向量与一维向量 #------------一维向量与一维向量------------------# ...# 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 矩阵，此时会遇到向量外积求和的问题
$\sum_{i=1}^n u_i v_i, u_i \in \mathbb{R}^{n\times 1}, v_i \in \mathbb{R}^{1\times n}$
如果我们一个一个地计算 $u_i v_i^T$ 并将它们用for循环加起来，那么我们需要计算 $n$ 个矩阵相乘，是非常低效的。
实际上我们可以将向量外积求和转化成一个矩阵相乘的计算，这里会用到下面的公式
$\sum_{i=1}^n u_i v_i = U V$
这里 $u_i$ 是矩阵 $U$ 的第 $i$ 个列向量， $v_i$ 是矩阵 $V$ 的第 $i$ 个行向量。 在实际计算中，我们可以构造这样的矩阵，将 $n$ 个矩阵计算降低为一个矩阵计算。 下面的代码验证了公式的正确性，并计算了两种方法的时间。
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...
• 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呢？
• 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中，矩阵与向量相加时，矩阵的每一行与向量相加，即要求矩阵的列数与向量的维数相等。 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]) ...

...