🚜 ✋ #⃣ आर में समानांतर कम्प्यूटिंग का परिचय 👨🏻 🔓 🐢

यह लेख आर भाषा के बारे में है । यह पूर्व-यूएसएसआर में मतलाब और विशेष रूप से पायथन के रूप में व्यापक नहीं है, लेकिन यह निश्चित रूप से ध्यान देने योग्य है। यह ध्यान दिया जाना चाहिए कि आर वास्तव में डेटा विज्ञान के लिए मानक है (हालांकि यह अच्छी तरह से यहां लिखा गया है कि डेटा वैज्ञानिक केवल रुपये नहीं हैं)। रिच सिंटैक्स, विरासत कोड के साथ संगतता (जो कि वैज्ञानिक अनुप्रयोगों में बहुत महत्वपूर्ण है), RStudio का सुविधाजनक विकास वातावरण और CRAN बनाने में बड़ी संख्या में पुस्तकालयों की उपस्थिति इस तरह की है।

लेकिन, हमेशा की तरह, सिक्के का फ्लिप पक्ष (या बल्कि, दुभाषिया आर) कम्प्यूटेशनल गति है । आर वेक्टरकृत कंप्यूटिंग का समर्थन करता है - कार्यों का लागू परिवार छोरों के उपयोग से बचा जाता है। लेकिन यह, सामान्य रूप से, वाक्यात्मक चीनी है, और अक्सर * लागू करने से "त्वरण" का प्रभाव सीधे नकारात्मक होता है। इस पृष्ठभूमि के खिलाफ, संगणना का समानांतर होना पूरी तरह से तर्कसंगत कदम लगता है (यदि हम निम्न-स्तरीय भाषाओं में परिवर्तन पर विचार नहीं करते हैं)। यह कोई रहस्य नहीं है कि इस प्रक्रिया के साथ कोड को संसाधित करना मुश्किल है।

आगे के काम के लिए, दो पैकेजों की आवश्यकता होगी - "फॉर्च्यूनर" (आपको फोरच निर्माण का उपयोग करने की अनुमति देता है) और "doSNOW" (समानांतर कंप्यूटिंग के लिए समर्थन प्रदान करता है)। CRAN से उन्हें इस तरह स्थापित किया जा सकता है:

install.packages(c("foreach","doSNOW"))

निम्नलिखित कमांड - ऑपरेशन के लिए तीन प्रोसेसर कोर का "क्लस्टर" तैयार करना:

 library(foreach) library(doSNOW) cluster <- makeCluster(3, type = "SOCK", outfile="") registerDoSNOW(cluster)

एक उदाहरण पर विचार करें जहां 1 से 10000 तक की संख्याओं के वर्ग की गणना की जाती है:

 system.time ({ sum.par <- foreach(i=1:10000, .combine='+') %dopar% { i^2 }})

सिद्धांत रूप में, सब कुछ एक सामान्य चक्र के समान है, सिवाय इसके कि आपको यह निर्दिष्ट करने की आवश्यकता है कि परिणामों को कैसे समूहित किया जाए - इस मामले में, यह एक अतिरिक्त ऑपरेशन है (और अक्सर ये फ़ंक्शन सी, आरबीएनडी, सिबिंड - या आपके द्वारा स्वयं लिखित एक फ़ंक्शन हैं)। यदि यह मायने नहीं रखता है कि किस क्रम में समूह बनाना है, तो .inorder = F तर्क का उपयोग करके आप कुछ हद तक गणना में तेजी ला सकते हैं। यदि% dopar% के बजाय% do% निर्देश का उपयोग किया जाता है, तो गणना क्रमिक रूप से की जाएगी (अर्थात, सामान्य लूप में)। वैसे, इस तरह के एक सरल कार्य के लिए, अनुक्रमिक संस्करण में निष्पादन का समय काफी कम होगा, क्योंकि बैलेंस शीट में अंतिम स्थान से दूर समानांतर संस्करण में डेटा हेरफेर के लिए ओवरहेड की लागत।

चलिए और भी मुश्किल काम पर चलते हैं। मान लीजिए कि हमारे पास यादृच्छिक चर x का वेक्टर है।

छिपा हुआ पाठ

 trials <- 10000 n <- 24000 alfa <- 1.6 beta <- 3 set.seed(1) x <- c(rgamma(n/3, shape=alfa, scale=beta), rgamma(n/3, shape=3*alfa, scale=4*beta), rgamma(n/3, shape=10*alfa, scale=3*beta)) plot(density(x, kernel="cosine"),lwd=2, col="blue", xlab="x",ylab="Density", main="Density plot") abline(v = median(x), col = "red", lty=5)

हम मंझले का अनुमान लगाते हैं - आत्मविश्वास अंतराल के साथ। ऐसा करने के लिए, बूटस्ट्रैप लागू करें और क्रमशः सीरियल कोड और समानांतर के लिए निष्पादन समय को मापें:

 set.seed(1) seq.time <- system.time({ seq.medians <- foreach(icount(trials), .combine=cbind) %do% { median(sample(x, replace = T)) } })

 > quantile(seq.medians, c(.025, .975)) 2.5% 97.5% 52.56311 54.99636 > seq.time user system elapsed 19.884 0.252 20.138

 set.seed(1) par.time <- system.time({ par.medians <- foreach(icount(trials), .combine=cbind) %dopar% { median(sample(x, replace = T)) } })

 > quantile(par.medians, c(.025, .975)) 2.5% 97.5% 52.56257 54.94890 > par.time user system elapsed 4.252 0.420 10.893

अंतर काफी ध्यान देने योग्य है। आइए हम एक ही कार्य के लिए एक अनुक्रमिक "वेक्टरकृत" संस्करण के चल रहे समय का मूल्यांकन करें (लागू फ़ंक्शन का उपयोग करके):

 set.seed(1) seq.time.ap <- system.time({ seq.medians.ap <- apply(matrix(sample(x, trials*n, replace = T), trials, n), 1, median) })

 > quantile(seq.medians.ap, c(.025, .975)) 2.5% 97.5% 52.56284 54.98266 > seq.time.ap user system elapsed 23.732 1.728 25.472

मशीन लर्निंग एल्गोरिदम के मापदंडों को निर्धारित करने के लिए एक समान दृष्टिकोण का उपयोग किया जा सकता है। उदाहरण के लिए, RSNNS पैकेज में Elman नेटवर्क (जहां तक मुझे पता है, R में, सामान्य रूप से, आवर्तक नेटवर्क के साथ काम करने के लिए कोई अन्य पैकेज नहीं हैं) के प्रशिक्षण के लिए कार्य हैं। न्यूरॉन्स की संख्या और सीखने की दर का विकल्प एक संसाधन-गहन कार्य है, इसलिए, यह समानांतर बनाने के लिए समझ में आता है।
हम गोलाकार उदाहरणों से अधिक दबाव वाली समस्या से गुजरते हैं। ऐसा करने के लिए, दो पैकेज स्थापित करें:

 install.packages(c("ElemStatLearn","RSNNS"))

ElemStatLearn पैकेज से, हमें दो डेटा सेट चाहिए- zip.train और zip.test, जिसमें gzipped handwritten digit images हैं। डेटासेट काफी मात्रा में होते हैं, तो चलो उनमें से केवल एक हिस्सा लेते हैं: क्रमशः नेटवर्क प्रशिक्षण, सत्यापन और परीक्षण के लिए।

छिपा हुआ पाठ

 library("ElemStatLearn") library(RSNNS) data(zip.train) data(zip.test) image(zip2image(zip.train, 1000), col=gray(255:0/255)) train <- zip.train[1:1000,-1] trainC <- decodeClassLabels(zip.train[1:1000,1]) valid <- zip.train[1001:1200,-1] validC <- zip.train[1001:1200,1] test <- zip.test[1:1000,-1] testC <- zip.test[1:1000,1]

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

 comb <- function(df1, df2) if (df1$err < df2$err) df1 else df2

जैसा कि आप कोड से देख सकते हैं, फ़ंक्शन दो डेटा फ़्रेम के गलत क्षेत्र की तुलना करता है और उस जगह का चयन करता है जहां त्रुटि कम है। स्क्रिप्ट टुकड़ा जो सीधे समानांतर मोड में नेटवर्क के प्रशिक्षण प्रदान करता है, सीधे नीचे प्रस्तुत किया गया है। हम इसे लॉन्च करते हैं और कुछ समय के लिए हम तीन गुठली के 100% लोडिंग की प्रशंसा करते हैं।

 errCl <- function (predicted, true){ return(round(sum(predicted != true)/length(true), 4)) } size <- c(13,29,53,71) lr <- c(.001,.01,.1,.5) nn.time <- system.time({ elm_par <- foreach(s=size, .combine='comb') %:% foreach(r=lr, .packages='RSNNS', .combine='comb', .inorder=F) %dopar% { elm <- elman(x=train, y=trainC, size=s, learnFunc="JE_BP", learnFuncParams=r, linOut=F, maxit=193) pred <- max.col(predict(elm, valid)) - 1 e <- errCl(pred, validC) data.frame(opt_size=s, lrate=r, err=e) } })

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

 > elm_par opt_size lrate err 1 29 0.5 0.05 > nn.time user system elapsed 0.312 0.168 179.542

हालांकि, ज़ाहिर है, 5% त्रुटि के साथ अपने आप को चापलूसी मत करो। चलो एक परीक्षण सेट पर 29 न्यूरॉन्स और 0.5 के प्रशिक्षण दर के साथ हमारे नेटवर्क का परीक्षण करें:

 elm <- elman(x=train, y=trainC, size=29, learnFunc="JE_BP", learnFuncParams=0.5, linOut=F, maxit=193) pred <- max.col(predict(elm, test)) - 1 e <- errCl(pred, testC)

 > e [1] 0.119

वैसे 11.9% भी बहुत अच्छा है। अब केवल एक ही चीज क्लस्टर को "चुकाना" है

 stopCluster(cluster)

एक निष्कर्ष के बजाय

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

साहित्य

आर के साथ उच्च प्रदर्शन और समानांतर कम्प्यूटिंग
घोंसले के शिकार फंदे
RSNNS पैकेज

आर में समानांतर कम्प्यूटिंग का परिचय

एक निष्कर्ष के बजाय

साहित्य

More articles: