Matlab की तुलना में Numpy में संकल्प धीमा है?

Question

Matlab में कनवॉल्यूशन Numpy में दृढ़ता के रूप में दोगुनी तेजी से प्रतीत होता है।

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" 

मैटलैब कोड (मेरी मशीन पर 8.7 सेकंड लेता है):

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

दो समान परिणाम दे

अजगर कोड (मेरी मशीन पर 19 सेकंड लेता है)।

क्या मैटलैब के प्रदर्शन से मेल खाने या हरा करने के लिए नम्पी सुधारने का कोई तरीका है?

दिलचस्प बात यह है कि रनटाइम्स में यह कारक या ~ 2 अंतर कई इनपुट आकारों में सुसंगत है।

Answer 1

कोई एवर नहीं; बस एक टिप्पणी:

इससे पहले कि आप प्रदर्शन की तुलना, आप सुनिश्चित दो कार्य एक ही परिणाम लौट रहे हैं बनाने की जरूरत है:

मैटलैब का convn, सप्टक के convn रूप में एक ही परिणाम देता है तो convnndimage.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 के डिफ़ॉल्ट ("पूर्ण") व्यवहार से कोई भी नहीं है।

---

2 डी सरणियों के लिए, scipy.signal.convolve2dscipy.signal.convolve से तेज है।

3 डी सरणियों के लिए, scipy.signal.convolveconvn(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)) डिफ़ॉल्ट रूप से एक नाव सरणी पैदा करता है। Matlab ones(n,m,p) इन्स की एक सरणी बनाने के लिए प्रतीत होता है। अच्छी तुलना करने के लिए, आपको मैटलैब मैट्रिस के प्रकार के लिए numpy arrays के dtype से मिलान करने का प्रयास करना चाहिए।

Answer 2

आप क्या सटीक संचालन कर रहे हैं? ऐसे कई अनुकूलन हैं जो ndimage प्रदान करते हैं यदि आपको सामान्य एन-डी संकल्प की आवश्यकता नहीं है।

उदाहरण के लिए, अपने वर्तमान आपरेशन:

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

के बराबर है:

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 

अंतर के कारण होता है:

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

हालांकि, वहाँ निष्पादन की गति में एक बड़े अंतर है uniform_filter द्वारा प्रत्येक अक्ष के साथ 1-डी रूपांतरण को पूर्ववर्ती करने के बजाय, सामान्य 3 डी संकल्प।

ऐसे मामलों में जहां कर्नेल सममित है, आप इन सरलीकरण को बना सकते हैं और एक महत्वपूर्ण गति प्राप्त कर सकते हैं।

मुझे convn के बारे में निश्चित नहीं है, लेकिन अक्सर आपके इनपुट डेटा कुछ मानदंडों से मेल खाते हैं तो मैटलैब के फ़ंक्शन इस तरह के अनुकूलन को पीछे-दृश्य बनाते हैं। Scipy अधिक आम तौर पर एक-एल्गोरिदम-प्रति-फ़ंक्शन का उपयोग करता है, और उम्मीद करता है कि उपयोगकर्ता को यह पता चल जाएगा कि किस मामले में कौन सा चयन करना है।

---

आपने "गॉसियन के लैपलासीन" फ़िल्टर का उल्लेख किया है। मैं हमेशा शब्दावली के साथ उलझन में एक स्पर्श मिलता है।

मुझे लगता है कि तुम क्या ndimage कार्यों के मामले में चाहते हैं या तो scipy.ndimage.gaussian_laplace या order=2 साथ scipy.ndimage.gaussian_filter (जो गाऊसी का दूसरा व्युत्पन्न द्वारा फिल्टर) है।

किसी भी दर पर, ऑपरेशन को प्रत्येक अक्ष पर 1-डी रूपांतरण के लिए सरल बनाते हैं, जो एक महत्वपूर्ण (2-3x) गति प्रदान करना चाहिए।