R Academy · पाठ

गति के लिए वेक्टरकरण

Q: क्या “गति के लिए वेक्टरकरण” पाठ निःशुल्क है?

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

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

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

Q: “गति के लिए वेक्टरकरण” पाठ पूरा करने में कितना समय लगता है?

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

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

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

गति में बड़ी बढ़त के लिए स्पष्ट लूपों को वेक्टरकृत संक्रियाओं से बदलें।

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

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

Vectorization क्यों महत्वपूर्ण है

R एक interpreted language है, इसलिए for loops में प्रत्येक iteration पर overhead होता है — function call dispatch, bounds checking और type coercion। Vectorized operations यह काम compiled C code में भेजती हैं, जो कई गुना तेज़ चलता है।

Base R में उपलब्ध optimizations में vectorization का प्रभाव सबसे अधिक होता है।

Loop और cumsum() का उदाहरण

for loop और अंतर्निहित cumsum() के माध्यम से running total निकालने पर अंतर स्पष्ट दिखाई देता है। cumsum() C-level compiled code को call करता है और पूरे vector को एक pass में process करता है।

n <- 500000
x <- rnorm(n)

t_loop <- system.time({
  result <- numeric(n)
  result[1] <- x[1]
  for (i in 2:n) result[i] <- result[i-1] + x[i]
})['elapsed']

t_vec <- system.time({
  result2 <- cumsum(x)
})['elapsed']

cat('Loop  :', t_loop, 's
')
cat('cumsum:', t_vec, 's
')

ifelse() बनाम for + if

ifelse(condition, yes, no) एक vectorized conditional है, जो एक ही बार में पूरे vector पर condition का मूल्यांकन करता है। यह element-by-element for + if loops की जगह एकल C-level pass का उपयोग करता है।

n <- 300000
x <- rnorm(n)

t_loop <- system.time({
  result <- numeric(n)
  for (i in seq_len(n)) result[i] <- if (x[i] > 0) x[i] else -x[i]
})['elapsed']

t_vec <- system.time({
  result2 <- ifelse(x > 0, x, -x)
})['elapsed']

cat('for+if :', t_loop, 's
')
cat('ifelse :', t_vec, 's
')

परिणामी vectors को पहले से allocate करना

जब loop से बचना संभव न हो, तो loop से पहले परिणाम vector को pre-allocate करें। loop के भीतर c(result, new_val) से vector को बढ़ाने पर प्रत्येक iteration में पूरा vector copy होता है — कुल memory operations O(n^2) हो जाती हैं।

n <- 20000

t_grow <- system.time({
  result <- c()
  for (i in seq_len(n)) result <- c(result, i^2)
})['elapsed']

t_prealloc <- system.time({
  result2 <- numeric(n)
  for (i in seq_len(n)) result2[i] <- i^2
})['elapsed']

cat('Growing vector:', t_grow, 's
')
cat('Pre-allocated :', t_prealloc, 's
')

सही pre-allocation types

pre-allocation के दौरान implicit coercion से बचने के लिए अपने data से मेल खाने वाले typed constructor का उपयोग करें:

numeric(n) — double-precision floats
integer(n) — integers
character(n) — खाली strings
logical(n) — FALSE values
vector('list', n) — NULLs की list

n <- 5
cat('numeric  :', numeric(n), '
')
cat('integer  :', integer(n), '
')
cat('logical  :', logical(n), '
')
cat('character:', character(n), '
')
cat('list len :', length(vector('list', n)), '
')

colSums() और rowSums() बनाम apply()

Matrix operations के लिए colSums(m), rowSums(m), colMeans(m) और rowMeans(m) अत्यधिक optimized C routines हैं। ये लगातार apply(m, 1, sum) से तेज़ होते हैं, क्योंकि apply प्रत्येक row के लिए R function sum को एक बार dispatch करता है।

m <- matrix(rnorm(1000 * 2000), nrow = 1000)

t_apply <- system.time(apply(m, 2, sum))['elapsed']
t_colsums <- system.time(colSums(m))['elapsed']

cat('apply(m,2,sum):', t_apply, 's
')
cat('colSums(m)    :', t_colsums, 's
')

Vectorized arithmetic हमेशा तेज़ होती है

Vectors पर basic arithmetic — +, -, *, /, ^, sqrt(), log(), exp() — सभी vectorized हैं। ये एक ही C call में पूरे vector पर element-wise काम करते हैं। इन्हें हमेशा loops पर प्राथमिकता दें।

x <- 1:1000000

t1 <- system.time(y <- x^2 + 2*x + 1)['elapsed']

t2 <- system.time({
  y2 <- numeric(length(x))
  for (i in seq_along(x)) y2[i] <- x[i]^2 + 2*x[i] + 1
})['elapsed']

cat('Vectorized:', t1, 's
')
cat('Loop      :', t2, 's
')

लूप के बजाय लॉजिकल सबसेटिंग

लॉजिकल शर्त के आधार पर वेक्टर को फ़िल्टर करना वेक्टराइज़्ड होता है। लूप चलाकर शर्त के अनुसार मान जोड़ने के बजाय, एक लॉजिकल इंडेक्स बनाएँ और एक ही बार सबसेट करें — अंतर्निहित C कोड एक ही पास में काम कर देता है।

x <- rnorm(500000)

t_loop <- system.time({
  pos <- c()
  for (v in x) if (v > 0) pos <- c(pos, v)
})['elapsed']

t_vec <- system.time({
  pos2 <- x[x > 0]
})['elapsed']

cat('Loop filter:', t_loop, 's
')
cat('Logical idx:', t_vec, 's
')

इंडेक्स पर काम के लिए which() और tabulate()

जब आपको TRUE मानों की स्थितियाँ चाहिए हों, तो which(condition) वेक्टराइज़्ड और तेज़ होता है। सघन पूर्णांक रेंज के लिए tabulate(bin_vector), table() की तुलना में पूर्णांकों की घटनाएँ अधिक तेज़ी से गिनता है।

x <- sample(1:10, 100000, replace = TRUE)

t_table    <- system.time(table(x))['elapsed']
t_tabulate <- system.time(tabulate(x, nbins = 10))['elapsed']

cat('table()   :', t_table, 's
')
cat('tabulate():', t_tabulate, 's
')

idx <- which(x == 5)
cat('Positions of 5: first 5 =', head(idx, 5), '
')

लूप अब भी कब स्वीकार्य हैं

हर लूप खराब नहीं होता। लूप इन स्थितियों में स्वीकार्य हैं:

हर पुनरावृत्ति पिछले परिणाम पर निर्भर करती है (क्रमिक निर्भरता)
पुनरावृत्तियों की संख्या कम हो (< 1000)
लूप का मुख्य भाग ऐसे जटिल फ़ंक्शन को कॉल करता हो जिसका कोई वेक्टराइज़्ड समकक्ष न हो

इन मामलों में पहले से मेमोरी आवंटित करने पर ध्यान दें और लूप के अंदर संरचनाओं का आकार बढ़ाने से बचें।

# Sequential dependency -- loop is correct here
fib <- function(n) {
  result <- integer(n)
  result[1] <- 1L
  if (n >= 2) result[2] <- 1L
  for (i in seq_len(n)[-c(1,2)]) result[i] <- result[i-1] + result[i-2]
  result
}
cat('Fibonacci:', fib(10), '
')

वेक्टराइज़ेशन का सारांश

तेज़ R कोड के लिए वेक्टराइज़ेशन के मुख्य नियम:

क्रमिक संचयन के लिए cumsum/cumprod/diff का उपयोग करें
तत्व-दर-तत्व शर्तों के लिए ifelse() का उपयोग करें
numeric(n) / vector('list',n) से पहले ही मेमोरी आवंटित करें
apply() के बजाय colSums/rowSums/colMeans/rowMeans का उपयोग करें
लॉजिकल सबसेटिंग, फ़िल्टर करने वाले लूप से बेहतर है

त्वरित जाँच: पहले से मेमोरी आवंटित करना

बड़े n के लिए लूप के अंदर result <- c(result, new_val) से वेक्टर का आकार बढ़ाना इतना धीमा क्यों होता है?

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

वेक्टराइज़ेशन का पुनरावलोकन

वेक्टराइज़ेशन, R के प्रदर्शन को बेहतर बनाने का मुख्य उपाय है:

वेक्टराइज़्ड फ़ंक्शन (cumsum, ifelse, अंकगणितीय ऑपरेटर) संकलित C कोड को कॉल करते हैं — ये समकक्ष R लूप से 10 से 100 गुना तेज़ होते हैं
जिस लूप से बचना संभव न हो, उससे पहले परिणाम रखने वाले कंटेनर के लिए मेमोरी आवंटित करें, ताकि O(n^2) कॉपी करने से बचा जा सके
मैट्रिक्स के समुच्चय संचालन के लिए colSums/rowSums, apply() से बेहतर हैं
लॉजिकल सबसेटिंग, फ़िल्टर करने वाले लूप को साफ़ और तेज़ तरीके से बदल देती है

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

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

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

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

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

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

क्या “गति के लिए वेक्टरकरण” पाठ निःशुल्क है?

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