Свертка в Numpy медленнее, чем в Matlab?

Какую именно операцию вы делаете? Есть ряд оптимизаций, которые ndimage предоставляет, если вам не нужна общая N-d свертка.

Например, ваша текущая операция:

img = np.ones((512,512,512))
kernel = np.ones((5,5,5))/125
result = ndimage.convolve(img, kernel)

эквивалентно:

img = np.ones((512,512,512))
result = ndimage.uniform_filter(img, 5)

Однако есть большая разница в скорости выполнения:

In [22]: %timeit ndimage.convolve(img, kernel)
1 loops, best of 3: 25.9 s per loop

In [23]: %timeit ndimage.uniform_filter(img, 5)
1 loops, best of 3: 8.69 s per loop

Разница вызвана uniform_filter предварительным формированием одномерной свертки вдоль каждой оси вместо обычной трехмерной свертки.

В случаях, когда ядро ​​симметрично, вы можете сделать эти упрощения и получить значительное ускорение.

Я не уверен насчет convn, но часто функции Matlab выполняют такую ​​оптимизацию за кулисами, если ваши входные данные соответствуют определенным критериям. Scipy чаще использует один алгоритм для каждой функции и ожидает, что пользователь знает, какой из них выбрать в каком случае.

Вы упомянули фильтр «лапласиан гаусса». Я всегда путаюсь с терминологией здесь.

Я думаю, что вы хотите с точки зрения ndimage функций либо scipy.ndimage.gaussian_laplace или scipy.ndimage.gaussian_filter с order=2 (что фильтрует по второй производной гауссова).

Во всяком случае, оба упрощают операцию вплоть до одномерной свертки по каждой оси, что должно дать значительное (в 2-3 раза) ускорение.

Не ответ; просто комментарий:

Прежде чем сравнивать производительность, нужно убедиться, что две функции возвращают один и тот же результат:

Если convn Matlab возвращает тот же результат, что и convn Octave, то convn отличается от ndimage.convolve:

octave> convn(ones(3,3), ones(2,2))
ans =

   1   2   2   1
   2   4   4   2
   2   4   4   2
   1   2   2   1

In [99]: ndimage.convolve(np.ones((3,3)), np.ones((2,2)))
Out[99]: 
array([[ 4.,  4.,  4.],
       [ 4.,  4.,  4.],
       [ 4.,  4.,  4.]])

ndimage.convolve имеет другие режимы, 'reflect','constant','nearest','mirror', 'wrap', но ни один из них не соответствует поведению convn по умолчанию ("полному").

Для двумерных массивов scipy.signal.convolve2d быстрее, чем scipy.signal.convolve.

Для 3D-массивов scipy.signal.convolve ведет себя так же, как convn(A,B):

octave> x = convn(ones(3,3,3), ones(2,2,2))
x =

ans(:,:,1) =

   1   2   2   1
   2   4   4   2
   2   4   4   2
   1   2   2   1

ans(:,:,2) =

   2   4   4   2
   4   8   8   4
   4   8   8   4
   2   4   4   2

ans(:,:,3) =

   2   4   4   2
   4   8   8   4
   4   8   8   4
   2   4   4   2

ans(:,:,4) =

   1   2   2   1
   2   4   4   2
   2   4   4   2
   1   2   2   1

In [109]: signal.convolve(np.ones((3,3,3), dtype='uint8'), np.ones((2,2,2), dtype='uint8'))
Out[109]: 
array([[[1, 2, 2, 1],
        [2, 4, 4, 2],
        [2, 4, 4, 2],
        [1, 2, 2, 1]],

       [[2, 4, 4, 2],
        [4, 8, 8, 4],
        [4, 8, 8, 4],
        [2, 4, 4, 2]],

       [[2, 4, 4, 2],
        [4, 8, 8, 4],
        [4, 8, 8, 4],
        [2, 4, 4, 2]],

       [[1, 2, 2, 1],
        [2, 4, 4, 2],
        [2, 4, 4, 2],
        [1, 2, 2, 1]]], dtype=uint8)

Обратите внимание, что np.ones((n,m,p)) по умолчанию создает массив float. Matlab ones(n,m,p) создает массив целых чисел. Чтобы сделать хорошее сравнение, вы должны попытаться сопоставить dtype массивов numpy с типом матриц Matlab.