Czy splot jest wolniejszy w Numpy niż w Matlab?

Question

Konwolucji w Matlab wydaje się być dwa razy szybciej niż splot w Numpy.

kod Pythona (trwa 19 sekund w moim urządzenia):

import numpy as np 
from scipy import ndimage 
import time 

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

start_time = time.time() 
ndimage.convolve(img,kernel,mode='constant') 
print "Numpy execution took ", (time.time() - start_time), "seconds" 

kod Matlab (trwa 8,7 sekundy w moim urządzenia):

img = ones(512,512,512); 
kernel = ones(5,5,5)/125; 
tic 
convn(img, kernel, 'same'); 
toc 

Oba dają identyczne wyniki.

Czy istnieje sposób na poprawę Numpy, aby dopasować lub pokonać wydajność Matlaba tutaj?

Co ciekawe, ten współczynnik lub ~ 2 różnica w czasie wykonywania jest stała przy wielu wejściach.

Answer 1

Nie anwer; tylko komentarz:

Przed porównać wydajność, trzeba upewnić się, że te dwie funkcje są wraca ten sam wynik:

Jeśli convn MATLAB wraca ten sam rezultat jak convn oktawy, a następnie convn jest inna niż 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 ma innych trybach 'reflect','constant','nearest','mirror', 'wrap', ale żaden ("full") zachowania te mecze convn „s domyślny.

---

Na tablicach 2D scipy.signal.convolve2d jest szybszy niż scipy.signal.convolve.

Dla tablic 3D scipy.signal.convolve wydaje się mieć takie samo zachowanie jak 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) 

---

Zauważ, że np.ones((n,m,p)) tworzy pływaka tablicę domyślnie. Matlab ones(n,m,p) wydaje się tworzyć tablicę intów. Aby dokonać dobrego porównania, powinieneś spróbować dopasować typ dtype z tablic numpy do typu macierzy Matlaba.

Answer 2

Jaką dokładnie operację wykonujesz? Istnieje wiele optymalizacji, które zapewnia ndimage, jeśli nie potrzebujesz ogólnego splotu N-d.

Na przykład, aktualna praca:

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

odpowiada:

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

Istnieje jednak duża różnica w szybkości wykonania:

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 

Różnica jest spowodowana przez uniform_filter preforming 1-d splotu wzdłuż każdej osi, zamiast ogólnej 3 D splot.

W przypadkach, w których jądro jest symetryczne, można wprowadzić te uproszczenia i uzyskać znaczące przyspieszenie.

Nie mam pewności co do convn, ale często funkcje Matlaba powodują, że tego rodzaju optymalizacje odbywają się za kulisami, jeśli dane wejściowe pasują do określonych kryteriów. Scipy częściej korzysta z jednego algorytmu na funkcję i oczekuje, że użytkownik dowie się, który z nich wybrać w danym przypadku.

---

Wspomniałeś filtr "Laplacian of Gaussian". Zawsze mam tutaj pojęcie mylące z terminologią.

myślę, co chcesz pod względem ndimage funkcji jest albo scipy.ndimage.gaussian_laplace lub scipy.ndimage.gaussian_filter z order=2 (który filtruje przez drugą pochodną Gaussa).

W każdym razie oba uproszczają operację do 1-d splotu na każdą oś, co powinno dać znaczące (2-3x) przyspieszenie.