我正在使用numba的@njit装饰器来编译一个在并行进程中使用的函数,但它比我预期的要慢。在执行时间上应该相差一个数量级的进程大约需要同一时间,这使得它看起来有大量的编译开销。
我有个功能
@njit
def foo(ar):
(do something)
return ar
和一个正常的python函数
def bar(x):
(do something)
return foo(x)
在并行进程中调用,如
if __name__=="__main__":
with concurrent.futures.ProcessPoolExecuto
我试图计算一维离散余弦变换(类型2),我试图提高我的性能与numba。我有以下代码:
import numpy as np
import math
import numba
@numba.jit()
def epsilon(N:int, i: int) -> float:
if i == 0 or i == N:
return math.sqrt(2)/2
return 1.0
@numba.jit()
def dct2(a):
n = len(a)
y = np.empty([2*n])
y[:len(a)] = a
from numba import jit
from numpy import arange
# jit decorator tells Numba to compile this function.
# The argument types will be inferred by Numba when function is called.
@jit
def sum2d(arr,m):
M, N = arr.shape
result = 0.0
if m in ['yes']:
for i in range(M):
我在看来学习Numba。在17:00,演示者屏幕上有以下代码:
@njit
def simulate_spring_mass_funky_damper(x0, T=10, dt=0.0001, vt=1.0):
times = np.arange(0, T, dt)
positions = np.zeros_like(times)
v = 0
a = 0
x = x0
positions[0] = x0/x0
for ii in range(len(times)):
if ii == 0:
我正在研究如何最好地比较使用numba编译的python函数中的字符串(没有python模式,python 3)。
用例如下:
import numba as nb
@nb.jit(nopython = True, cache = True)
def foo(a, t = 'default'):
if t == 'awesome':
return(a**2)
elif t == 'default':
return(a**3)
else:
...
但是,将返回以下错误:
In
所以我用Numpy在Python中做了一些关于衍射的作业。我的结果根本就不是他们应该得到的结果,我很困惑。
我用来生成FFT的代码如下:
Python:
aperaturearray = np.array(im) # Turn image into numpy array
Ta = np.fft.fftshift(np.fft.fft2(aperaturearray))
### I did some calculations here ###
ftfm = Image.fromarray(np.uint8(Utfm))
ftfm.save(("Path"))
Matla
我有几台装有Ubuntu和MPICH服务器的PC--我用它们与C++和MPI进行并行计算。现在我想用Python做类似的事情。我的问题是-有什么简单的方法可以在许多CPU核心(在许多计算机上)上进行快速傅立叶变换?用法的例子会很好。下面是我在单线程上使用的方法:
import numpy as np
N=1024
tab=np.random.rand(N,N,N) #declare some matrix in 3d
a=np.random.rand(N,N,N) #declare other matrix
tab=np.fft.ifftn(a*np.fft.fftn(tab))
当我们有2^
我想使用一个numba.typed.List (将称为List)传递到我的函数中,该函数被包装在njit中。但是,这个List应该从现有的python列表中创建。
当我查看时,创建List的方式似乎是初始化它,然后将元素附加到它。然而,这要求您遍历python中已经存在的列表,这对于大型列表来说似乎是效率低下的。
例如:
from numba.typed import List
numba_list = List()
py_list = ["a", "b", "c"]
for e in py_list:
numba_list.append
我正在用Python语言构建一个numba模拟类,并且我想传递一些来自早期模拟的参数值,这些参数值存储在文件中。有许多参数值保存在文件中,所以它们在一个文件中,我使用pandas访问该文件。
不幸的是,试图在numba中使用pandas会抛出一个错误。具体地说,numba似乎对我在其中调用pandas并赋值感到不高兴,因为它不确定如何键入它们。(注意:如果我将这些链接的pandas调用拆分为多行,则会将read_feather行标识为罪魁祸首):
from collections import OrderedDict
from numba import jitclass, float32, i
我知道numba会创建一些间接费用,在某些情况下(非密集计算),纯python会变得更慢。但我不知道的是在哪里划界线。是否可以用算法复杂度的顺序来确定在哪里?
例如,为了添加两个数组(~O(n)),在这段代码中,纯python比5更短:
def sum_1(a,b):
result = 0.0
for i,j in zip(a,b):
result += (i+j)
return result
@numba.jit('float64[:](float64[:],float64[:])')
def sum_2(a,b):
我正在尝试编译一个简单的函数,它接受一个python列表,然后根据一个索引列表来分割它。我是numba的新手,医生帮不了我。
Problem I无法成功编译该函数
代码编译 arr变量是一个浮起或整数的python列表,idx是一个numpy数组或python整数列表,根据arr输入结果应该是一个2d浮或整数的python列表。
from numba.pycc import CC
cc = CC('trial')
# Uncomment the following line to print out the compilation steps
cc.verbose = Tru
我对python有点陌生,我正在玩numba,并编写了比numba中的纯python运行更慢的代码。在较小的数量中,纯蟒蛇的x4时间比numba快,而且在大量情况下,它们的运行速度基本相同。是什么让我的代码在numba慢运行?
from numba import njit
@njit
def forr (q):
p=0
k=q
n=0
while k!=0:
n += 1
k=k//10
h=(abs(q-n*9)+q-n*9)//2
for j in range(q,h,-1):
考虑以下四个函数(python、numba、cython和smart),它们在给定相同的整数输入时计算相同的响应
def python(n):
total = 0
for m in range(1,n+1):
total += m
return total
from numba import jit
numba = jit(python)
cpdef int cython(int n):
cdef int total = 0
cdef int m
for m in range(1, n+1):
total +=
我刚刚开始使用numba来提高我的程序的性能。我已经减少了我将提出的情况
import numba as nb
import numpy as np
from time import time
def dt_max(U,f, eps=1e-5):
return np.min( np.abs( U ) / ( np.abs( f ) + eps ) )
@nb.njit(cache=True)
def fast_dt_max(U,f, eps=1e-5):
m=U[0]
if m<0 : m=-U[0]
for i in range(len
这是我面临的问题的一个示例代码:
import numba, numpy as np
@numba.jit
def f_plain(x):
return x * (x - 1)
@numba.jit
def integrate_f_numba(a, b, N):
s = 0
dx = (b - a) / N
for i in range(N):
s += f_plain(a + i * dx)
return s * dx
@numba.jit
def apply_integrate_f_numba(col_a, col_b, col_N):
与其他语言相比,python的性能有很多一般性的问题。我有一个更具体的例子:有两个用python和c#编写的简单函数,这两个函数都检查int number是否为质数。
python:
import time
def is_prime(n):
num =n/2
while num >1:
if n % num ==0:
return 0
num-=1
return 1
start = time.clock()
probably_prime = is_prime(2147483629)
elapsed = (
目前,我正试图使用numba加快一些python代码的速度。根据,numpy.meshgrid不受支持,但numpy.vstack是支持的。因此,我将meshgrid调用替换为vstack,它在不使用numba时运行良好。但是,当使用numba时,它不起作用。
以下是代码:
import numpy as np
import timeit
from numba import njit, prange
@njit(parallel=True)
def method1_par1(n):
# create some data
x = np.linspace(0,2*np.pi,
问题
Numpy基本上可以更快地将数组内容复制到另一个数组(至少看起来,对于足够大的数组,Numpy更快)。
我是,并不是期望Numba更快,但是几乎一样快,似乎是一个合理的目标。
最小工作实例
import numpy as np
import numba as nb
def copyto_numpy(a, b):
np.copyto(a, b, 'no')
@nb.jit(nopython=True)
def copyto_numba(a, b):
N = len(a)
for i in range(N):
b[i] = a[i]