标签: numba

为什么 np.dot 比 np.sum 快这么多？根据这个答案，我们知道 np.sum 很慢并且有更快的替代方案。

例如：

In [20]: A = np.random.rand(1000)\n\nIn [21]: B = np.random.rand(1000)\n\nIn [22]: %timeit np.sum(A)\n3.21 \xc2\xb5s \xc2\xb1 270 ns per loop (mean \xc2\xb1 std. dev. of 7 runs, 100,000 loops each)\n\nIn [23]: %timeit A.sum()\n1.7 \xc2\xb5s \xc2\xb1 11.5 ns per loop (mean \xc2\xb1 std. dev. of 7 runs, 1,000,000 loops each)\n\nIn [24]: %timeit np.add.reduce(A)\n1.61 \xc2\xb5s \xc2\xb1 19.6 ns per loop (mean \xc2\xb1 std. dev. of 7 runs, 1,000,000 loops each)\n

但它们都比以下慢： …

最近,我有一个令人沮丧的时间让python Numba在Ubuntu或Fedora Linux上工作.主要问题在于llvmlite的编译.我需要安装什么才能正确编译？

我有一个像图中所示的三角形镶嵌.

给定N曲面细分中的三角形数量,我有一个N X 3 X 3数组存储(x, y, z)每个三角形的所有三个顶点的坐标.我的目标是为每个三角形找到共享相同边缘的相邻三角形.这是一个错综复杂的部分是我不重复邻居计数的整个设置.也就是说,如果三角形j已被计为三角形的邻居i,则三角形i不应再次计为三角形的邻居j.这样,我想有一个地图存储每个索引三角形的邻居列表.如果我从索引中的三角形开始i,那么索引i将有三个邻居,而所有其他的将有两个或更少.举个例子,假设我有一个存储三角形顶点的数组:

import numpy as np
vertices = np.array([[[2.0, 1.0, 3.0],[3.0, 1.0, 2.0],[1.2, 2.5, -2.0]],
                     [[3.0, 1.0, 2.0],[1.0, 2.0, 3.0],[1.2, -2.5, -2.0]],
                     [[1.0, 2.0, 3.0],[2.0, 1.0, 3.0],[3.0, 1.0, 2.0]],
                     [[1.0, 2.0, 3.0],[2.0, 1.0, 3.0],[2.2, 2.0, 1.0]],
                     [[1.0, 2.0, 3.0],[2.2, 2.0, 1.0],[4.0, 1.0, 0.0]],
                     [[2.0, 1.0, 3.0],[2.2, 2.0, 1.0],[-4.0, 1.0, 0.0]]])

假设我从顶点索引开始计数2,即具有顶点的那个[[1.0, 2.0, 3.0],[2.0, …

我想将一个日期时间数组传递给Numba函数(它不能被矢量化,否则会非常慢).我知道Numba支持numpy.datetime64.但是,它似乎支持datetime64 [D](日精度),但不支持datetime64 [ns](毫秒精度)(我学到了很多方法:它是否记录了？).

我试图从datetime64 [ns]转换为datetime64 [D],但似乎无法找到方法!有任何想法吗？

我用下面的最小代码总结了我的问题.如果你运行testdf(mydates),这是datetime64 [D],它工作正常.如果你运行testdf(dates_input),这是datetime64 [ns],它不会.请注意,此示例只是将日期传递给Numba函数,后者尚未对它们执行任何操作.我尝试将dates_input转换为datetime64 [D],但转换不起作用.在我的原始代码中,我从一个SQL表读入一个pandas数据帧,并需要一个列,将每个日期的日期更改为15日.

import numba
import numpy as np
import pandas as pd
import datetime

mydates =np.array(['2010-01-01','2011-01-02']).astype('datetime64[D]')
df=pd.DataFrame()
df["rawdate"]=mydates
df["month_15"] = df["rawdate"].apply(lambda r: datetime.date( r.year, r.month,15 ) )

dates_input = df["month_15"].astype('datetime64[D]')
print dates_input.dtype # Why datetime64[ns] and not datetime64[D] ??


@numba.jit(nopython=True)
def testf(dates):
    return 1

print testf(mydates)

我跑的错误testdf(dates_input)是:

numba.typeinfer.TypingError: Failed at nopython (nopython frontend)
Var 'dates' unified to object: dates := {pyobject}

我无法弄清楚为什么numba在这里击败numpy(超过3x).我是否在这里进行基准测试时遇到了一些根本性的错误？看起来像numpy的完美情况,不是吗？请注意,作为一个检查,我还运行了一个组合numba和numpy(未显示)的变体,正如预期的那样,与没有numba的numpy相同.

(顺便说一下这是一个后续问题:数字处理2d阵列的最快方法:数据帧vs系列vs阵列vs numba)

import numpy as np
from numba import jit
nobs = 10000 

def proc_numpy(x,y,z):

   x = x*2 - ( y * 55 )      # these 4 lines represent use cases
   y = x + y*2               # where the processing time is mostly
   z = x + y + 99            # a function of, say, 50 to 200 lines
   z = z * ( z - .88 )       # of fairly simple numerical operations

   return z

@jit …

我想在不使用numpy.linalg.inv的情况下反转矩阵.

原因是我使用Numba加速代码,但是不支持numpy.linalg.inv,所以我想知道我是否可以使用'经典'Python代码反转矩阵.

使用numpy.linalg.inv,示例代码如下所示:

import numpy as np
M = np.array([[1,0,0],[0,1,0],[0,0,1]])
Minv = np.linalg.inv(M)

有人可以帮我改写这个函数(doTheMath函数)来在GPU上进行计算吗？我现在用了好几天试图绕过它,但没有结果.我想也许有人可以帮助我以你认为适合作为日志的任何方式重写这个函数,因为我在最后给出了相同的结果.我试图使用@jitfrom numba但由于某种原因,它实际上比常规运行代码慢得多.由于样本量很大,我们的目标是大大缩短执行时间,因此我相信GPU是最快的方法.

我会解释一下实际发生的事情.实际数据看起来几乎与下面代码中创建的样本数据完全相同,每个样本分为大约5.000.000行的样本大小或每个文件大约150MB.总共有大约600.000.000行或20GB的数据.我必须循环遍历这些数据,逐个样本然后逐行逐行,从每行中取出最后2000行(或另一行)并运行doTheMath返回结果的函数.然后将该结果保存回硬盘驱动器,我可以使用另一个程序执行其他操作.如下所示,我不需要所有行的所有结果,只需要大于特定数量的行.如果我现在在python中运行我的函数,那么每1.000.000行大约需要62秒.考虑到所有数据以及应该用多快的速度,这是一段很长的时间.

我必须提一下,我借助于文件将真实数据文件上传到RAM,data = joblib.load(file)因此上传数据不是问题,因为每个文件只需要大约0.29秒.上传后,我运行下面的整个代码.花费最长时间的是doTheMath功能.我愿意将我在stackoverflow上获得的所有500个声望点作为奖励给那些愿意帮我重写这个简单代码以在GPU上运行的人.我的兴趣特别在于GPU,我真的很想看看它是如何解决这个问题的.

编辑/更新1: 这是一个指向真实数据的小样本的链接:data_csv.zip大约102000行真实数据1和2000行用于真实数据2a和data2b.用于minimumLimit = 400实际样本数据

编辑/更新2: 对于这篇文章后面的人,这里是以下答案的简短摘要.到目前为止,我们对原始解决方案有4个答案.@Divakar提供的那个只是对原始代码的调整.在这两个调整中,只有第一个实际上适用于这个问题,第二个是一个很好的调整但不适用于此.在其他三个答案中,其中两个是基于CPU的解决方案和一个tensorflow-GPU尝试.Paul Panzer的Tensorflow-GPU似乎很有前景,但是当我在GPU上实际运行它时它比原来慢,所以代码仍然需要改进.

另外两个基于CPU的解决方案由@PaulPanzer(一个纯粹的numpy解决方案)和@MSeifert(一个numba解决方案)提交.与原始代码相比,这两种解决方案都能提供非常好的结果和两种处理数据.在Paul Panzer提交的两个中,速度更快.它在大约3秒内处理大约1.000.000行.唯一的问题是较小的batchSizes,这可以通过切换到MSeifert提供的numba解决方案,或者甚至是在下面讨论的所有调整之后的原始代码来克服.

我非常高兴并感谢@PaulPanzer和@MSeifert所做的关于他们答案的工作.不过,由于这是一个关于基于GPU的解决方案的问题,我等着看是否有人愿意尝试GPU版本,看看与当前的CPU相比,GPU上的数据处理速度有多快解决方案.如果没有其他答案胜过@PaperPanzer的纯粹numpy解决方案那么我会接受他的答案作为正确的答案并得到赏金:)

编辑/更新3: @Divakar已经发布了一个新的答案与GPU的解决方案.在对真实数据进行测试之后,速度甚至与CPU对应解决方案无法相比.GPU在大约1.5秒内处理大约5.000.000.这太不可思议了:)我对GPU解决方案感到非常兴奋,感谢@Divakar发布它.我感谢@PaulPanzer和@MSeifert的CPU解决方案:)现在我的研究继续以令人难以置信的速度归功于GPU :)

import pandas as pd
import numpy as np
import time

def doTheMath(tmpData1, data2a, data2b):
    A = tmpData1[:, 0]
    B = tmpData1[:,1]
    C = tmpData1[:,2]
    D = tmpData1[:,3]
    Bmax = B.max()
    Cmin  = C.min()
    dif = (Bmax - Cmin)
    abcd = ((((A - Cmin) / …

我试图运行下面的代码,但报告错误:

NvvmSupportError:找不到libNVVM.执行conda install cudatoolkit:找不到库nvvm

我的开发环境是:Ubuntu 17.04,Spyder/Python3.5,我通过conda(numba和cudatoolkit)安装.Nvidia GPU(GTX 1070和GTX 1060).

import numpy as np
from timeit import default_timer as timer
from numba import vectorize

@vectorize(["float32(float32, float32)"], target='cuda')     
def VecADD(a,b):
    return a+b        

n = 32000000
a = np.ones (n, dtype=np.float32) 
b = np.ones (n, dtype=np.float32)     
c = np.zeros(n, dtype=np.float32) 

start = timer()
C = VecADD(a,b)
print (timer() - start)

有谁知道如何解决这个问题？

我有一些简单的代码,可以执行以下操作.

它F使用+ -1条目迭代所有可能的长度n列表.对于每一个,它使用+ -1条目迭代所有可能的长度2n列表S,其中$ S $的前半部分只是下半部分的副本.代码计算F每个S长度子列表的内积n.对于每个F,S,它计算在第一个非零内积之前为零的内积.

这是代码.

#!/usr/bin/python

from __future__ import division
import itertools
import operator
import math

n=14
m=n+1
def innerproduct(A, B):
    assert (len(A) == len(B))
    s = 0 
    for k in xrange(0,n):
        s+=A[k]*B[k]
    return s

leadingzerocounts = [0]*m
for S in itertools.product([-1,1], repeat = n):
    S1 = S + S
    for F in itertools.product([-1,1], repeat = n):
        i = 0
        while (i<m):
            ip = innerproduct(F, S1[i:i+n]) …

我想了解当使用Numba来加速numpyfor循环中的纯代码时,收益来自哪里.是否有任何分析工具可以让您查看jitted功能？

演示代码(如下所示)只是使用非常基本的矩阵乘法来为计算机提供工作.观察到的收益来自:

1. 更快loop,
2. 重新编译在编译过程中numpy截获的函数jit,或者
3. jitnumpy外包通过包装函数执行到低级库的开销较少LINPACK

%matplotlib inline
import numpy as np
from numba import jit
import pandas as pd

#Dimensions of Matrices
i = 100 
j = 100

def pure_python(N,i,j):
    for n in range(N):
        a = np.random.rand(i,j)
        b = np.random.rand(i,j)
        c = np.dot(a,b)

@jit(nopython=True)
def jit_python(N,i,j):
    for n in range(N):
        a = np.random.rand(i,j)
        b = np.random.rand(i,j)
        c = np.dot(a,b)

time_python = []
time_jit = []
N = [1,10,100,500,1000,2000] …