Скорость Numpy против Cython

Как упоминалось в других ответах, версия 2 по существу такая же, как и версия 1, поскольку cython не может копаться в операторе доступа к массиву, чтобы оптимизировать его. На это есть 2 причины

• Во-первых, при каждом вызове функции numpy возникает определенное количество накладных расходов по сравнению с оптимизированным кодом C. Однако эти накладные расходы станут менее значительными, если каждая операция будет иметь дело с большими массивами.

• Во-вторых, создание промежуточных массивов. Это станет яснее, если вы рассмотрите более сложную операцию, такую ​​как out[row, :] = A[row, :] + B[row, :]*C[row, :]. В этом случае весь массив B*C должен быть создан в памяти, а затем добавлен к A. Это означает, что кэш ЦП перегружается, так как данные считываются и записываются в память, а не хранятся в ЦП и используются сразу. Важно отметить, что эта проблема усугубляется, если вы имеете дело с большими массивами.

В частности, поскольку вы заявляете, что ваш реальный код сложнее, чем ваш пример, и он показывает гораздо большее ускорение, я подозреваю, что вторая причина, вероятно, будет основным фактором в вашем случае.

Кроме того, если ваши вычисления достаточно просты, вы можете преодолеть этот эффект, используя numexpr, хотя, конечно, cython полезен во многих других ситуациях, поэтому он может быть лучшим подходом для вас.

С небольшой модификацией версия 3 становится вдвое быстрее:

@cython.boundscheck(False)
@cython.wraparound(False)
@cython.nonecheck(False)
def process2(np.ndarray[DTYPE_t, ndim=2] array):

    cdef unsigned int rows = array.shape[0]
    cdef unsigned int cols = array.shape[1]
    cdef unsigned int row, col, row2
    cdef np.ndarray[DTYPE_t, ndim=2] out = np.empty((rows, cols))

    for row in range(rows):
        for row2 in range(rows):
            for col in range(cols):
                out[row, col] += array[row2, col] - array[row, col]

    return out

Узким местом в ваших вычислениях является доступ к памяти. Ваш входной массив имеет порядок C, что означает, что перемещение по последней оси делает наименьший скачок в памяти. Поэтому ваш внутренний цикл должен быть вдоль оси 1, а не оси 0. Внесение этого изменения сокращает время выполнения вдвое.

Если вам нужно использовать эту функцию для небольших входных массивов, вы можете уменьшить накладные расходы, используя np.empty вместо np.ones. Чтобы уменьшить накладные расходы, используйте PyArray_EMPTY из numpy C API.

Если вы используете эту функцию для очень больших входных массивов (2**31), то целые числа, используемые для индексации (и в функции range), переполнятся. Для безопасности используйте:

cdef Py_ssize_t rows = array.shape[0]
cdef Py_ssize_t cols = array.shape[1]
cdef Py_ssize_t row, col, row2

вместо

cdef unsigned int rows = array.shape[0]
cdef unsigned int cols = array.shape[1]
cdef unsigned int row, col, row2

Сроки:

In [2]: a = np.random.rand(10000, 10)
In [3]: timeit process(a)
1 loops, best of 3: 3.53 s per loop
In [4]: timeit process2(a)
1 loops, best of 3: 1.84 s per loop

где process — ваша версия 3.

Я бы рекомендовал использовать флаг -a, чтобы cython сгенерировал html-файл, который показывает, что переводится в чистый c по сравнению с вызовом API python:

http://docs.cython.org/src/quickstart/cythonize.html

Версия 2 дает почти тот же результат, что и Версия 1, потому что вся тяжелая работа выполняется API Python (через numpy), а cython ничего не делает для вас. На самом деле на моей машине numpy построен против MKL, поэтому, когда я компилирую сгенерированный cython код c с помощью gcc, версия 3 на самом деле немного медленнее, чем две другие.

Cython сияет, когда вы выполняете манипуляции с массивом, которые numpy не может выполнять «векторизованным» способом, или когда вы делаете что-то интенсивное с памятью, что позволяет избежать создания большого временного массива. Я получил 115-кратное ускорение, используя cython vs numpy для некоторого моего собственного кода:

https://github.com/synapticarbors/pylangevin-integrator

Частично это вызывало каталог randomkit на уровне кода c вместо вызова его через numpy.random, но большая часть этого заключалась в том, что cython переводил циклы for, требующие больших вычислительных ресурсов, в чистый c без вызовов python.

Разница может быть связана с тем, что версии 1 и 2 выполняют вызов np.sum() на уровне Python для каждой строки, в то время как версия 3, скорее всего, компилируется в плотный, чистый цикл C.

Изучение различий между версией 2 и версией 3, созданным Cython, исходным кодом C должно быть поучительным.

Я предполагаю, что основные накладные расходы, которые вы экономите, - это созданные временные массивы. Вы создаете очень большой массив array - array[row, :], а затем уменьшаете его до меньшего массива, используя sum. Но создание этого большого временного массива не будет бесплатным, особенно если вам нужно выделить память.