मल्टीथ्रेडिंग द्वारा R में गणनाओं को गति देने का एक उदाहरण

परिचय

विकिपीडिया से निम्नानुसार है:

आर सांख्यिकीय डेटा प्रोसेसिंग और ग्राफिक्स के लिए एक प्रोग्रामिंग भाषा है, साथ ही जीएनयू परियोजना के भीतर एक मुक्त ओपन-सोर्स कंप्यूटिंग वातावरण है।

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

समस्या का बयान

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

सामग्री और तरीके

हमने आर 2.15.2 , न्यूरलनेट - 1.32, समानांतर - 2.15.2, रेंबमार्क - 1.0.0 का उपयोग किया। विंडोज 7 चलाने वाला कंप्यूटर, एक Intell Core i5-2550K CPU @ 3.40GHz (4 कोर) और 8GB RAM है। अंतर्निहित डेटा डेटा (अनुमान, पैकेज = "डेटासेट")।

परिणाम और चर्चा

सबसे पहले, चलो एक तंत्रिका नेटवर्क की सामान्य गणना के दौरान प्रोसेसर लोड को देखते हैं। एक उदाहरण को मामूली संशोधन के साथ न्यूरलनेट पैकेज के विवरण से लिया गया है: थ्रेशोल्ड = 0.0001 - स्टॉपिंग मानदंड में से एक, और गणना का दोहराव = 20 - 20 पुनरावृत्ति, ताकि गणना अधिक "जटिल" हो।

nn<-function() { print(" ") neuralnet(case~parity+induced+spontaneous, infert, err.fct="ce", linear.output=FALSE, likelihood=TRUE,rep=20, threshold=0.0001) } nn() 

आप विंडोज टास्क मैनेजर से देख सकते हैं कि निष्पादन के दौरान प्रोसेसर कोर का केवल एक उपयोग किया जाता है और सीपीयू लोड 25% है।
अब इस कोड के निष्पादन समय को मापें। इसके लिए, मैंने रिंचमार्क पैकेज का उपयोग किया। सामान्य तौर पर, माप के लिए कोड इस तरह दिखेगा:

 within(benchmark(test.name=test.function(), #      replications=c(3), #     (+1   "") columns=c('test', 'replications', 'elapsed'), #       order=c('elapsed', 'test')), #    { average = elapsed/replications }) #         

परिणाम है:

  test replications elapsed average 1 _ 3 47.83 15.94333333 

अब, इस समय की तुलना प्रतिनिधि = 20 विकल्प के माध्यम से नहीं बल्कि 20 उदाहरणों के साथ करें, उदाहरण के लिए, नीलम।

 nn.s<-function() { print(" ") nets<-sapply(1:20, function(X) neuralnet(case~parity+induced+spontaneous, infert, err.fct="ce", linear.output=FALSE, likelihood=TRUE,rep=1, threshold=0.0001)) } 

यह पता चला है:

  test replications elapsed average 1 _ 3 46.05 15.35 2 _ 3 47.52 15.84 

रनटाइम लगभग समान है। स्पष्ट रूप से न्यूरलनेट फ़ंक्शन के अंदर रिट्रीस के निष्पादन का कोई अनुकूलन नहीं है। शेष गुठली का उपयोग करने के लिए हम समानांतर पैकेज का उपयोग करते हैं । यह R c संस्करण 2.14.0 का हिस्सा है और आपको कई स्वतंत्र थ्रेड्स में कोड निष्पादित करने की अनुमति देता है। प्रत्येक थ्रेड न्यूरलनेट का कार्य करेगा ।

 nn.p<-function() { print(" ") cl <- makeCluster(getOption("cl.cores", 4)) #       clusterExport(cl,"infert") #     clusterEvalQ(cl,library(neuralnet)) #   neuralnet   parSapply(cl, 1:20, function(X) #   sapply neuralnet(case~parity+induced+spontaneous, infert, err.fct="ce", linear.output=FALSE, likelihood=TRUE,rep=1, threshold=0.0001) ) stopCluster(cl) } 

लीड समय की तुलना करें:

  test replications elapsed average 3 _ 3 17.38 5.793333333 2 _ 3 45.88 15.293333333 1 _ 3 46.61 15.536666667 

इस प्रकार, समानांतर संस्करण 2.5 गुना से अधिक तेज है। इस मामले में, प्रोसेसर लोड 100% है।

सुविधा के लिए, आप न्यूरलनेट फ़ंक्शन के लिए अपना स्वयं का रैपर बना सकते हैं।

 pneuralnet <- function(formula, data, rep=1, ..., cl) { clusterExport(cl,"data") clusterEvalQ(cl,library(neuralnet)) nets <- parLapply(cl, 1:rep, function(X) neuralnet(formula, data, rep=1, ...) ) #       reached.threshold nets <- nets[order(sapply(1:rep,function(i){nets[[i]]$result.matrix["reached.threshold", ]}))] return(nets) } cl <- makeCluster(getOption("cl.cores", 4)) nets <- pneuralnet(case~parity+induced+spontaneous, infert, err.fct="ce", linear.output=FALSE, likelihood=TRUE,rep=4, threshold=0.0001, cl=cl) stopCluster(cl)