पिछले लेख में, मैंने इस बारे में बात की थी कि मल्टीथ्रेडिंग क्या है और RAND में Yandex.Direct API के साथ काम करते समय इसके कार्यान्वयन के उदाहरण दिए हैं, doParallel , doParallel और foreach निर्माण का उपयोग करते हुए।

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

सामग्री

• कार्य
• ट्रेनिंग
• सीरियल प्रोसेसिंग सॉल्यूशन उदाहरण, सैपली फंक्शन और purrr पैकेज
  
  • नीरस कार्य
  • Purrr पैकेज
• Yandex.Direct से कीवर्ड एकत्रित करने के कार्य को हल करने के लिए बहुस्तरीय विकल्प
  
  • समानांतर पैकेज
  • भविष्य का पैकेज
  • भविष्य में लपेटने वाले
    
    • Future.apply पैकेज
    • Furrr पैकेज
• गति परीक्षण
• निष्कर्ष
• साक्षात्कार

कार्य

एक उदाहरण के रूप में, हम पिछले प्रकाशन में विचार की गई समस्या को लेते हैं, अर्थात्। बहु-थ्रेडेड मोड में, 4 Yandex.Direct विज्ञापन खातों से कीवर्ड की एक सूची एकत्र करें।

Yandex.Direct API के साथ काम करने के लिए, हम ryandexdirect पैकेज का उपयोग करेंगे। इसके लिए आधिकारिक दस्तावेज लिंक पर है , लेकिन वर्णित कार्य के कार्यान्वयन के लिए, हमें केवल 2 कार्यों की आवश्यकता है:

• yadirAuth - Yandex.Direct API में प्राधिकरण;
• yadirGetKeyWords - विज्ञापन खातों से कीवर्ड की एक सूची डाउनलोड करें।

यह सिर्फ यह नहीं है कि मैंने कीवर्ड डाउनलोड करने की प्रक्रिया को चुना, तथ्य यह है कि यह Yandex.Direct API में सबसे लंबे ऑपरेशनों में से एक है। दूसरे, सभी खातों में कीवर्ड की संख्या अलग-अलग होती है, इसलिए, प्रत्येक खाते के लिए इस ऑपरेशन को पूरा करने का समय बहुत अलग होगा, हमारे मामले में 1 से 20 सेकंड तक।

ट्रेनिंग

प्रारंभ में, आपको इस आलेख में चर्चा किए गए सभी पैकेजों को स्थापित करने की आवश्यकता है, इसके लिए आप नीचे दिए गए कोड का उपयोग कर सकते हैं।

 #    install.packages("ryandexdirect") install.packages("tictoc") install.packages("rbenchmark") install.packages("dplyr") install.packages("purrr") install.packages("future") install.packages("promises") install.packages("furrr") install.packages("future.apply") 

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

हम Yandex.Direct logins से मिलकर एक वेक्टर बनाते हैं, जिसमें से बाद में हम कीवर्ड के लिए अनुरोध करेंगे:

 logins <- c("login1", "login2", "login3", "login4") 

Yandex.Direct API के साथ काम करने के लिए, आपको पहले प्रत्येक खाते के अंतर्गत प्राधिकरण से गुजरना होगा, इसके लिए आप निम्नलिखित डिज़ाइन का उपयोग कर सकते हैं:

 lapply(logins, function(l) { yadirAuth(Login = l)}) 

उपरोक्त कोड चलाने के बाद, प्रत्येक खाते के तहत प्राधिकरण के लिए एक ब्राउज़र खुल जाएगा। आप अपने विज्ञापन सामग्री तक पहुंचने के लिए ryandexdirect की अनुमति की पुष्टि करते हैं। आपको उस पृष्ठ पर पुनः निर्देशित किया जाएगा जहां आपको सत्यापन कोड की प्रतिलिपि बनाने की आवश्यकता है। इसे R कंसोल में दर्ज करके, प्राधिकरण प्रक्रिया को पूरा करें। यह कार्य वेक्टर लॉगिन बनाते समय आपके द्वारा निर्दिष्ट प्रत्येक लॉगिन के लिए दोहराया जाता है।

कुछ उपयोगकर्ता, प्राधिकरण प्रक्रिया के दौरान, किसी तृतीय-पक्ष संसाधन के रीडायरेक्ट के तथ्य से भ्रमित हो सकते हैं, लेकिन इसमें आपके खाते के लिए कोई खतरा नहीं है, मैंने इस विषय पर लेख "एडवर्टाइज़मेंट एपीआई के साथ काम करने के लिए आर पैकेज का उपयोग करना कितना सुरक्षित है" में अधिक विस्तार से वर्णन किया है।

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

सीरियल प्रोसेसिंग सॉल्यूशन उदाहरण, सैपली फंक्शन और purrr पैकेज

पिछले लेख में , मैंने एक उदाहरण के रूप में लूप के for एक समाधान का हवाला दिया। चूंकि हमने foreach पैकेज का उपयोग करते हुए मल्टीथ्रेडिंग पर विचार किया था, जो सिंटैक्स लूप जैसा दिखता है, यह उदाहरण वहां उपयुक्त था, हालांकि आर के उपयोगकर्ताओं द्वारा लूप के उपयोग का स्वागत नहीं किया गया है।

इस लेख में हम जिन पैकेजों पर विचार करेंगे, वे सिंटैक्स में लागू परिवार के कार्यों की अधिक याद दिलाते हैं; इसलिए, मैं उनका उपयोग करके सीरियल मोड में समाधान का एक उदाहरण दूंगा।

sapply कार्य

आदेशों के निष्पादन समय का अनुमान लगाने के लिए, प्रत्येक दृष्टिकोण में, हम tictoc पैकेज का उपयोग करेंगे।

 library(tictoc) library(dplyr) tic() #   kw.sapply <- sapply( logins, #  ,     function(x) #        #     { yadirGetKeyWords(Login = x) %>% mutate(login = x) }, simplify = FALSE #     ) toc() #   #       result.sapply <- do.call("rbind", kw.sapply) 

39.36 sec elapsed समय: 39.36 sec elapsed

सबसे पहले, apply परिवार के कार्यों के वाक्यविन्यास को छोरों के वाक्यविन्यास के रूप में पढ़ना आसान नहीं है, लेकिन वास्तव में, सब कुछ काफी सरल है।

sapply(X, FUN)

जहां:

• एक्स - एक वस्तु जिसके तत्वों को हम प्रत्येक पुनरावृत्ति पर बदले में उपयोग करेंगे और उपयोग करेंगे, लूप के लिए यह इस तरह दिखता था: के for(i in X) ;
• FUN - एक फ़ंक्शन जिसमें हम ऑब्जेक्ट एक्स के प्रत्येक तत्व को बदले में प्रतिस्थापित करेंगे, अगर हम इसके साथ एक सादृश्य खींचते हैं, तो यह लूप का शरीर है।

कोड उदाहरण 4 में , पहले बनाए गए लॉगिन वेक्टर को X तर्क में पास किया जाता है। लॉगिन वेक्टर का प्रत्येक तत्व बारी-बारी से अनाम फ़ंक्शन function(x) { yadirGetKeyWords(Login = x) %>% mutate(login = x) } लिए केवल तर्क के रूप में पारित किया जाता है जिसे FUN तर्क में पारित किया गया था।

यानी sapply FUN 4 बार में निर्दिष्ट फ़ंक्शन को निष्पादित करेगा, एक-एक करके इसमें लॉगिन का प्रतिस्थापन करेगा, और परिणाम को 4 तत्वों से मिलकर एक सूची (वर्ग सूची के ऑब्जेक्ट) के रूप में वापस करेगा। प्रत्येक तत्व एक तालिका है जिसमें प्रत्येक पुनरावृत्ति पर खाते से प्राप्त खोजशब्दों की एक सूची है।

1. yadirGetKeyWords(Login = "login1") %>% mutate(login = "login1")
2. yadirGetKeyWords(Login = "login2") %>% mutate(login = "login2")
3. yadirGetKeyWords(Login = "login3") %>% mutate(login = "login3")
4. yadirGetKeyWords(Login = "login4") %>% mutate(login = "login4")

sapply का उपयोग करके प्राप्त वस्तु में निम्नलिखित संरचना है:

 summary(kw.sapply) 

  Length Class Mode login1 19 data.frame list login2 19 data.frame list login3 19 data.frame list login4 19 data.frame list 

इस उदाहरण के अंत में, कमांड result.sapply <- do.call("rbind", kw.sapply) kw.sapply सूची के सभी 4 तत्वों को एक result.sapply फ्रेम में जोड़ता है।

 # A tibble: 6,804 x 1 result.sapply$Id $Keyword $AdGroupId $CampaignId $ServingStatus $State <dbl> <fct> <dbl> <int> <fct> <fct> 1 15164230566 ~ 3597453985 39351725 ELIGIBLE ON 2 15164230567  ~ 3597453985 39351725 ELIGIBLE ON 3 15164230568  ~ 3597453985 39351725 ELIGIBLE ON 4 15164230569 ~ 3597453985 39351725 ELIGIBLE ON 5 15164230570 ~ 3597453985 39351725 ELIGIBLE ON 6 15164230571  ~ 3597453985 39351725 ELIGIBLE ON 7 15164230572 ~ 3597453985 39351725 ELIGIBLE ON 8 15164230573  ~ 3597453985 39351725 ELIGIBLE ON 9 15164230574 ~ 3597453985 39351725 ELIGIBLE ON 10 15164230575 ~ 3597453985 39351725 ELIGIBLE ON # ... with 6,794 more rows, and 13 more variables: $Status <fct>, # $StrategyPriority <fct>, $StatisticsSearchImpressions <int>, # $StatisticsSearchClicks <int>, $StatisticsNetworkImpressions <int>, # $StatisticsNetworkClicks <lgl>, $UserParam1 <chr>, $UserParam2 <chr>, # $ProductivityValue <lgl>, $ProductivityReferences <lgl>, $Bid <dbl>, # $ContextBid <dbl>, $login <chr> 

sapply अलावा, कार्यों के *apply परिवार में शामिल हैं: apply , lapply , vapply , mapply और अन्य।

purrr पैकेज

 library(purrr) library(dplyr) library(tictoc) tic() #   result.purrr <- map_df( logins, #  ,     ~ #   function(.x) { yadirGetKeyWords(Login = .x) %>% mutate(login = .x) } ) toc() #   

35.46 sec elapsed समय: 35.46 sec elapsed

purrr पैकेज हेडली विकम द्वारा लिखी गई tidyverse लाइब्रेरी के कोर का हिस्सा है।

अर्थ और वाक्य रचना के संदर्भ में, पैकेज के मुख्य कार्य sapply समान हैं, इसका मुख्य लाभ इस प्रकार है:

• फ़ंक्शंस को फैमिली map , map , map2 , pmap map2 में बांटा गया है walk और एक ही फ़ैमिली में शामिल अलग-अलग फ़ंक्शंस अलग-अलग फॉर्मेट में रिजल्ट लौटाते हैं: chr , dbl , int , df , आदि;
• map2 परिवार के कार्य आपको दो वस्तुओं के साथ-साथ तत्वों (पुनरावृति) पर map2 करने की map2 हैं;
• pmap परिवार के कार्य आपको किसी भी संख्या के तत्वों पर एक साथ pmap करने की pmap हैं। आप इनपुट .l तर्क ( sapply में एक्स तर्क का एक एनालॉग) के लिए एक तालिका पारित कर सकते हैं, जिनमें से प्रत्येक कॉलम में वे मान शामिल होंगे जिनके द्वारा आप पुनरावृत्ति करेंगे, और जिन्हें .f (FUN एनालॉग) से पारित एक ही फ़ंक्शन के तर्कों में बदले में प्रतिस्थापित किया जाएगा । नीलम) ।

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

 library(purrr) #      agencies <- c("agency1", NA, "agency2", "agency1") #      #         result.pmap2 <- map2_df(.x = logins, .y = agencies, ~ { yadirGetKeyWords(Login = .x, AgencyAccount = .y) %>% mutate(login = .x) }) 

अब उस स्थिति की कल्पना करें कि जब आप अलग-अलग खातों में लॉग इन करते हैं, तो आपने फ़ाइल को अलग-अलग फ़ोल्डरों में क्रेडेंशियल के साथ सहेजा है, फिर आपको तीन वस्तुओं पर तुरंत पुनरावृति करने की आवश्यकता है: विज्ञापन खातों के लॉगिन, एजेंट खातों के लॉगिन, जिस पथ में फ़ाइल क्रेडेंशियल संग्रहीत है। यह मदद से किया जा सकता है। pmap परिवार के pmap ।

 library(purrr) #  ,       #      TokenPath <- c("C:\\proj1\\tokens", "C:\\yandex\\token", "C:\\yandex\\token", "C:\\my_yandex_acoount") #   pmap.result <- pmap_df(list(Login = logins, AgencyAccount = agencies, TokenPath = TokenPath), yadirGetKeyWords) 

तदनुसार, फ़ंक्शंस map_df , map2_df और pmap_df को निष्पादित करने का परिणाम दिनांक फ़्रेम है, और उनका उपयोग करते समय, उदाहरण के लिए sapply ( do.call("rbind", kw.sapply) ) के साथ अंतिम चरण की आवश्यकता नहीं है।

कोड अधिक कॉम्पैक्ट हो गया है और थोड़ी तेजी से निष्पादित किया गया है, लेकिन फिर भी, वर्णित दृष्टिकोण, sapply और purrr , प्रत्येक खाते से क्रमिक रूप से कीवर्ड एकत्र करते हैं। इसलिए, इस ऑपरेशन का कुल निष्पादन समय सभी चार खातों से डेटा के संग्रह की अवधि के बराबर है।

समय [कुल] = समय [लॉगिन 1] + समय [लॉगिन 2] + समय [लॉगिन 3] + समय [लॉगिन 4]

Yandex.Direct से कीवर्ड एकत्रित करने के कार्य को हल करने के लिए बहुस्तरीय विकल्प

इसलिए, यदि आपने पहले लेख पढ़ा है, तो आप जानते हैं कि ऑपरेशन के बहुस्तरीय मोड में कई विशेषताएं हैं:

• प्रत्येक धागा एक साफ काम के माहौल के साथ एक अलग आर सत्र में शुरू होता है।
• इसी कारण से, एक अलग चल रही प्रक्रिया में, पहले से जुड़े पैकेट डिफ़ॉल्ट रूप से प्रेषित नहीं होते हैं।

एक काम के माहौल में बनाई गई वस्तुओं को निर्यात करना, और प्रत्येक दृष्टिकोण में संकुल को अलग-अलग तरीके से कार्यान्वित किया जाता है, फिर हम उन्हें और अधिक विस्तार से विचार करेंगे।

parallel पैकेज

इस पैकेज को पहली बार संस्करण 2.14.0 में आर पैकेज में शामिल किया गया था और आज तक यह आर के साथ आता है।

 library(parallel) library(tictoc) #   cl <- makeCluster(4) #      clusterExport(cl = cl, varlist = "logins") #  ,      #  ,       ryandexdirect clusterEvalQ(cl = cl, { library(ryandexdirect) library(dplyr) } ) tic() #   parallel.kw <- parSapplyLB(cl = cl, #   X = logins, # ,     FUN = function(x) { #      #      X yadirGetKeyWords(Login = x) %>% mutate(login = x) }, simplify = F) #    toc() #     #   stopCluster(cl) #      result.parallel <- dplyr::bind_rows(parallel.kw) 

16.75 sec elapsed समय: 16.75 sec elapsed

कोड 8 को पार्स करने की कोशिश करते हैं। makeCluster फ़ंक्शन 4 प्रक्रियाओं का एक क्लस्टर बनाता है। हम अपने मुख्य काम के माहौल से clusterExport फ़ंक्शन का उपयोग करके निर्मित क्लस्टर में वस्तुओं का निर्यात कर सकते हैं, इसके लिए हमें इसके तर्कों का उपयोग करने की आवश्यकता है:

• सीएल - क्लस्टर जिसमें हम वस्तुओं का निर्यात करेंगे
• varlist - एक पाठ वेक्टर जिसमें प्रत्येक क्लस्टर प्रक्रिया में निर्यात की जाने वाली वस्तुओं के नाम होते हैं।

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

parSapplyLB क्लस्टर नोड्स के बीच लोड संतुलन के साथ sapply फ़ंक्शन का एक समानांतर संस्करण है, वे भी इसका उपयोग करते हैं, लेकिन आपको क्लस्टर तर्क के साथ क्लस्टर निर्दिष्ट करने की आवश्यकता है।

parallel में भी *apply परिवार के कार्यों को *apply अन्य समानांतर संस्करण हैं: parLapply , parSapply , parApply , आदि।

parSapply केवल parSapplyLB से भिन्न है, क्योंकि इसमें क्लस्टर नोड्स पर लोड संतुलन नहीं है।

निर्मित क्लस्टर को रोकने के लिए स्टॉप क्लस्टर फ़ंक्शन का उपयोग किया जाता है।

अंतिम कमांड, dplyr::bind_rows(parallel.kw) हम parSapplyLB का उपयोग करके प्राप्त समानांतर . parSapplyLB ऑब्जेक्ट को एक तालिका में parSapplyLB ।

लिनक्स के लिए, parallel में अलग-अलग कार्य हैं: mclapply , mcmapply , mcMap । अक्सर इस ऑपरेटिंग सिस्टम में, कमांड तेजी से निष्पादित होते हैं, और कोड अधिक कॉम्पैक्ट हो जाता है।

 library(parallel) library(tictic) library(dplyr) library(ryandexdirect) tic() mclapply.kw <- mclapply(logins, FUN = function(x) { #      #      X yadirGetKeyWords(Login = x) %>% mutate(login = x) }, mc.cores = 4) toc() 

इन कार्यों का उपयोग करते समय, makeCluster क्लस्टर makeCluster का उपयोग करके क्लस्टर शुरू करने की कोई आवश्यकता नहीं है। mc.cores तर्क का उपयोग करके आपके द्वारा निर्दिष्ट नोड्स की संख्या। पैकेज और निर्यात ऑब्जेक्ट को कनेक्ट करने की भी आवश्यकता नहीं है, ये ऑपरेशन स्वचालित रूप से किए जाते हैं।

future पैकेज

आर में अतुल्यकालिक प्रोग्रामिंग के लिए सबसे आधुनिक दृष्टिकोणों में से एक।

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

 library(future) #    plan(multiprocess) #      #    future.kw <- future({yadirGetKeyWords(Login = logins[4])}, packages = "ryandexdirect", globals = "logins") #     resolved(future.kw) #     future.result.1 <- value(future.kw) 

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

• अनुक्रमिक - यह ऑपरेशन का सामान्य आर मोड है, कमांड को वर्तमान सत्र में क्रमिक रूप से निष्पादित किया जाता है;
• बहुक्रिया - समानांतर मोड, वर्तमान मशीन पर पृष्ठभूमि में चल रहे सत्रों में कमांड निष्पादित किए जाएंगे, जबकि आपका कामकाजी सत्र अवरुद्ध नहीं होगा;
• क्लस्टर - समानांतर मोड, कमांड को वर्तमान या रिमोट मशीन पर निष्पादित किया जाएगा, समान parallel पैकेज में कैसे लागू किया जाता है।

संपूर्ण future पैकेज वर्तमान सत्र को अवरुद्ध किए बिना पृष्ठभूमि प्रक्रियाओं में कमांड निष्पादित करने पर आधारित है। कमांड चलाना निष्पादन उसी नाम के future के कार्य का अनुसरण करता है, इसलिए जब हम कमांड चलाते हैं:

 future({yadirGetKeyWords(Login = logins[4])}, packages = "ryandexdirect", globals = "logins") 

R में हमारा वर्तमान सत्र अवरुद्ध नहीं है, और आदेश को पृष्ठभूमि में निष्पादित किया गया है, एक और R सत्र चला रहा है।

आप resolved फ़ंक्शन का उपयोग करके किसी दिए गए अभिव्यक्ति की निष्पादन प्रक्रिया की वर्तमान स्थिति की जांच कर सकते हैं। अंत में, value फ़ंक्शन का उपयोग future निष्पादन के परिणाम प्राप्त करने के लिए किया जाता है। यदि आप समानांतर चलने वाले सत्र में अपने future रन से पहले value फ़ंक्शन चलाते हैं, तो समानांतर सत्र की अभिव्यक्ति पूरी होने तक वर्तमान कार्य सत्र अवरुद्ध हो जाएगा।

सबसे उन्नत कार्य उदाहरण future promises के साथ उपयोग है।

 library(future) library(promises) #    plan(multiprocess) #      #    future.kw <- future({suppressMessages( yadirGetKeyWords(Login = logins[4]))}, packages = "ryandexdirect", globals = "logins") %...>% #     future, #      nrow() %...>% paste("words loaded") %...>% print() 

promises पैकेज पाइपलाइन ऑपरेटरों का एक सेट प्रदान करता है जो future कार्यक्षमता को पूरी तरह से पूरक करता है।

कोड 11 उदाहरण में, पृष्ठभूमि में, हम एक विज्ञापन खाते से कीवर्ड डाउनलोड करने की प्रक्रिया शुरू करते हैं। इसके अलावा, पाइपलाइन ऑपरेटर %...>% कार्य सत्र को अवरुद्ध किए बिना %...>% future होने की प्रतीक्षा करता है, और शेष संचालन करता है। future काम पूरा होने पर कोड निष्पादन के परिणामस्वरूप, निर्दिष्ट खाते से कीवर्ड की संख्या कंसोल में प्रदर्शित की जाएगी:

 [1] "1855 words loaded" 

लेख के अंत में, future और promises गुच्छा का एक और अधिक उदाहरण दिया जाएगा।

डिफ़ॉल्ट रूप से, future पैकेज ही प्रत्येक समानांतर चलने वाले सत्र के लिए पूरे कार्यक्षेत्र को निर्यात करता है, लेकिन आप स्वयं ग्लोबल्स तर्क का उपयोग करके निर्यात के लिए वस्तुओं की एक सूची निर्दिष्ट कर सकते हैं।

पैकेजों को future से जोड़ने के लिए future एक वेक्टर पास करना चाहिए जिसमें उनके नाम पैकेज तर्क के लिए हों।

अब हमारे कार्य पर वापस, समानांतर मोड में निम्नलिखित कोड उदाहरण 4 खातों से कीवर्ड की एक सूची लोड करेगा:

 library(future) library(tictoc) #   plan("multisession", workers = 4) tic() #   futs <- lapply(logins, #      function(i) #        #   future({ yadirGetKeyWords(Login = i) %>% mutate(login = i) }, packages = c("ryandexdirect", "dplyr"))) completed <- sapply(futs, resolved) #    kw <- lapply(futs, value) #    toc() #    #     result.future <- dplyr::bind_rows(kw) 

लीड समय: 14.83 sec elapsed

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

lapply काम करने का परिणाम future लॉन्च की गई सूची है। आप sapply(futs, resolved) कमांड का उपयोग करके प्रत्येक की स्थिति की जांच कर सकते हैं, जो एक तार्किक वेक्टर लौटाएगा जहां TRUE का अर्थ होगा कि future पूरा हो गया है, और FALSE कि future वर्तमान में प्रगति पर है।

प्रत्येक future से परिणाम प्राप्त करने के लिए, उनका काम पूरा होने के बाद, हम lapply(futs, value) कमांड का उपयोग करते हैं।

: result.future <- dplyr::bind_rows(kw) .

future

, (
future ), .

future.apply

future.apply future , .

 library(future.apply) library(tictoc) #    plan("multisession", workers = 4) tic() #   kw.future.apply <- future_sapply(logins, #    ,   function(x) { #     yadirGetKeyWords(Login = x) %>% mutate(login = x) }, simplify = FALSE, #    #   future.packages = c("ryandexdirect", "dplyr"), future.globals = TRUE ) toc() #    

: 17.28 sec elapsed

13 , future.apply future , .

4 : plan("multisession", workers = 4) .

future_sapply logins . यानी , , sapply , .

future_sapply future.packages . future.globals . , .

furrr

future . purrr , furrr .

 library(furrr) library(tictoc) #   cl <- parallel::makeCluster(4) plan(cluster, workers = cl) tic() #   furrr.kw <- future_map(logins, ~ #   function(.x) yadirGetKeyWords(Login = .x) %>% mutate(login = .x), .options = future_options(packages = c("ryandexdirect", "dplyr"), globals = c())) toc() #    #      result.furrr <-dplyr::bind_rows(furrr.kw) 

: 15.45 sec elapsed

furrr purrr . purrr , .

.options . .options future_options , .

14 packages globals :

 .options = future_options(packages = c("ryandexdirect", "dplyr"), globals = c()) 

rbenchmark .

, future promises . .

, 20 4 () .

= (T[1] * 20) + (T[2] * 20) + (T[N] * 20)

 library(furrr) library(parallel) library(dplyr) library(future) library(ryandexdirect) library(tictoc) library(rbenchmark) #   logins <- c("login1", "login2", "login3", "login4") #        #        par par.furrr <- function(logins) { cl <- parallel::makeCluster(4) plan(cluster, workers = cl) furrr.kw <- future_map(logins, ~ yadirGetKeyWords(Login = .x) %>% mutate(login = .x), .options = future_options(packages = c("ryandexdirect", "dplyr"), globals = c())) result.furrr <-dplyr::bind_rows(furrr.kw) } par.future <- function(logins) { plan("multisession", workers = 4) futs <- lapply(logins, function(i) future({ yadirGetKeyWords(Login = i) %>% mutate(login = i) }, packages = c("ryandexdirect", "dplyr"))) completed <- sapply(futs, resolved) kw <- lapply(futs, value) result.future <- dplyr::bind_rows(kw) } par.future.apply <- function(logins) { plan("multisession", workers = 4) kw.future.apply <- future_sapply(logins, function(x) { yadirGetKeyWords(Login = x) %>% mutate(login = x) }, simplify = FALSE, future.packages = c("ryandexdirect", "dplyr"), future.globals = TRUE ) result.future.apply <- dplyr::bind_rows(kw.future.apply) } par.parallel <- function(logins) { cl <- parallel::makeCluster(4) clusterExport(cl = cl, varlist = "logins") clusterEvalQ(cl = cl, { library(ryandexdirect) library(dplyr) } ) parallel.kw <- parSapplyLB(cl = cl, X = logins, FUN = function(x) { yadirGetKeyWords(Login = x) %>% mutate(login = x) }, simplify = F) stopCluster(cl) result.parallel <- dplyr::bind_rows(parallel.kw) } #          seq seq.apply <- function(logins) { kw.sapply <- sapply( logins, function(x) { yadirGetKeyWords(Login = x) %>% mutate(login = x) }, simplify = FALSE ) result.sapply <- do.call("rbind", kw.sapply) } seq.purrr <- function(logins) { kw.purrr <- map_df( logins, ~ { yadirGetKeyWords(Login = .x) %>% mutate(login = .x) } ) result.purrr <- do.call("rbind", kw.purrr) } #       rbenchmark #   future + promises #  ,       #          plan(list(tweak(multisession, workers = 2), tweak(multisession, workers = 4))) tic() speed.test <- future({ #          within(benchmark(furrr = par.furrr(logins), future = par.future(logins), future.apply = par.future.apply(logins), parallel = par.parallel(logins), apply = seq.apply(logins), purrr = seq.purrr(logins), replications = c(20), columns = c('test', 'replications', 'elapsed'), order = c('elapsed', 'test')), { average = round(elapsed/replications, 2) }) }, packages = c("dplyr", "ryandexdirect", "rbenchmark", "parallel", "purrr", "future", "promises", "furrr", "future.apply"), globals = c("logins", "par.furrr", "par.future", "par.future.apply", "par.parallel", "seq.apply", "seq.purrr")) %...>% print() %...T>% toc() message("My Session is not blocked") 

3370 , .. .

. , future , promises , .

, . "My Session is not blocked", , , .. .

promises :

• %...>% — %>% , . यानी , resolved , future , value . , print .
• %...T>% — %T>% , , . , , , .. .. print , , .
• %...T!% — .

15 plan tweak ( plan(list(tweak(multisession, workers = 2), tweak(multisession, workers = 4))) ), , 2 , future 4 .

:

 My Session is not blocked test replications elapsed average 4 parallel 20 393.02 19.65 1 furrr 20 402.09 20.10 2 future 20 431.19 21.56 3 future.apply 20 432.29 21.61 5 apply 20 847.77 42.39 6 purrr 20 864.19 43.21 3370.55 sec elapsed 

, parallel , . furrr , future future.apply .

1 , , . , API . .

, 4 , .

निष्कर्ष

R, API.

, API . " R , 1" .

:

• doSNOW / doParallel + foreach
• future + promises
• future.apply / furrr
• parallel

, , .

, R .