我想尽可能地加快余弦距离计算scipy.spatial.distance.cosine，所以我尝试使用numpy
def alt_cosine(x,y):
return 1 - np.inner(x,y)/np.sqrt(np.dot(x,x)*np.dot(y,y))
我尝试了 cython
from libc.math cimport sqrt
def alt_cosine_2(x,y):
return 1 - np.inner(x,y)/sqrt(np.dot(x,x)*np.dot(y,y))
并逐步获得改进（在长度为50的numpy数组上进行测试）
>>> cosine() # ... make some timings
5.27526156300155e-05 # mean calculation time for one loop
>>> alt_cosine()
9.913400815003115e-06
>>> alt_cosine_2()
7.0269494536660205e-06
最快的方法是什么？不幸的是，我无法将变量类型指定为alt_cosine_2，我将将此函数与类型为{{1}的numpy数组一起使用}
答案 0 :(得分：6)
有一种信念认为，无法在cython或numba的帮助下加快numpy的功能。但这并非完全正确：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-300 ns：其他所有事情都是调用函数的开销。减少开销的一种可能是在cython的帮助下“手动”插入这些功能：
%%cython
from libc.math cimport sqrt
import numpy as np
cimport numpy as np
def cy_cosine(np.ndarray[np.float64_t] x, np.ndarray[np.float64_t] y):
cdef double xx=0.0
cdef double yy=0.0
cdef double xy=0.0
cdef Py_ssize_t i
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/sqrt(xx*yy)
导致：
>>> %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)
与原始numpy版本相比，速度提高了8。
numba可以更快的原因有很多：Cython在prevents some optimization的运行时间内处理数据的步幅（例如矢量化）。 Numba似乎处理得更好。
但是这里的差异完全是由于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内联其他jited函数，但它也能够以很少的开销调用一些numpy函数，因此以下版本（将inner替换为dot）：< / p>
@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（或类似形式）实现，并且将轻松击败我们的简单尝试。
这引起了一个问题：为特殊大小的输入优化代码真的值得吗？有时答案是“是”，有时答案是“否”。
如果可能的话，我会使用numba + dot解决方案，该解决方案对于较小的输入非常快，但对于较大的输入也具有mkl实现的全部功能。
也有一些区别：第一个版本返回一个np.float64对象，而cython和numba版本返回一个Python浮点型。
列表：
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))
答案 1 :(得分：2)