रेपा 2 और 3 एपीआई के बीच महत्वपूर्ण अंतर क्या हैं?

Question

अधिक विशिष्ट होना करने के लिए, मैं निम्नलिखित अहानिकर दिखने थोड़ा Repa 3 कार्यक्रम है:

{-# LANGUAGE QuasiQuotes #-} 

import Prelude hiding (map, zipWith) 
import System.Environment (getArgs) 
import Data.Word (Word8) 
import Data.Array.Repa 
import Data.Array.Repa.IO.DevIL 
import Data.Array.Repa.Stencil 
import Data.Array.Repa.Stencil.Dim2 

main = do 
    [s] <- getArgs 
    img <- runIL $ readImage s 

    let out = output x where RGB x = img 
    runIL . writeImage "out.bmp" . Grey =<< computeP out 

output img = map cast . blur . blur $ blur grey 
    where 
    grey    = traverse img to2D luminance 
    cast n   = floor n :: Word8 
    to2D (Z:.i:.j:._) = Z:.i:.j 

--------------------------------------------------------------- 

luminance f (Z:.i:.j) = 0.21*r + 0.71*g + 0.07*b :: Float 
    where 
    (r,g,b) = rgb (fromIntegral . f) i j 

blur = map (/ 9) . convolve kernel 
    where 
    kernel = [stencil2| 1 1 1 
         1 1 1 
         1 1 1 |] 

convolve = mapStencil2 BoundClamp 

rgb f i j = (r,g,b) 
    where 
    r = f $ Z:.i:.j:.0 
    g = f $ Z:.i:.j:.1 
    b = f $ Z:.i:.j:.2 

कौन इतना समय मेरी 2 है GHZ कोर 2 डुओ लैपटॉप पर एक 640x420 छवि पर कार्रवाई करने लगते हैं:

real 2m32.572s 
user 4m57.324s 
sys  0m1.870s 

मुझे पता है कि कुछ गलत होना चाहिए, क्योंकि मुझे रिपा 2 का उपयोग करके अधिक जटिल एल्गोरिदम पर बहुत बेहतर प्रदर्शन प्राप्त हुआ है। उस एपीआई के तहत, मैंने पाया कि बड़ा सुधार प्रत्येक सरणी परिवर्तन से पहले 'बल' पर कॉल जोड़ने से आया था (जिसे मैं नक्शा, संकल्प, ट्रैवर्स इत्यादि के लिए हर कॉल का मतलब समझें)। मैं रेपा 3 में समान रूप से काम करने के लिए काफी कुछ नहीं कर सकता - वास्तव में मैंने सोचा कि नया अभिव्यक्ति प्रकार पैरामीटर यह सुनिश्चित करना है कि किसी सरणी को मजबूर करने की आवश्यकता होने पर कोई अस्पष्टता नहीं है? और इस योजना में नया monadic इंटरफ़ेस कैसे फिट है? मैंने डॉन एस द्वारा अच्छा ट्यूटोरियल पढ़ा है, लेकिन रेपा 2 और 3 एपीआई के बीच कुछ महत्वपूर्ण अंतराल हैं जिन पर ऑनलाइन AFAIK पर चर्चा नहीं की गई है।

अधिक सरल, क्या उपर्युक्त प्रोग्राम की दक्षता को ठीक करने के लिए एक न्यूनतम प्रभावशाली तरीका है?

Answer 1

नए प्रतिनिधित्व प्रकार पैरामीटर आवश्यक होने पर स्वचालित रूप से बल नहीं देते हैं (शायद यह अच्छी तरह से करने में एक कठिन समस्या है) - आपको अभी भी मैन्युअल रूप से मजबूर होना होगा।

computeP 
    :: (Monad m, Repr r2 e, Fill r1 r2 sh e) 
    => Array r1 sh e -> m (Array r2 sh e) 

मैं व्यक्तिगत रूप से वास्तव में समझने के नहीं क्यों यह monadic है, क्योंकि आप बस के रूप में अच्छी तरह से इकाई पहचान का उपयोग कर सकते हैं:: Repa 3 में इस computeP समारोह के साथ किया जाता

import Control.Monad.Identity (runIdentity) 
force 
    :: (Repr r2 e, Fill r1 r2 sh e) 
    => Array r1 sh e -> Array r2 sh e 
force = runIdentity . computeP 

तो, अब आपके output समारोह उचित मजबूर कर के साथ फिर से लिखा जा सकता है:

output img = map cast . f . blur . f . blur . f . blur . f $ grey 
    where ... 

एक संक्षिप्त नाम f साथ

सहायता करने के लिए एक सहायक समारोह u का उपयोग कर प्रकार निष्कर्ष:

u :: Array U sh e -> Array U sh e 
u = id 
f = u . force 

इन परिवर्तनों के साथ

, speedup काफी नाटकीय है - है, जो उम्मीद की जा करने के लिए है के लिए मजबूर कर मध्यवर्ती बिना के रूप में प्रत्येक उत्पादन पिक्सेल भी बहुत कुछ का मूल्यांकन की तुलना में आवश्यक है समाप्त होता है (मध्यवर्ती के मूल्यों को साझा नहीं कर रहे हैं) ।

आपका मूल कोड:

real 0m25.339s 
user 1m35.354s 
sys  0m1.760s 

मजबूर कर के साथ:

real 0m0.130s 
user 0m0.320s 
sys  0m0.028s 

एक 600x400 png साथ परीक्षण किया गया, आउटपुट फाइलों समान थे।

Answer 2

computeP नया force है।

Repa 3 में आप हर जगह आप Repa 2.

में force इस्तेमाल किया है | repa-उदाहरण से Laplace उदाहरण आप क्या कर रहे के समान है computeP उपयोग करने के लिए की जरूरत है। आपको अपने blur फ़ंक्शन में सादे map के बजाय cmap का भी उपयोग करना चाहिए। अगले सप्ताह के शुरू में मेरे मुखपृष्ठ पर क्यों एक पेपर समझा जाएगा।