Alcanzar el rendimiento de Numba con Cython
Por lo general, puedo igualar el rendimiento de Numba cuando uso Cython. Sin embargo, en este ejemplo no he podido hacerlo: Numba es aproximadamente 4 veces más rápido que la versión de mi Cython.
Aquí la versión de Cython:
%%cython -c=-march=native -c=-O3
cimport numpy as np
import numpy as np
cimport cython
@cython.boundscheck(False)
@cython.wraparound(False)
def cy_where(double[::1] df):
cdef int i
cdef int n = len(df)
cdef np.ndarray[dtype=double] output = np.empty(n, dtype=np.float64)
for i in range(n):
if df[i]>0.5:
output[i] = 2.0*df[i]
else:
output[i] = df[i]
return output
Y aquí está la versión de Numba:
import numba as nb
@nb.njit
def nb_where(df):
n = len(df)
output = np.empty(n, dtype=np.float64)
for i in range(n):
if df[i]>0.5:
output[i] = 2.0*df[i]
else:
output[i] = df[i]
return output
Cuando se prueba, la versión de Cython está a la par con la @ de numwhere
, pero es claramente inferior a Numba:
#Python3.6 + Cython 0.28.3 + gcc-7.2
import numpy
np.random.seed(0)
n = 10000000
data = np.random.random(n)
assert (cy_where(data)==nb_where(data)).all()
assert (np.where(data>0.5,2*data, data)==nb_where(data)).all()
%timeit cy_where(data) # 179ms
%timeit nb_where(data) # 49ms (!!)
%timeit np.where(data>0.5,2*data, data) # 278 ms
¿Cuál es la razón del rendimiento de Numba y cómo se puede combinar cuando se usa Cython?
Según lo sugerido por @ max9111, eliminando la zancada mediante el uso de la vista de memoria continua, que no mejora mucho el rendimiento:
@cython.boundscheck(False)
@cython.wraparound(False)
def cy_where_cont(double[::1] df):
cdef int i
cdef int n = len(df)
cdef np.ndarray[dtype=double] output = np.empty(n, dtype=np.float64)
cdef double[::1] view = output # view as continuous!
for i in range(n):
if df[i]>0.5:
view[i] = 2.0*df[i]
else:
view[i] = df[i]
return output
%timeit cy_where_cont(data) # 165 ms