मापने कार्य निष्पादन का समय आर

Question

फ़ंक्शन के निष्पादन समय को मापने के आर में एक मानकीकृत तरीका है?

स्पष्ट रूप से मैं system.timeनिष्पादन से पहले और बाद में ले सकता हूं और फिर उन का अंतर ले सकता हूं, लेकिन मैं जानना चाहूंगा कि क्या कुछ मानकीकृत तरीका या कार्य है (पहिया का आविष्कार नहीं करना चाहते हैं)।

---

मुझे याद है कि मैंने एक बार नीचे की तरह कुछ का उपयोग किया है:

somesysfunction("myfunction(with,arguments)")
> Start time : 2001-01-01 00:00:00  # output of somesysfunction
> "Result" "of" "myfunction"        # output of myfunction
> End time : 2001-01-01 00:00:10    # output of somesysfunction
> Total Execution time : 10 seconds # output of somesysfunction

Comments

मुझे लगता है कि आपके proc.timeमन system.timeमें एक कारण था जो आपको चाहिए।

— मारेक

बड़े कार्यों के लिए, Rprofअच्छा है। यह एक कोड chunk / फ़ंक्शन में सभी प्रक्रियाओं की एक प्रोफ़ाइल प्रदान करता है।

— रिच स्क्रीवेन

नए आर उपयोगकर्ताओं को यह सवाल Google के माध्यम से मिल रहा है: require(microbenchmark)अब (कुछ साल पहले से) सामुदायिक मानक तरीका समय चीजों के लिए। times <- microbenchmark( lm(y~x), glm(y~x), times=1e3); example(microbenchmark)। यह एक करता है सांख्यिकीय की तुलना lmबनाम glmबजाय 1000 से अधिक की कोशिश करता, system.timeकेवल एक बार परीक्षण।

— isomorphismes

उपयोग करें res <- microbenchmark(your code1,your code2)और फिर print(res)एक टेबल ggplot2::autoplot(res)देखने के लिए या एक बॉक्सप्लॉट देखने के लिए! रेफरी

— ट्रैविस

Answer 1

ऐसा करने का एक और संभावित तरीका Sys.time () का उपयोग करना होगा:

start.time <- Sys.time()
...Relevent codes...
end.time <- Sys.time()
time.taken <- end.time - start.time
time.taken

ऊपर के उत्तरदाता की तुलना में इसे करने का सबसे सुरुचिपूर्ण तरीका नहीं है, लेकिन निश्चित रूप से इसे करने का एक तरीका है।

Comments

यह बहुत अधिक मेमोरी-कुशल है, फिर सिस्टम.टाइम (), जो प्रभावी रूप से इसके तर्कों को कॉपी करता है। यह महत्वपूर्ण है जब आप डेटा के साथ काम कर रहे हैं जो मुश्किल से आपके रैम में फिट होते हैं।

— एडम रिक्ज़ोस्की

उपयोग करने वाले लोगों के लिए Sys.time, कृपया इसे कुछ कैविएट के लिए पढ़ें: टाइमिंग आर कोड विथ Sys.time ()

— at

system.time()मेरे लिए तेज था। मुझे लगता है कि उत्तर के लिए system.time()स्वीकार किया जाना चाहिए!

— ग्वांग-जिन किम

यह कई कोर पर समानांतर में की गई लंबी गणना के लिए लगने वाले समय को जानने का मेरा पसंदीदा तरीका है। इस मामले में, इस कॉल के माध्यम से मापी गई दीवार घड़ी का समय काफी सटीक है क्योंकि कंप्यूटर सभी कोर के साथ कुछ और करने की तुलना में अधिक व्यस्त होगा और गणना को पूरा होने में मिनट या घंटे लगते हैं। यह एक बहुत ही विशिष्ट उपयोग मामला है लेकिन ध्यान देने योग्य है।

— पाब्लो ने

Answer 2

अंतर्निहित फ़ंक्शन system.time()इसे करेगा।

उपयोग की तरह: system.time(result <- myfunction(with, arguments))

Comments

यह जानना महत्वपूर्ण है कि system.time()एक तर्क है gcFirstजो TRUEडिफ़ॉल्ट रूप से है। यह एक तरफ माप को थोड़ा और अधिक प्रतिलिपि प्रस्तुत करने योग्य बनाता है, लेकिन कुल रन समय का एक महत्वपूर्ण ओवरहेड उत्पन्न कर सकता है (जो मापा नहीं जाता है, ऑफ कोर्स)।

— जकोब-आर

यह किस इकाई में मापा जाता है? उदाहरण के लिए मैं सिर्फ भाग गया system.time(result <- myfunction(with, arguments))और एक आउटपुट के रूप में 187.564 मिला- क्या वह सेकंड या क्या है?

— zsad512

उपयोग करने वाले लोगों के लिए system.time, कृपया कुछ कैविएट के लिए इसे पढ़ें: "ऑब्जेक्ट नहीं मिला" और "अनपेक्षित प्रतीक" त्रुटियां जब समय आर कोड को system.time () के साथ ।

— ।

@ zsad512 मुझे यकीन है कि वे सेकंड हैं ।

— टपर

Answer 3

जैसा कि एंड्री ने कहा, system.time()ठीक काम करता है। छोटे कार्य के लिए मैं replicate()इसमें डालना चाहता हूं :

system.time( replicate(10000, myfunction(with,arguments) ) )

Comments

आप माइक्रोबेन्चमार्क पैकेज का उपयोग करने से बेहतर हैं क्योंकि इसमें समय पर प्रतिकृति के ओवरहेड शामिल नहीं हैं।

— हैडली

Answer 4

निष्पादन के समय को मापने का एक अच्छा तरीका यह है कि रिंचमार्क पैकेज का उपयोग किया जाए । यह पैकेज (आसानी से) आपको यह निर्दिष्ट करने की अनुमति देता है कि आपके परीक्षण को दोहराने के लिए कितनी बार और रिश्तेदार बेंचमार्क होना चाहिए।

यह भी देखें में एक संबंधित सवाल stats.stackexchange

Comments

माइक्रोबेन्चमार्क और भी बेहतर है क्योंकि यह उच्च परिशुद्धता समय कार्यों का उपयोग करता है।

— हैडल

@hadley लेकिन तुलना के मामले में rbenchmark अधिक उपयोगकर्ता के अनुकूल है। मेरे लिए माइक्रोबेनमार्क अपग्रेडेड सिस्टम.टाइम है। rmicrobenchmark है कि हम क्या :) की जरूरत

— मारेक

माइक्रोबेनमार्क का अनुचर काफी प्रतिक्रियाशील है - मुझे यकीन है कि वह जो भी आप की जरूरत है जोड़ देगा।

— 16

Answer 5

microbenchmark एक हल्के (~ 50kB) पैकेज है और अधिक-या-कम एक मानक तरीका है जो कई भावों और कार्यों को बेंचमार्क करने के लिए आर में है:

microbenchmark(myfunction(with,arguments))

उदाहरण के लिए:

> microbenchmark::microbenchmark(log10(5), log(5)/log(10), times = 10000)
Unit: nanoseconds
           expr min lq    mean median uq   max neval cld
       log10(5)   0  0 25.5738      0  1 10265 10000   a
 log(5)/log(10)   0  0 28.1838      0  1 10265 10000

यहाँ दोनों अभिव्यक्तियों का मूल्यांकन 10000 बार किया गया, जिसका निष्पादन समय 25-30 ns के आसपास था।

Answer 6

वहाँ भी proc.time()

आप उसी तरह से उपयोग कर सकते हैं, Sys.timeलेकिन यह आपको एक समान परिणाम देता है system.time।

ptm <- proc.time()
#your function here
proc.time() - ptm

उपयोग करने के बीच मुख्य अंतर

system.time({ #your function here })

यह है कि proc.time()विधि अभी भी समय को मापने के बजाय अपने कार्य को निष्पादित करती है ... और वैसे, मुझे अंदर से उपयोग system.timeकरना पसंद है {}ताकि आप चीजों का एक सेट लगा सकें ...

Answer 7

पैकेज "tictoc" आपको निष्पादन समय को मापने का एक बहुत ही सरल तरीका देता है। प्रलेखन इस प्रकार है: https://cran.fhcrc.org/web/packages/tictoc/tictoc.pdf ।

install.packages("tictoc")
require(tictoc)
tic()
rnorm(1000,0,1)
toc()

व्यतीत समय को एक चर में सहेजने के लिए आप कर सकते हैं:

install.packages("tictoc")
require(tictoc)
tic()
rnorm(1000,0,1)
exectime <- toc()
exectime <- exectime$toc - exectime$tic

Answer 8

यद्यपि अन्य समाधान एकल कार्य के लिए उपयोगी होते हैं, मैं निम्नलिखित कोड का सुझाव देता हूं जहां अधिक सामान्य और प्रभावी है:

Rprof(tf <- "log.log", memory.profiling = TRUE)
# the code you want to profile must be in between
Rprof (NULL) ; print(summaryRprof(tf))

Comments

मैं अब तक Rprof के बारे में नहीं जानता था और यह वास्तव में बहुत अच्छा है! इसके अलावा यह बेस आर के साथ आता है इसलिए अतिरिक्त पैकेज की आवश्यकता नहीं है microbenchmarkया profvis।

— साइमन सी।

मुझे आश्चर्य है कि अगर rprof के रूप में अच्छी तरह से कल्पना की जा सकती है, उदाहरण के लिए अगर हम इसे रूपरेखा प्रत्येक आइटम के लिए समय की साजिश करना चाहते हैं?

— ज़ाविर अमीन

@ZawirAmin एक तरीका है, बस Rstudio >> प्रोफ़ाइल मेनू का उपयोग करें

— TPArrow

Answer 9

पैकेज का उपयोग करके ऐसा करने का एक और सरल लेकिन बहुत शक्तिशाली तरीका है profvis। यह आपके कोड के निष्पादन समय को ही नहीं मापता है, बल्कि आपके द्वारा निष्पादित प्रत्येक फ़ंक्शन के लिए आपको एक ड्रिल डाउन देता है। यह चमकदार के लिए भी इस्तेमाल किया जा सकता है।

library(profvis)

profvis({
  #your code here
})

कुछ उदाहरणों के लिए यहां क्लिक करें ।

Answer 10

यदि आप चाहें तो आप MATLAB- शैली tic- tocफ़ंक्शन का उपयोग कर सकते हैं। यह अन्य SO प्रश्न देखें

आर में स्टॉपवॉच समारोह

Comments

जोड़ने के बारे में था proc.time()... मुझे प्यारा नाम बेहतर पसंद है। =)

— isomorphismes