有一种观点认为，numpy的功能不能在cython或numba的帮助下加速。但这并不完全正确：numpy的目标是为各种场景提供出色的性能，但这也意味着在特殊场景下的性能并不完美。在

有了特定的场景，您就有机会改进numpy的性能，即使这意味着要重写numpy的一些功能。例如，在本例中，我们可以使用cython将函数加速到因子4，使用numba可以将因子8加速。在

让我们从您的版本开始作为基线(请参阅答案末尾的列表)：>>>%timeit cosine(x,y) # scipy's

31.9 µs ± 1.81 µs per loop (mean ± std. dev. of 7 runs, 10000 loops each)

>>>%timeit np_cosine(x,y) # your numpy-version

4.05 µs ± 19.2 ns per loop (mean ± std. dev. of 7 runs, 100000 loops each)

%timeit np_cosine_fhtmitchell(x,y) # @FHTmitchell's version

4 µs ± 53.7 ns per loop (mean ± std. dev. of 7 runs, 100000 loops each)

>>>%timeit np_cy_cosine(x,y)

2.56 µs ± 123 ns per loop (mean ± std. dev. of 7 runs, 100000 loops each)

所以我看不到@FHTmitchell版本的改进，但其他方面与您的时间安排没有什么不同。在

向量只有50个元素，所以实际计算需要大约200-300ns：其他的都是调用函数的开销。降低开销的一种可能性是在cython的帮助下每只手“内联”这些函数：

^{pr2}$

这导致：>>> %timeit cy_cosine(x,y)

921 ns ± 19.5 ns per loop (mean ± std. dev. of 7 runs, 1000000 loops each)

不错！我们可以通过进行以下更改来放弃一些安全性(运行时检查+ieee-754标准)来尝试挤出更多的性能：%%cython -c=-ffast-math

...

cimport cython

@cython.boundscheck(False)

@cython.wraparound(False)

def cy_cosine_perf(np.ndarray[np.float64_t] x, np.ndarray[np.float64_t] y):

...

这导致：>>> %timeit cy_cosine_perf(x,y)

828 ns ± 17.6 ns per loop (mean ± std. dev. of 7 runs, 1000000 loops each)

也就是说，再增加10%，这意味着比numpy版本快5倍。在

还有另一个提供类似功能/性能的工具-numba：import numba as nb

import numpy as np

@nb.jit(nopython=True, fastmath=True)

def nb_cosine(x, y):

xx,yy,xy=0.0,0.0,0.0

for i in range(len(x)):

xx+=x[i]*x[i]

yy+=y[i]*y[i]

xy+=x[i]*y[i]

return 1.0-xy/np.sqrt(xx*yy)

这导致：>>> %timeit nb_cosine(x,y)

495 ns ± 5.9 ns per loop (mean ± std. dev. of 7 runs, 1000000 loops each)

一个提速8比原来的纽比版本。在

numba速度更快的原因有很多：Cython在运行时处理数据的步幅，prevents some optimization(例如矢量化)。麻木似乎处理得更好。在

但这里的差异完全是由于numba的开销较少：%%cython -c=-ffast-math

import numpy as np

cimport numpy as np

def cy_empty(np.ndarray[np.float64_t] x, np.ndarray[np.float64_t] y):

return x[0]*y[0]

import numba as nb

import numpy as np

@nb.jit(nopython=True, fastmath=True)

def nb_empty(x, y):

return x[0]*y[0]

%timeit cy_empty(x,y)

753 ns ± 6.81 ns per loop (mean ± std. dev. of 7 runs, 1000000 loops each)

%timeit nb_empty(x,y)

456 ns ± 2.47 ns per loop (mean ± std. dev. of 7 runs, 1000000 loops each)

对numba来说，几乎减少了2倍的开销！在

正如@max9111所指出的，numpy内联了其他jitted函数，但它也能够以很少的开销调用一些numpy函数，因此以下版本(将inner替换为dot)：@nb.jit(nopython=True, fastmath=True)

def np_nb_cosine(x,y):

return 1 - np.dot(x,y)/sqrt(np.dot(x,x)*np.dot(y,y))

>>> %timeit np_nb_cosine(x,y)

605 ns ± 5.9 ns per loop (mean ± std. dev. of 7 runs, 1000000 loops each)

只慢了大约10%。在

请注意，上述比较仅适用于含有50个元素的向量。对于更多的元素，情况就完全不同了：numpy版本使用了并行化的mkl(或类似的)dot产品实现，并将轻松击败我们简单的尝试。在

这就引出了一个问题：针对特定大小的输入优化代码真的值得吗？有时答案是“是”，有时答案是“否”。在

如果可能的话，我会得到numba+dot的解决方案，对于小输入非常快，但是对于较大的输入，它也具有mkl实现的全部功能。在

还有一点区别：第一个版本返回np.float64-对象，cython和numba版本返回Python float。在

列表：from scipy.spatial.distance import cosine

import numpy as np

x=np.arange(50, dtype=np.float64)

y=np.arange(50,100, dtype=np.float64)

def np_cosine(x,y):

return 1 - inner(x,y)/sqrt(np.dot(x,x)*dot(y,y))

from numpy import inner, sqrt, dot

def np_cosine_fhtmitchell(x,y):

return 1 - inner(x,y)/sqrt(np.dot(x,x)*dot(y,y))

%%cython

from libc.math cimport sqrt

import numpy as np

def np_cy_cosine(x,y):

return 1 - np.inner(x,y)/sqrt(np.dot(x,x)*np.dot(y,y))