R में लूप्स पर ट्यूटोरियल - उपयोग और विकल्प

For लूप्स की व्याख्या

यह लूप संरचना, जो आयताकार बॉक्स ‘init’ (या initialization), निर्णय वाला हीरा या रहॉम्बस, और आयताकार बॉक्स i1 से बनती है, एक ज्ञात संख्या बार निष्पादित होती है।

फ्लोचार्ट की भाषा में, आयताकार बॉक्स का अर्थ कुछ ऐसा होता है “ऐसा कुछ करें जिसमें निर्णय शामिल न हों”। दूसरी ओर, रहॉम्बस या हीरे “निर्णय प्रतीक” कहलाते हैं और इसलिए ऐसे प्रश्नों में अनूदित होते हैं जिनके केवल दो तार्किक उत्तर होते हैं: True (T) या False (F)।

ध्यान दें कि चीजों को सरल रखने के लिए, अन्य संभावित प्रतीकों को चित्र से हटा दिया गया है।

इनिशियलाइज़ेशन वाले आयत के भीतर एक या अधिक निर्देशों के बाद एक शर्त का मूल्यांकन होता है, जो एक ऐसे वेरिएबल पर है जो किसी निर्दिष्ट अनुक्रम के भीतर मान धारण कर सकता है। चित्र में, यह हीरे द्वारा दर्शाया गया है: प्रतीकों का अर्थ है “क्या वेरिएबल v का वर्तमान मान अनुक्रम seq का सदस्य है?”।

दूसरे शब्दों में, आप जाँच रहे हैं कि v का वर्तमान मान किसी निर्दिष्ट सीमा के भीतर है या नहीं। आप प्रायः यह सीमा इनिशियलाइज़ेशन में निर्धारित करते हैं, जैसे 1:100 ताकि लूप शुरू हो सके।

यदि शर्त पूरी नहीं होती और परिणाम False होता है, तो लूप कभी निष्पादित नहीं होता। यह for लूप संरचना के दाईं ओर ढीले तीर से दर्शाया गया है। तब प्रोग्राम लूप ब्लॉक के बाद मिलने वाले पहले निर्देश को निष्पादित करेगा।

यदि शर्त सत्यापित हो जाती है, तो एक निर्देश — या निर्देशों का ब्लॉक — i1 निष्पादित होता है। और संभव है कि यह ब्लॉक स्वयं एक और लूप हो। ऐसे मामलों में, इसे नेस्टेड लूप कहते हैं।

एक बार यह हो जाने पर, शर्त का फिर मूल्यांकन किया जाता है। यह i1 से ऊपर की ओर जाने वाली लाइनों से इंगित है, जो इनिशियलाइज़ेशन बॉक्स के तुरंत बाद शीर्ष पर लौटती हैं। R — और Python — में हम इसे सामान्य अंग्रेज़ी में भी व्यक्त कर सकते हैं, यह पूछकर कि हमारा वेरिएबल मानों की किसी रेंज में आता है या नहीं।

ध्यान दें कि अन्य भाषाओं में, उदाहरण के लिए C में, शर्त को तार्किक ऑपरेटरों जैसे greater than, less than, equal to, … के साथ अधिक स्पष्ट रूप से व्यक्त किया जाता है।

यहाँ एक सरल for लूप का उदाहरण है:

# Create a vector filled with random normal values
u1 <- rnorm(30)
print("This loop calculates the square of the first 10 elements of vector u1")

# Initialize `usq`
usq <- 0. 

for (i in 1:10) {
    # i-th element of `u1` squared into `i`-th position of `usq`
    usq[i] <- u1[i] * u1[i]
    print(usq[i])
}

print(i)

for ब्लॉक कर्ली ब्रेसेज़ में घिरा होता है। इन्हें परीक्षण शर्त के तुरंत बाद या उसके नीचे रखा जा सकता है, और बेहतर है कि उसके बाद इंडेंटेशन आए। यह अनिवार्य नहीं है, लेकिन कर्ली ब्रेसेज़ निश्चित रूप से आपके कोड की पठनीयता बढ़ाती हैं और लूप ब्लॉक तथा उसके भीतर संभावित त्रुटियों को आसानी से पहचानने देती हैं।

ध्यान दें कि वर्गों के वेक्टर usq को इनिशियलाइज़ किया गया है। यह सादे RStudio कोड में आवश्यक नहीं होता, लेकिन मार्कअप संस्करण में knitr संकलित नहीं करेगा क्योंकि लूप में उपयोग से पहले वेक्टर के संदर्भ का न मिलना RStudio में त्रुटि फेंक देता है। knitr के बारे में अधिक जानकारी के लिए, R Markdown पेज पर जाएँ।

For लूप्स को नेस्ट करना

अब जब आप जानते हैं कि for लूप्स को नेस्ट भी किया जा सकता है, तो आप शायद सोच रहे होंगे कि ऐसा क्यों और कब अपने कोड में उपयोग करें।

मान लीजिए कि आप किसी द्वि-आयामी array में उसके तत्वों को विशिष्ट मान देकर हेरफेर करना चाहते हैं।

तब आप कुछ ऐसा कर सकते हैं:

# Insert your own integer here
my_int <- 42

nr <- as.integer(my_int)

# Create a `n` x `n` matrix with zeros
mymat <- matrix(0, nr, nr)

# For each row and for each column, assign values based on position
# These values are the product of two indexes
for (i in 1:dim(mymat)[1]) {
    for (j in 1:dim(mymat)[2]) {
        mymat[i, j] = i * j
    }
}

टिप: matrix() फ़ंक्शन के बारे में अधिक जानकारी के लिए, R Documentation देखें।

You have two nested for loops in the code chunk above and thus two sets of curly braces, each with its own block and governed by its own index. That is, i runs over the lines and j runs over the columns.

 

क्या उत्पन्न हुआ?

# Show the first 10x10 chunk or the first `nr` x `nr` chunk
if (nr > 10) {
    mymat[1:10, 1:10]
} else
    mymat[1:nr, 1:nr]

ध्यान दें कि उपयोगकर्ता को बहुत बड़ी तालिकाओं से स्क्रीन न भर दे, इसके लिए आपने अंत में एक शर्त रखी है कि यदि उपयोगकर्ता ने 10 से बड़ा पूर्णांक माँगा है तो केवल पहली 10 x 10 खंड को प्रिंट करें। अन्यथा, एक n x n खंड प्रिंट होगा।

पूरा कोड इस प्रकार दिखता है:

# Insert your own integer here
my_int <- 42

nr <- as.integer(my_int)

# Create a `n` x `n` matrix with zeroes
mymat <- matrix(0, nr, nr)

# For each row and for each column, assign values based on position
# These values are the product of two indexes
for (i in 1:dim(mymat)[1]) {
    for (j in 1:dim(mymat)[2]) {
        mymat[i, j] = i * j
    }
}

# Show the first 10x10 chunk or the first `nr` x `nr` chunk
if (nr > 10) {
    mymat[1:10, 1:10]
} else
    mymat[1:nr, 1:nr]

For लूप्स: लोकप्रिय, लेकिन हर बार आपके लिए सर्वोत्तम नहीं

for लूप अब तक का सबसे लोकप्रिय है, और इसकी संरचना यह मानती है कि इटरेशन की संख्या तय और पहले से ज्ञात है, जैसे “पहले 200 अभाज्य संख्याएँ उत्पन्न करें” या “सबसे महत्वपूर्ण 10 ग्राहकों की सूची बनाएँ” जैसे मामलों में।

लेकिन अगर आपको इटरेशन की संख्या का पता न हो या वह आपके नियंत्रण में न हो, और एक या कई शर्तें ऐसी हों जो पहले से अनुमानित न की जा सकें, तो क्या होगा?

उदाहरण के लिए, आप किसी निर्दिष्ट पोस्टल कोड वाले क्षेत्र में रहने वाले ग्राहकों की संख्या गिनना चाह सकते हैं, या पिछले दो दिनों में किसी वेब पेज बैनर पर क्लिकों की संख्या, या इसी तरह की अप्रत्याशित घटनाएँ।

ऐसे मामलों में, while लूप और उसका करीबी repeat मददगार साबित हो सकते हैं…

break के साथ अपने लूप्स तोड़ें

जब R इंटरप्रेटर को break मिलता है, तो वह नियंत्रण को लूप के अंत के तुरंत बाद वाली निर्देश पंक्ति (यदि कोई है) को सौंप देता है। नेस्टेड लूप्स के मामले में, break केवल सबसे अंदरूनी लूप से बाहर निकलने की अनुमति देगा।

यहाँ एक उदाहरण है।

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

जब इंडेक्स बराबर होते हैं और इस प्रकार अंदरूनी लूप में, जो कॉलम इंडेक्स j पर चलता है, शर्त पूरी होती है, तो एक break निष्पादित होता है और सबसे अंदरूनी लूप बाधित हो जाता है, और सीधे अंदरूनी लूप के बाद वाली निर्देश पर जंप हो जाता है। यह निर्देश एक print() निर्देश है। फिर नियंत्रण बाहरी for शर्त (पंक्तियों पर, इंडेक्स i) पर आता है, जिसका फिर से मूल्यांकन होता है।

यदि इंडेक्स अलग हैं, तो असाइनमेंट किया जाता है और काउंटर 1 से बढ़ाया जाता है। अंत में, प्रोग्राम काउंटर ctr प्रिंट करता है, जिसमें असाइन किए गए तत्वों की संख्या होती है।

# Make a lower triangular matrix (zeroes in upper right corner)
m = 10
n = 10

# A counter to count the assignment
ctr = 0

# Create a 10 x 10 matrix with zeroes
mymat = matrix(0, m, n)

for (i in 1:m) {
    for (j in 1:n) {
        if (i == j) {
            break
        } else {
            # you assign the values only when i<>j
            mymat[i, j] = i * j
            ctr = ctr + 1
        }
    }
    print(i * j)
}

# Print how many matrix cells were assigned
print(ctr)

ध्यान दें कि कभी-कभी कर्ली ब्रैकेट्स वहाँ भी लगा देना, जहाँ वे सख्ती से आवश्यक नहीं हैं, थोड़ा ज्यादा सतर्क होना लग सकता है। आप आमतौर पर यह सुनिश्चित करने के लिए ऐसा करते हैं कि जो भी { से खोला गया है, वह } से बंद भी हो। तो यदि आपको { या } की असंगत संख्या दिखे, तो आप जानते हैं कि कोई त्रुटि है, हालाँकि इसका उलटा आवश्यक रूप से सत्य नहीं है!

लूप्स में next का उपयोग

next किसी विशेष इटरेशन को समाप्त कर अगले चक्र पर कूद जाता है। वास्तव में, यह वर्तमान लूप की शर्त के मूल्यांकन पर छलांग लगा देता है।

अन्य भाषाओं में, आपको इसका (हल्का भ्रमित करने वाला) समकक्ष “continue” मिल सकता है, जिसका अर्थ वही है: जहाँ कहीं भी हों, शर्त की जाँच होते ही लूप के मूल्यांकन पर कूद जाएँ।

किसी शर्त के घटित होने पर किसी विशेष चक्र को छोड़ते हुए लूप को जारी रखने का एक सरल उदाहरण है:

m = 20

for (k in 1:m) {
    if (!k %% 2)
        next
    print(k)
}

यह कोड खंड अंतराल 1:m (यहाँ m=20) के सभी विषम संख्याएँ प्रिंट करता है। दूसरे शब्दों में, वे सभी पूर्णांक जिनका 2 से भाग देने पर शेषफल शून्य नहीं आता (इसीलिए मॉड्यूलस ऑपरेन्ड %% का उपयोग), जैसा कि if परीक्षण में निर्दिष्ट है, प्रिंट होंगे।

जिन संख्याओं का शेषफल शून्य है वे प्रिंट नहीं होंगी, क्योंकि प्रोग्राम i in 1:m शर्त के मूल्यांकन पर कूद जाता है और उसके बाद आने वाले किसी भी निर्देश को नज़रअंदाज़ कर देता है। इस मामले में, print(k) को छोड़ दिया जाता है।

v1 <- c(3,4,5)
v2 <- c(3,4,6)
v3 <- c(0,0,0)
n = length(v1)

for (i in 1:n) {
    v3[i] <- v1[i] + v2[i]
}
v3

v3 = v1 + v2
v3

A <- matrix(1:6, nrow = 3, ncol = 2)
B <- matrix(c(2,4,3,1,5,7), nrow=3, ncol=2)

C= A + B
C

R में वेक्टराइजेशन समझाया गया

जबकि प्राथमिक ऑपरेशन्स की संख्या समान दिखती है, फिर वेक्टराइजेशन तेज़ क्यों चलता है?

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

R इंटरप्रेटर आपके कमांड्स के संदर्भ से इन बातों को “समझता” है, लेकिन वह यह काम कमांड-दर-कमांड करता है। इसलिए, चाहे आप किसी कमांड को दोहराएँ, उसे हर बार ऐसी परिभाषाओं से निपटना पड़ता है।

इसके बजाय, एक कम्पाइलर समूचे कोड पर संकलन-समय में शाब्दिक रूप से सारी परिभाषाएँ और घोषणाएँ हल कर देता है; तत्पश्चात कुछ भी निष्पादित करने से पहले कोड को एक सघन और अनुकूलित बाइनरी में बदल दिया जाता है। अब, चूँकि R फ़ंक्शन्स इनमें से किसी निम्न-स्तरीय भाषा में लिखे होते हैं, वे अधिक दक्ष होते हैं।

व्यवहार में, यदि कोई निम्न-स्तरीय कोड देखे, तो उसे प्रायः C या C++ के कॉल्स मिलेंगे, जो सामान्यतः एक तथाकथित रैपर कोड के भीतर लागू होते हैं।

दूसरे, वेक्टराइजेशन का समर्थन करने वाली भाषाओं (जैसे R या Matlab) में, प्रत्येक निर्देश जो किसी न्यूमेरिक डाटा का उपयोग करता है, ऐसे ऑब्जेक्ट पर कार्य करता है जो मूलतः वेक्टर के रूप में परिभाषित है, भले ही उसमें केवल एक तत्व हो। यह डिफ़ॉल्ट है जब आप, उदाहरण के लिए, एक एकल न्यूमेरिक वैरिएबल परिभाषित करते हैं: R में उसकी आंतरिक अभिव्यक्ति हमेशा एक वेक्टर होगी, चाहे वह सिर्फ एक संख्या ही क्यों न हो।

लूप्स परदे के पीछे बने रहते हैं, पर C/C++ के संकलित निम्न और बहुत तेज़ स्तर पर। वेक्टर होने का लाभ यह है कि परिभाषाएँ इंटरप्रेटर द्वारा पूरे वेक्टर पर केवल एक बार हल कर दी जाती हैं, उसके आकार से निरपेक्ष। इसके विपरीत, स्केलर पर किए गए लूप में परिभाषाएँ और आबंटन तत्व-दर-तत्व करने पड़ते हैं, और यह धीमा है।

अंततः, मूल वेक्टर फ़ॉर्मैट के साथ कार्य करना अत्यंत दक्ष रैखिक बीजगणित रूटीनों (जैसे BLAS या Basic Linear Algebra Subprograms) का उपयोग संभव बनाता है, ताकि वेक्टराइज़्ड निर्देशों के निष्पादन पर R इन प्रभावी संख्यात्मक रूटीनों का लाभ उठा सके। अतः संदेश यह होगा कि जहाँ संभव हो, एक ही फ़ंक्शन कॉल में संपूर्ण डाटा संरचनाओं को प्रोसेस करें ताकि उन सारी कॉपींग ऑपरेशन्स से बचा जा सके जो अन्यथा निष्पादित होते हैं।

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

R में वेक्टराइजेशन का एक उदाहरण

“ग्रोइंग डाटा” की धारणा पर लौटते हैं, जो कि किसी डेटा फ्रेम को “अपडेट” करने का आम तौर पर अक्षम तरीका है।

पहले, आप replicate(m, rnorm(n)) से एक m x n मैट्रिस बनाते हैं, जहाँ m=10 कॉलम वेक्टर्स में प्रत्येक में n=10 तत्व होते हैं, जो rnorm(n) से बनते हैं, जो यादृच्छिक सामान्य संख्याएँ बनाता है।

फिर आप इसे डेटा फ्रेम में बदलते हैं (अर्थात् 10 वैरिएबल्स के 10 ऑब्ज़र्वेशन्स) और एक नेस्टेड for लूप से प्रत्येक तत्व पर एक बीजीय क्रिया करते हैं: हर इटेरेशन पर, एक साइनसोइडल फ़ंक्शन उन दो इंडेक्सेस द्वारा संदर्भित हर तत्व में वृद्धि करता है।

निम्न उदाहरण थोड़ा कृत्रिम है, पर यह किसी सिग्नल को कुछ रैंडम नॉइज़ में जोड़ने का प्रतिनिधित्व कर सकता है:

# This is a bad loop with 'growing' data
set.seed(42)
m = 10
n = 10

# Create matrix of normal random numbers
mymat <- replicate(m, rnorm(n))

# Transform into data frame
mydframe <- data.frame(mymat)

for (i in 1:m) {
  for (j in 1:n) {
    mydframe[i, j] <- mydframe[i, j] + 10 * sin(0.75 * pi)
    print(mydframe)
  }
}

यहाँ, निष्पादन समय का अधिकांश भाग कॉपी करने और लूप को मैनेज करने में लगता है।

देखें कि वेक्टराइज़्ड समाधान कैसा दिखता है:

set.seed(42)
m = 10
n = 10
mymat <- replicate(m, rnorm(n))
mydframe <- data.frame(mymat)
mydframe <- mydframe + 10 * sin(0.75 * pi)
mydframe

यह सरल लगता है: आखिरी पंक्ति नेस्टेड for लूप की जगह लेती है। ध्यान दें कि दोनों इंप्लीमेंटेशन्स का ठीक वही परिणाम सुनिश्चित करने के लिए set.seed() का उपयोग किया गया है।

अब दोनों समाधानों के निष्पादन समय को परिमाणित करते हैं।

आप यह R के सिस्टम कमांड्स, जैसे system.time() का उपयोग करके कर सकते हैं, जिसमें कोड का एक टुकड़ा इस तरह पास किया जा सकता है:

टिप: जिस कोड का आप आकलन करना चाहते हैं, उसे system.time() फ़ंक्शन के कोष्ठकों के बीच रख दें।

# Insert `system.time()` to measure loop execution
for (i in 1:m) {
  for (j in 1:n) {
    mydframe[i, j] <- mydframe[i, j] + 10 * sin(0.75 * pi)
  }
}

# Add `system.time()` to measure vectorized execution
mydframe <- mydframe + 10 * sin(0.75 * pi) 

ऊपर के कोड खंड में, आप m और n चुनने, मैट्रिस बनाने और उसे डेटा फ्रेम में बदलने का काम शुरुआत में केवल एक बार करते हैं, और फिर for वाले भाग का वेक्टराइज़्ड संस्करण के “वन-लाइनर” के मुकाबले दो अलग-अलग system.time() कॉल्स से मूल्यांकन करते हैं।

आप देखते हैं कि केवल m=n=10 की न्यूनतम सेटिंग के साथ भी वेक्टराइज़्ड संस्करण 7 गुना तेज़ है, यद्यपि इतने कम मानों के लिए, यह उपयोगकर्ता के लिए बमुश्किल मायने रखता है।

अंतर (मानवीय पैमाने पर) तब ध्यान देने योग्य हो जाते हैं जब आप m=n=100 रखते हैं, जबकि 1000 तक बढ़ाने पर for लूप कई दर्जन सेकंड तक अटका हुआ लगता है, जबकि वेक्टराइज़्ड रूप अब भी आँख झपकते ही चल जाता है।

m=n=10000 के लिए for लूप एक मिनट से अधिक अटका रहता है जबकि वेक्टराइज़्ड को 2.54 सेकंड लगते हैं। बेशक, इन मापों को हल्के में लेना चाहिए और ये हार्डवेयर और सॉफ्टवेयर कॉन्फ़िगरेशन पर निर्भर होंगे; बेहतर है कि अपने लैपटॉप पर इंटरनेट ब्राउज़र में दर्जनों खुले टैब और पृष्ठभूमि में चल रहे कई अनुप्रयोगों से ओवरलोडिंग से बचें; फिर भी ये माप अंतर की झलक दिखाते हैं।

न्यायपूर्वक कहें तो, m और n की वृद्धि मैट्रिस जनरेशन को भी गंभीर रूप से प्रभावित करती है जैसा कि आप आसानी से प्रतिकृति फ़ंक्शन के चारों ओर एक और system.time() कॉल रखकर देख सकते हैं।

आपको प्रोत्साहित किया जाता है कि m और n के साथ खेलें और देखें कि निष्पादन समय कैसे बदलता है, निष्पादन समय को गुणनफल m x n के एक फ़ंक्शन के रूप में प्लॉट करके। यही प्रासंगिक संकेतक है, क्योंकि यह बनाई गई मैट्रिसों का आयाम व्यक्त करता है। यह इस प्रकार nset-ed for लूप के जरिए कार्य पूरा करने के लिए आवश्यक इटेरेशन्स की संख्या को भी मापता है।

तो यह वेक्टराइजेशन का एक उदाहरण है। पर ऐसे और भी कई हैं। R News, जो R प्रोजेक्ट का न्यूज़लेटर है के पेज 46 पर, एर्रे या मैट्रिस में कुछ आयामों पर सम और औसत निकालने के लिए बहुत दक्ष फ़ंक्शन्स हैं, जैसे: rowSums(), colSums(), rowMeans(), और colMeans()।

इसके अलावा, न्यूज़लेटर यह भी उल्लेख करता है कि “…‘apply’ परिवार के फ़ंक्शन्स, जिनके नाम [s,l,m,t]apply हैं, ऑब्जेक्ट्स के तत्वों/आयामों पर किसी अन्य फ़ंक्शन को लागू करने के लिए दिए गए हैं। ये ‘apply’ फ़ंक्शन्स कभी-कभी काफ़ी जटिल कार्यों के लिए एक संक्षिप्त सिंटैक्स देते हैं जो कि खराब लिखे गए लूप्स की तुलना में अधिक पठनीय और तेज़ है।”.