R Academy · पाठ

microbenchmark से बेंचमार्किंग

microbenchmark() की सहायता से अनेक कार्यान्वयनों की सांख्यिकीय तुलना करें।

पाठ 4, कुल 4 में से13 चरण

microbenchmark से बेंचमार्किंग, CoddyKit पर R Academy का एक निःशुल्क पाठ है। यह 4 में से 4वाँ पाठ है। इस अध्ययन पथ के 3 तक कोई भी पाठ पूरा पढ़ना निःशुल्क है — इसके बाद CoddyKit PRO हर पाठ अनलॉक करता है, साथ ही अंतर्निर्मित कोड संपादक और चौबीसों घंटे एआई शिक्षक के साथ व्यावहारिक अभ्यास भी उपलब्ध कराता है। यह R Academy सीखने के मार्ग का हिस्सा है और आपकी प्रगति वेब तथा CoddyKit ऐप पर सिंक होती रहती है। R Academy पाठ्यक्रम में कुल 4 पाठ शामिल हैं।

माइक्रोबेंचमार्क क्यों करें?

system.time() में मिलीसेकंड स्तर की सटीकता होती है और तेज़ संचालन के लिए यह अविश्वसनीय हो सकता है। microbenchmark पैकेज अभिव्यक्तियों को सैकड़ों बार चलाता है, प्रारंभिक तैयारी को संभालता है और नैनोसेकंड स्तर की सांख्यिकी देता है — इसलिए समान कार्यान्वयनों की तुलना के लिए यह सही उपकरण है।

माइक्रोबेंचमार्क का मूल उपयोग

microbenchmark() में नामित अभिव्यक्तियाँ दें। हर तर्क का नाम आउटपुट में लेबल बन जाता है। times तर्क यह नियंत्रित करता है कि हर अभिव्यक्ति का मूल्यांकन कितनी बार किया जाए।

# library(microbenchmark)
# x <- 1:10000
#
# microbenchmark(
#   loop = {
#     s <- 0
#     for (v in x) s <- s + v
#   },
#   vectorized = sum(x),
#   times = 200L
# )

times तर्क चुनना

अधिक पुनरावृत्तियों से अनुमान अधिक स्थिर मिलते हैं, लेकिन अधिक समय लगता है। सामान्य दिशानिर्देश:

तेज़ अभिव्यक्तियाँ (माइक्रोसेकंड): times = 1000L या अधिक
मध्यम गति (मिलीसेकंड): times = 100L
धीमी अभिव्यक्तियाँ (सेकंड): times = 10L या कम

डिफ़ॉल्ट मान times = 100L है, जो एक अच्छा प्रारंभिक विकल्प है।

# library(microbenchmark)
# microbenchmark(
#   fast_op = sqrt(2),
#   times = 10000L   # many reps for a nanosecond-scale operation
# )
# microbenchmark(
#   slow_op = sort(rnorm(1e6)),
#   times = 10L      # fewer reps for second-scale operation
# )

unit तर्क निर्दिष्ट करना

परिणामों को सुविधाजनक पैमाने पर दिखाने के लिए unit तर्क का उपयोग करें:

'ns' — नैनोसेकंड (बहुत तेज़ संचालन के लिए)
'us' — माइक्रोसेकंड
'ms' — मिलीसेकंड
's' — सेकंड
'relative' — सबसे तेज़ अभिव्यक्ति के अनुपात में

# library(microbenchmark)
# x <- runif(1000)
#
# microbenchmark(
#   sapply_sqrt = sapply(x, sqrt),
#   vectorized  = sqrt(x),
#   times = 500L,
#   unit = 'us'   # display in microseconds
# )

सारांश आउटपुट को समझना

microbenchmark इन कॉलमों वाली सारांश तालिका प्रिंट करता है:

min — एकल रन का सबसे कम समय
lq / mean / median / uq — निचला चतुर्थक, माध्य, माध्यिका, ऊपरी चतुर्थक
max — एकल रन का सबसे अधिक समय
neval — मूल्यांकनों की संख्या

मुख्य तुलना माप के रूप में median का उपयोग करें — यह कभी-कभार होने वाले GC विरामों के प्रति अधिक स्थिर होता है, जो max और mean को बढ़ा देते हैं।

# Example summary output (unit: microseconds):
#
#         expr    min     lq   mean  median    uq    max neval
#         loop 1203.1 1245.3 1301.7  1262.4 1310.1 2100.8   100
#   vectorized    2.1    2.3    2.9     2.4    2.6   18.3   100
#
# => vectorized is ~525x faster at median
cat('Always compare medians, not means, for microbenchmark results
')

माइक्रोबेंचमार्क ऑब्जेक्ट पर summary()

सहेजे गए microbenchmark परिणाम पर summary(mb) कॉल करने से एक डेटा फ़्रेम मिलता है, जिसकी प्रोग्राम के माध्यम से जाँच की जा सकती है। आप सारांश कॉल में unit भी बदल सकते हैं।

# library(microbenchmark)
# x <- rnorm(5000)
# mb <- microbenchmark(
#   vapply_abs  = vapply(x, abs, numeric(1)),
#   base_abs    = abs(x),
#   times = 200L
# )
# s <- summary(mb, unit = 'ms')
# print(s[, c('expr', 'min', 'median', 'max')])

दृश्य तुलना के लिए autoplot()

autoplot(mb), अभिव्यक्तियों के बीच समय-वितरण का वायलिन या बॉक्स प्लॉट बनाने के लिए ggplot2 का उपयोग करता है। इससे न केवल माध्यिका के अंतर, बल्कि विकल्पों के बीच परिवर्तनशीलता और ओवरलैप भी आसानी से दिखाई देते हैं।

# library(microbenchmark)
# library(ggplot2)
#
# x <- 1:50000
# mb <- microbenchmark(
#   loop   = { s <- 0; for (v in x) s <- s + v },
#   vapply = vapply(x, identity, numeric(1)),
#   vec    = sum(x),
#   times  = 100L
# )
# autoplot(mb)  # opens ggplot2 violin chart

लूप बनाम vapply बनाम sapply की तुलना

एक सामान्य बेंचमार्क में किसी फ़ंक्शन को तत्व-दर-तत्व for लूप, sapply() या vapply() से लागू किया जाता है। vapply(), sapply() से तेज़ है क्योंकि यह परिणाम वेक्टर के लिए पहले ही मेमोरी आवंटित कर देता है। दोनों ही पूर्णतः वेक्टराइज़्ड कोड से धीमे होते हैं।

# library(microbenchmark)
# x <- runif(5000, 1, 100)
#
# mb <- microbenchmark(
#   for_loop = {
#     r <- numeric(length(x))
#     for (i in seq_along(x)) r[i] <- log(x[i])
#   },
#   sapply_log  = sapply(x, log),
#   vapply_log  = vapply(x, log, numeric(1)),
#   vec_log     = log(x),
#   times = 200L, unit = 'us'
# )
# print(mb)

पहले शुद्धता की जाँच करना

बेंचमार्क करने से पहले जाँच लें कि सभी अभिव्यक्तियाँ एक जैसे परिणाम लौटाती हैं। तेज़ लेकिन गलत कार्यान्वयन बेकार है। आउटपुट की तुलना करने के लिए identical() या all.equal() का उपयोग करें।

# x <- runif(1000)
# r1 <- sapply(x, sqrt)
# r2 <- sqrt(x)
# r3 <- vapply(x, sqrt, numeric(1))
#
# stopifnot(isTRUE(all.equal(r1, r2)))
# stopifnot(isTRUE(all.equal(r1, r3)))
# cat('All three produce identical results -- safe to benchmark
')
cat('Always verify correctness before comparing speed
')

setup तर्क के साथ बेंचमार्क करना

समय मापी जाने वाली अभिव्यक्तियों से पहले कोड को एक बार चलाने के लिए setup तर्क का उपयोग करें। जब आप डेटा बनाने का समय नहीं माप रहे हों, तब इससे डेटा बनाने का समय बेंचमार्क में शामिल नहीं होगा।

# library(microbenchmark)
#
# microbenchmark(
#   sort_base  = sort(x),
#   sort_order = x[order(x)],
#   setup = { x <- rnorm(10000) },
#   times = 100L
# )
# Each iteration refreshes x via setup, then times sort_base and sort_order

विश्लेषण में बेंचमार्क की रिपोर्टिंग

बेंचमार्क परिणाम साझा करते समय हमेशा यह जानकारी दें:

R का संस्करण और प्लेटफ़ॉर्म
पैकेजों के संस्करण
उपयोग किया गया times मान
जिस डेटा आकार पर बेंचमार्क किया गया

समय-मापन अलग-अलग मशीनों पर सीधे तुलनीय नहीं होते — कार्यान्वयनों की तुलना करते समय निरपेक्ष संख्याओं के बजाय अनुपात की रिपोर्ट करें।

cat('R version    :', R.version$version.string, '
')
cat('Platform     :', R.version$platform, '
')
cat('Logical cores:', parallel::detectCores(), '
')

त्वरित जाँच: माइक्रोबेंचमार्क माप

दो कार्यान्वयनों की तुलना के लिए microbenchmark आउटपुट का कौन-सा सारांश आँकड़ा सबसे विश्वसनीय है?

इंटरैक्टिव पाठ में इसका उत्तर दें

माइक्रोबेंचमार्क का पुनरावलोकन

microbenchmark, R में कठोर माइक्रो-बेंचमार्किंग के लिए मानक उपकरण है:

नामित अभिव्यक्तियाँ दें और पुनरावृत्तियों को नियंत्रित करने के लिए times निर्धारित करें
पठनीय आउटपुट के लिए unit = 'us' या 'ms' का उपयोग करें
माध्यिकाओं की तुलना करें — ये GC के असामान्य मानों के प्रति स्थिर होती हैं
समय-वितरण को दृश्य रूप देने के लिए autoplot() का उपयोग करें
बेंचमार्क करने से पहले all.equal() से शुद्धता की जाँच करें

शुरुआत निःशुल्क

एआई शिक्षक के साथ R सीखें — निःशुल्क

अपने ब्राउज़र में वास्तविक कोड लिखें और चलाएँ, चौबीसों घंटे एआई शिक्षक से तुरंत सहायता पाएँ, और वेब या ऐप पर वहीं से शुरू करें जहाँ आपने छोड़ा था।

पाठ्यक्रम: 43
पाठ: 159

निःशुल्क सीखना शुरू करें पूरा पाठ्यक्रम देखें

अक्सर पूछे जाने वाले प्रश्न

क्या “microbenchmark से बेंचमार्किंग” पाठ निःशुल्क है?

हाँ — R Academy अध्ययन पथ के 3 तक कोई भी पाठ, जिसमें “microbenchmark से बेंचमार्किंग” भी शामिल है, यहाँ वेब पर पूरा पढ़ना निःशुल्क है। इसके बाद CoddyKit PRO हर पाठ अनलॉक करता है, साथ ही अंतर्निर्मित कोड संपादक और चौबीसों घंटे एआई शिक्षक के साथ इंटरैक्टिव अभ्यास भी उपलब्ध कराता है। R Academy पाठ्यक्रम में कुल 4 पाठ शामिल हैं।

“microbenchmark से बेंचमार्किंग” में मैं क्या सीखूँगा?

microbenchmark() की सहायता से अनेक कार्यान्वयनों की सांख्यिकीय तुलना करें। आप ब्राउज़र में सीधे चलाए जाने वाले व्यावहारिक कोड के साथ R Academy का अभ्यास करते हैं, और पाठ पूरा करते समय 24/7 एआई ट्यूटर आपके प्रश्नों के उत्तर देता है।

क्या R Academy शुरू करने के लिए मुझे किसी अनुभव की आवश्यकता है?

पहले के अनुभव की आवश्यकता नहीं है। CoddyKit पर R Academy शुरुआती से लेकर उन्नत शिक्षार्थियों तक सभी के लिए व्यवस्थित किया गया है, इसलिए आप यहीं से या शुरुआत से सीखना शुरू कर सकते हैं और अपनी गति से आगे बढ़ सकते हैं। यह 4 में से 4वाँ पाठ है।

“microbenchmark से बेंचमार्किंग” पाठ पूरा करने में कितना समय लगता है?

CoddyKit का अधिकांश पाठ लगभग 5–10 मिनट में पूरा हो जाता है। हर पाठ छोटा और संवादात्मक है, इसलिए आप लगातार प्रगति करते हैं और वेब या ऐप पर वहीं से सीखना जारी रख सकते हैं जहाँ आपने छोड़ा था।

क्या मैं इस R Academy पाठ में कोड लिख और चला सकता हूँ?

हाँ। हर R Academy पाठ में एक अंतर्निर्मित कोड संपादक शामिल है, जिससे आप सीधे अपने ब्राउज़र में वास्तविक कोड लिख और चला सकते हैं और तुरंत एआई प्रतिक्रिया पा सकते हैं—स्थानीय सेटअप की आवश्यकता नहीं है।

इस पाठ्यक्रम के सभी पाठ

system.time() और proc.time()
Rprof और profvis से कोड का प्रोफ़ाइल विश्लेषण
गति के लिए वेक्टरकरण
microbenchmark से बेंचमार्किंग

← R Academy पर वापस जाएँ