समानांतर आर

परिचय

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

अस्वीकरण :
मैं प्रस्तुति में विशेष रूप से सख्त होने का दिखावा नहीं करता, मेरा काम पाठकों को एक सामान्य विचार से अवगत कराना है।

आर हर किसी के लिए अच्छा और अच्छा है, लेकिन इसकी दो सीमाएं हैं जो डेटा की थोड़ी मात्रा के साथ काम करते समय लगभग हस्तक्षेप नहीं करती हैं और बड़े मामलों के साथ काम करते समय जीवन को बहुत खराब कर देती हैं:

• सभी कोड एक प्रक्रिया में निष्पादित किए जाते हैं
• सभी डेटा को मेमोरी में संग्रहीत किया जाता है

यह लगभग हमेशा मामला है, अगर आप वास्तव में इसके बारे में नहीं सोचते हैं। और अगर आप इसके बारे में सोचते हैं तो क्या करना है, मैं आपको बताऊंगा।

बिना छोरों बनाम फोरच के काम करें

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

a <- c(); for (i in 1:4) { a<- c(a, i^2) } #   a <- 1:4 * 1:4 # ,   ? 

यदि आपको कुछ नॉनवेज करने की आवश्यकता है, तो आप आवेदन कर सकते हैं। उदाहरण के लिए, एक ही परिणाम इस तरह प्राप्त किया जा सकता है:

  a <- sapply(1:4, function(x) {x^2}) 

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

और समानता कहां है, आप पूछें? यह वह जगह है जहाँ सबसे दिलचस्प झूठ है।
साधारण लोग आए और सोचा: “ये सब लागू होते हैं, सूची, आदि। - यह अच्छा है। लेकिन मुझे राहत नहीं चाहिए। मुझे एक परिचित उपकरण दो। ” और ऐसा एक यंत्र प्रकट हुआ है। आप इसे फॉर्च्यूनर पैकेज में पा सकते हैं।
दरअसल, हम एक ही नाम के कार्य में रुचि रखते हैं, जिसका आकर्षण यह है कि यह चक्र के प्रत्येक चरण में प्राप्त परिणामों को संयोजित कर सकता है (जो मूल को नहीं जानता है, इसके साथ विकृतियों को देखें)। इसके अलावा, आप न केवल कुछ तरीकों से गठजोड़ कर सकते हैं - अपने खुद के कॉम्बिनेटर या किसी भी उपयुक्त फ़ंक्शन को खिला सकते हैं। सबसे आम और उपयोगी सी, सीबीएन, आरबीआईइंड हैं।

  a <- foreach(i=1:4, .combine='c') %do% {i^2} 

चलो चलते हैं!

समानांतर कंप्यूटिंग प्रक्रिया शुरू करने का सबसे कुशल तरीका क्या है? छोटे स्वतंत्र टुकड़ों में कार्य को तोड़ो। यह बिल्कुल वैसा ही है कि R में समानांतरीकरण कैसे काम करता है। फॉर्च्यूनर और doSNOW मॉड्यूल एक आधार के रूप में काम करते हैं।
आइए हमारी गणना के लिए एक "क्लस्टर" बनाएं और उस पर एक सरल परीक्षण चलाएं।

  #   library(foreach) library(doSNOW) cl <- makeCluster(4) registerDoSNOW(cl) a <- mean(foreach(i=1:10^6, .combine='c') %dopar% {mean(rnorm(i))}) stopCluster(cl) 

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

DoSNOW क्लस्टर अलग हैं। संक्षेप में, एक क्लस्टर R इंस्टेंस का एक संग्रह है जो% dopar% के अंदर कोड निष्पादित करता है। उन सभी को एक मशीन पर स्थित किया जा सकता है, लेकिन विभिन्न पर भी स्थान दिया जा सकता है।

  cl1 <- makeCluster(c("localhost","remotehost"), type = "SOCK") 

कुल मिलाकर, चार प्रकार के क्लस्टर उपलब्ध हैं: PVM (http://www.csm.ornl.gov/pvm/), MPI (http://cran.r-project.org/web/packages/Rmpi/index.html), NWS (http://nws-r.sourceforge.net/) और SOCK पहले तीन के लिए, अतिरिक्त पुस्तकालयों (वास्तव में, कार्यान्वयन) की आवश्यकता होगी, डिफ़ॉल्ट रूप से सॉकेट क्लस्टर शुरू हो जाएगा।

डिबगिंग और विभिन्न प्रकार के सभी आँकड़ों के लिए, आप स्नो.टाइम फ़ंक्शन का उपयोग कर सकते हैं, इसमें सभी कॉलों को लपेटकर:

  cl <- makeCluster(4) registerDoSNOW(cl) tm <- snow.time(a <- mean(foreach(i=1:10^6, .combine='c') %dopar% {mean(rnorm(i))})) print(tm) plot(tm) stopCluster(cl) 

निम्नलिखित तस्वीरें प्राप्त की हैं:

और एक बकरी बटन समझौते के लिए क्या?

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

• गणना को एक बहुत बड़ी समयावधि पर चलाएं (विनिमय रणनीति के प्रदर्शन का प्रारंभिक मूल्यांकन)
• इसी तरह के डेटासेट के एक सेट पर गणना शुरू करें (RxQ क्रॉस-वेलिडेशन)

मुझे लगता है कि आप अपने स्वयं के उद्देश्यों के लिए इस दृष्टिकोण का उपयोग करने में सक्षम होंगे। सौभाग्य है