किस तरीके से मैं जूलिया फंक्शन को बेंचमार्क कर सकता हूं?

Question

पृष्ठभूमि

मैंने खुद को मशीन लर्निंग सिखाया है और हाल ही में जूलिया मशीन लर्निंग इकोसिस्टम में डील करना शुरू किया है।

---

एक अजगर पृष्ठभूमि से आ रहा है और कुछ Tensorflow और OpenCV / skimageअनुभव होने के कारण, मैं जूलिया ML पुस्तकालयों (फ्लक्स / JuliaImages) को अपने समकक्षों के खिलाफ देखना चाहता हूं कि यह कितनी तेजी से या धीमी गति से CV (कोई भी) कार्य करता है और यदि निर्णय लेना है तो मुझे जूलिया का उपयोग करना चाहिए।

मुझे पता है कि timeitइस तरह से मॉड्यूल का उपयोग करके अजगर में एक फ़ंक्शन को निष्पादित करने के लिए समय कैसे प्राप्त किया जाए :

#Loading an Image using OpenCV

s = """\
img = cv2.imread('sample_image.png', 1)
"""
setup = """\
import timeit
"""
print(str(round((timeit.timeit(stmt = s, setup = setup, number = 1))*1000, 2)) + " ms")
#printing the time taken in ms rounded to 2 digits

जूलिया में एक ही कार्य करने वाले फ़ंक्शन के निष्पादन समय की तुलना उचित पुस्तकालय (इस मामले में JuliaImages) का उपयोग करके कैसे की जाती है ।

क्या जूलिया समय / बेंचमार्क को कोई फ़ंक्शन / मैक्रो प्रदान करता है?

Answer 1

using BenchmarkToolsजूलिया कार्यों को बेंचमार्क करने के लिए अनुशंसित तरीका है। जब तक आप किसी ऐसी चीज को टाइम नहीं कर रहे हैं, जो कि काफी समय लेती है, @benchmarkया तो या उससे कम वर्बोज़ @btimeमैक्रोज़ का उपयोग करें । क्योंकि इन मैक्रो के पीछे की मशीनरी कई बार लक्ष्य फ़ंक्शन का मूल्यांकन करती है, @timeबेंचमार्किंग चीजों के लिए उपयोगी है जो धीरे-धीरे चलती हैं (जैसे कि डिस्क एक्सेस या बहुत समय लेने वाली गणना शामिल हैं)।

इसका उपयोग @btimeया @benchmarkसही तरीके से करना महत्वपूर्ण है, यह भ्रामक परिणामों से बचा जाता है। आमतौर पर, आप एक फ़ंक्शन को बेंचमार्क कर रहे हैं जो एक या अधिक तर्क लेता है। बेंचमार्किंग करते समय, सभी तर्क बाहरी चर होने चाहिए: (बेंचमार्क मैक्रो के बिना)

x = 1
f(x)
# do not use f(1)

फ़ंक्शन का मूल्यांकन कई बार किया जाएगा। जब भी फ़ंक्शन का मूल्यांकन किया जाता है, तब फ़ंक्शन तर्कों को फिर से मूल्यांकन करने से रोकने के लिए, हमें प्रत्येक तर्क $को प्रत्येक चर के नाम से प्रीफ़िक्स करके एक तर्क के रूप में उपयोग किया जाता है। बेंचमार्किंग मैक्रोज़ इसका उपयोग यह इंगित करने के लिए करते हैं कि बेंचमार्किंग प्रक्रिया की शुरुआत में चर का मूल्यांकन (हल) एक बार किया जाना चाहिए, और फिर इसका परिणाम सीधे रूप में उपयोग किया जाना है:

julia> using BenchmarkTools
julia> a = 1/2;
julia> b = 1/4;
julia> c = 1/8;
julia> a, b, c
(0.5, 0.25, 0.125)

julia> function sum_cosines(x, y, z)
         return cos(x) + cos(y) + cos(z)
       end;

julia> @btime sum_cosines($a, $b, $c);  # the `;` suppresses printing the returned value
  11.899 ns (0 allocations: 0 bytes)    # calling the function takes ~12 ns (nanoseconds)
                                        # the function does not allocate any memory

# if we omit the '$', what we see is misleading
julia> @btime sum_cosines(a, b, c);    # the function appears more than twice slower 
 28.441 ns (1 allocation: 16 bytes)    # the function appears to be allocating memory

# @benchmark can be used the same way that @btime is used
julia> @benchmark sum_cosines($a,$b,$c) # do not use a ';' here
BenchmarkTools.Trial:
  memory estimate:  0 bytes
  allocs estimate:  0
  --------------
  minimum time:     12.111 ns (0.00% GC)
  median time:      12.213 ns (0.00% GC)
  mean time:        12.500 ns (0.00% GC)
  maximum time:     39.741 ns (0.00% GC)
  --------------
  samples:          1500
  evals/sample:     999

जबकि पैरामीटर समायोजित किए जा सकते हैं, डिफ़ॉल्ट मान आमतौर पर अच्छी तरह से काम करते हैं। अनुभवी ursers के लिए बेंचमार्कटल्स के बारे में अतिरिक्त जानकारी के लिए, मैनुअल देखें ।

Answer 2

जूलिया टाइमिंग / बेंचमार्किंग कोड रनटाइम के लिए दो मैक्रो प्रदान करता है। य़े हैं :

• @समय
• @ चिह्न : बाहरी, द्वारा स्थापितPkg.add("BenchmarkTools")

बेंचमार्कटूल का उपयोग करना @benchmark बहुत आसान है और दो भाषाओं की गति की तुलना करने में आपके लिए मददगार होगा। @bencharkआपके द्वारा दिए गए अजगर बेंच के खिलाफ उपयोग करने का उदाहरण ।

using Images, FileIO, BenchmarkTools

@benchmark img = load("sample_image.png")

आउटपुट:

BenchmarkTools.Trial: 
  memory estimate:  3.39 MiB
  allocs estimate:  322
  --------------
  minimum time:     76.631 ms (0.00% GC)
  median time:      105.579 ms (0.00% GC)
  mean time:        110.319 ms (0.41% GC)
  maximum time:     209.470 ms (0.00% GC)
  --------------
  samples:          46
  evals/sample:     1

मतलब समय के लिए तुलना करने के लिए, आपको samplesअपने अजगर समयसीमा कोड में संख्या (46) डालनी चाहिए और निष्पादन के औसत समय को प्राप्त करने के लिए इसे उसी संख्या से विभाजित करना चाहिए।

print(str(round((timeit.timeit(stmt = s, setup = setup, number = 46)/46)*1000, 2)) + " ms")

आप जूलिया और पायथन दोनों में किसी भी फ़ंक्शन को बेंचमार्क करने के लिए इस प्रक्रिया का पालन कर सकते हैं। मुझे आशा है कि आप संदेह कर रहे हैं।

---

नोट : एक सांख्यिकीय दृष्टिकोण से, @benchmark, @time से काफी बेहतर है।

Comments

ध्यान दें कि समय का शोर ज्यादातर सकारात्मक होता है, जिसका अर्थ है कि न्यूनतम समय अक्सर (हमेशा नहीं) अधिक जानकारीपूर्ण होता है। @btimeऔर @belapsedकेवल न्यूनतम समय वापस करें।

— फ्रेड्रिक बैज