Yandex.Direct API उदाहरण (भाग 1) का उपयोग करके समानांतर कंप्यूटिंग का उपयोग करते हुए आर-भाषा एपीआई के साथ काम को गति कैसे दें

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

सबसे अधिक संभावना है कि यह आपको लंबे समय तक परेशान नहीं करेगा, और आप इस प्रश्न को पूछने की संभावना नहीं है। लेकिन उदाहरण के लिए, यदि आपको एपीआई से बड़ी संख्या में विज्ञापन खातों से डेटा एकत्र करने के कार्य का सामना करना पड़ता है, उदाहरण के लिए Yandex.Direct, तो आप महत्वपूर्ण रूप से, कम से कम दो से तीन बार, मल्टीथ्रेडिंग का उपयोग करके डेटा एकत्र करने में लगने वाले समय को कम कर सकते हैं।

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

सामग्री

• क्या है मल्टीथ्रेडिंग
• हम किन पैकेजों का उपयोग करेंगे
• कार्य
• Yandex.Direct, ryandexdirect पैकेज में प्राधिकरण
• लूप के लिए एकल-थ्रेडेड अनुक्रमिक समाधान
• आर में मल्टीथ्रेडिंग समाधान
  
  • DoSNOW पैकेज और मल्टीथ्रेडेड विशेषताएं
  • DoParallel पैकेज
• तीन दृष्टिकोणों की समीक्षा के बीच स्पीड टेस्ट, रिंचमार्क पैकेज
• निष्कर्ष

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

क्या है मल्टीथ्रेडिंग

एक-सूत्रण (अनुक्रमिक गणना) - एक गणना मोड जिसमें सभी कार्यों (कार्यों) को क्रमिक रूप से किया जाता है, इस मामले में सभी दिए गए कार्यों की कुल अवधि सभी कार्यों की अवधि के योग के बराबर होगी।

मल्टीथ्रेडिंग (समानांतर कंप्यूटिंग) - एक कंप्यूटिंग मोड जिसमें निर्दिष्ट क्रियाएं (कार्य) समानांतर में किए जाते हैं, अर्थात्। एक ही समय में, जबकि सभी परिचालनों का कुल निष्पादन समय सभी प्रचालनों की अवधि के योग के बराबर नहीं होगा।

धारणा को सरल बनाने के लिए, आइए निम्न तालिका देखें:

दी गई तालिका की पहली पंक्ति सशर्त समय इकाइयाँ हैं, इस मामले में यह हमारे लिए सेकंड, मिनट या किसी अन्य समय अवधि के लिए महत्वपूर्ण नहीं है।

इस उदाहरण में, हमें 4 ऑपरेशन करने की आवश्यकता है, इस मामले में प्रत्येक ऑपरेशन की एक अलग गणना अवधि होती है, एकल-थ्रेडेड मोड में, सभी 4 ऑपरेशन एक के बाद एक क्रमिक रूप से किए जाएंगे, इसलिए उनके निष्पादन का कुल समय t1 + t2 + t3 + t4, 3 + 1 होगा + ५ + ४ = १३।

बहु-थ्रेडेड मोड में, सभी 4 कार्य समानांतर में किए जाएंगे, अर्थात अगला कार्य शुरू करने के लिए, पिछले एक के पूरा होने तक इंतजार करने की कोई आवश्यकता नहीं है, इसलिए यदि हम अपना काम 4 थ्रेड्स में शुरू करते हैं, तो कुल गणना का समय सबसे बड़े कार्य के गणना समय के बराबर होगा, हमारे मामले में यह कार्य t3 है, हमारे उदाहरण में गणना की अवधि 5 है अस्थायी इकाइयाँ, और क्रमशः इस मामले में सभी 4 परिचालनों का निष्पादन समय 5 अस्थायी इकाइयों के बराबर होगा।

हम किन पैकेजों का उपयोग करेंगे

मल्टीथ्रेडेड मोड में गणना के लिए, हम doSNOW , doSNOW और doParallel उपयोग करेंगे।

foreach पैकेज आपको foreach निर्माण का उपयोग करने की अनुमति देता है, जो अनिवार्य रूप से लूप के लिए बढ़ाया जाता है।

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

लेख के अंत में, rbenchmark पैकेज का उपयोग करते rbenchmark हम नीचे वर्णित सभी तरीकों का उपयोग करके Yandex.Direct API से डेटा संग्रह संचालन की अवधि को मापेंगे और तुलना करेंगे।

Yandex.Direct API के साथ काम करने के लिए, हम ryandexdirect पैकेज का उपयोग करेंगे, इस लेख में हम इसे एक उदाहरण के रूप में उपयोग करेंगे, इसकी क्षमताओं और कार्यों के बारे में अधिक विवरण आधिकारिक दस्तावेज में पाए जा सकते हैं।

सभी आवश्यक पैकेजों को स्थापित करने के लिए कोड:

 install.packages("foreach") install.packages("doSNOW") install.packages("doParallel") install.packages("rbenchmark") install.packages("ryandexdirect") 

कार्य

आपको एक कोड लिखना होगा जो किसी भी संख्या के Yandex.Direct विज्ञापन खातों से कीवर्ड की सूची का अनुरोध करेगा। परिणाम को एक दिनांक फ़्रेम में एकत्र किया जाना चाहिए, जिसमें विज्ञापन खाते के लॉगिन के साथ एक अतिरिक्त फ़ील्ड होगा जिसमें कीवर्ड होता है।

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

यैंडेक्स में प्राधिकरण। अप्रत्यक्ष

Yandex.Direct विज्ञापन प्लेटफॉर्म के एपीआई के साथ काम करने के लिए, शुरू में प्रत्येक खाते के तहत प्राधिकरण से गुजरना आवश्यक है, जहां से हम कीवर्ड की सूची का अनुरोध करने की योजना बनाते हैं।

इस लेख में दिए गए सभी कोड नियमित Yandex.Direct विज्ञापन खातों के साथ काम करने का एक उदाहरण दर्शाते हैं, यदि आप एक एजेंट खाते के तहत काम कर रहे हैं, तो आपको AgencyAccount तर्क का उपयोग करने और एजेंट खाता लॉगिन इसे पास करने की आवश्यकता है। आप यैंडेक्स के एजेंट खातों के साथ काम करने के बारे में अधिक जानकारी प्राप्त कर सकते हैं। अप्रत्यक्ष रूप से यहां रैंडेक्सएक्सैड पैकेज का उपयोग कर।

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

 ryandexdirect::yadirAuth(Login = "    ") 

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

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

लूप के लिए एकल-थ्रेडेड अनुक्रमिक समाधान

लूप के for एक से अधिक खातों से डेटा एकत्र करने का सबसे आसान तरीका है। सरल लेकिन सबसे प्रभावी नहीं, क्योंकि आर भाषा में विकास के सिद्धांतों में से एक कोड में छोरों के उपयोग से बचने के लिए है।

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

 library(ryandexdirect) #   logins <- c("login_1", "login_2", "login_3", "login_4") #    res1 <- data.frame() #    for (login in logins) { temp <- yadirGetKeyWords(Login = login) temp$login <- login res1 <- rbind(res1, temp) } 

सिस्टम.टाइम फ़ंक्शन का उपयोग करके रनटाइम को मापना निम्न परिणाम दिखाता है:

काम का समय:
उपयोगकर्ता: 178.83
सिस्टम: 0.63
पारित: 320.39

4 खातों के लिए कीवर्ड के संग्रह में 320 सेकंड लगे, और ऑपरेशन के दौरान yadirGetKeyWords फ़ंक्शन प्रदर्शित होने वाले सूचना संदेशों से, सबसे बड़ा खाता देखा जाता है, जिसमें से 5970 कीवर्ड प्राप्त हुए, 142 सेकंड संसाधित किए गए थे।

आर में मल्टीथ्रेडिंग समाधान

मैंने पहले ही ऊपर लिखा है कि मल्टीथ्रेडिंग के लिए हम doSNOW और doParallel उपयोग करेंगे।

मैं इस तथ्य पर ध्यान आकर्षित करना चाहता हूं कि लगभग किसी भी एपीआई की अपनी सीमाएं हैं, और Yandex.Direct API कोई अपवाद नहीं है। वास्तव में, Yandex.Direct API के साथ काम करने के लिए मदद कहती है:

एक उपयोगकर्ता की ओर से पांच से अधिक एक साथ एपीआई अनुरोधों की अनुमति नहीं है।

इसलिए, इस तथ्य के बावजूद कि इस मामले में हम 4 धाराओं के निर्माण के साथ एक उदाहरण पर विचार करेंगे, यांडेक्स के साथ काम करने में। अप्रत्यक्ष रूप से आप 5 स्ट्रीम बना सकते हैं, भले ही आप एक ही उपयोगकर्ता के तहत सभी अनुरोध भेज दें। लेकिन अपने प्रोसेसर के 1 कोर प्रति 1 थ्रेड का उपयोग करना सबसे तर्कसंगत है, आप parallel::detectCores(logical = FALSE) कमांड का उपयोग करके भौतिक प्रोसेसर कोर की संख्या निर्धारित कर सकते हैं, parallel::detectCores(logical = FALSE) हुए तार्किक कोर की संख्या का पता लगाया जा सकता है parallel::detectCores(logical = TRUE) । विकिपीडिया पर इस तरह के भौतिक और तार्किक मूल के बारे में अधिक विस्तृत समझ संभव है।

अनुरोधों की संख्या की सीमा के अलावा, Yandex.Direct API तक पहुँचने के लिए अंकों की संख्या पर एक दैनिक सीमा है, यह सभी खातों के लिए अलग-अलग हो सकता है, प्रत्येक अनुरोध ऑपरेशन किए जाने के आधार पर अलग-अलग अंकों की खपत भी करता है। उदाहरण के लिए, कीवर्ड की एक सूची को क्वेरी करने के लिए आपको एक पूर्ण क्वेरी के लिए 15 अंक और प्रत्येक 2000 शब्दों के लिए 3 अंक काटे जाएंगे, आप यह पता लगा सकते हैं कि आधिकारिक प्रमाण पत्र में अंक कैसे लिखे गए हैं। आप अंक और उपलब्ध अंकों की संख्या के बारे में जानकारी, साथ ही साथ सूचना संदेशों में उनकी दैनिक सीमा yadirGetKeyWords फ़ंक्शन द्वारा कंसोल पर वापस देख yadirGetKeyWords हैं।

 Number of API points spent when executing the request: 60 Available balance of daily limit API points: 993530 Daily limit of API points:996000 

आइए doSNOW और doParallel के साथ doSNOW करें।

DoSNOW पैकेज और मल्टीथ्रेडेड विशेषताएं

हम गणना के बहु-थ्रेडेड मोड के लिए एक ही ऑपरेशन को फिर से लिखते हैं, इस मामले में 4 धागे बनाते हैं, और लूप के बजाय, हम foreach कंस्ट्रक्शन का उपयोग करते हैं।

 library(foreach) library(doSNOW) #   logins <- c("login_1", "login_2", "login_3", "login_4") cl <- makeCluster(4) registerDoSNOW(cl) res2 <- foreach(login = logins, #  -  .combine = 'rbind', #        .packages = "ryandexdirect", #   .inorder=F ) %dopar% {cbind(yadirGetKeyWords(Login = login), login) } stopCluster(cl) 

इस स्थिति में, system.time फ़ंक्शन का उपयोग करके रनटाइम को मापना निम्न परिणाम दिखाता है:

काम का समय:
उपयोगकर्ता: 0.17
सिस्टम: 0.08
पारित: 151.47

वही परिणाम, अर्थात्। हमें 151 सेकंड में 4 Yandex.Direct खातों से कीवर्ड का संग्रह प्राप्त हुआ, अर्थात 2 बार तेजी से। इसके अलावा, मैंने अभी पिछले उदाहरण में लिखा था कि सबसे बड़े खाते (142 सेकंड) से कीवर्ड की सूची लोड करने में कितना समय लगा, यानी। इस उदाहरण में, कुल समय सबसे बड़े खाते के प्रसंस्करण समय के लगभग समान है। तथ्य यह है कि foreach फ़ंक्शन की मदद से, हमने एक साथ 4 धाराओं में डेटा एकत्र करने की प्रक्रिया शुरू की, अर्थात। एक ही समय में सभी 4 खातों से क्रमशः एकत्रित डेटा, कुल समय सबसे बड़े खाते के प्रसंस्करण समय के बराबर है।

मैं कोड 2 के बारे में थोड़ा स्पष्टीकरण दूंगा, makeCluster फ़ंक्शन थ्रेड्स की संख्या के लिए ज़िम्मेदार है, इस मामले में हमने 4 प्रोसेसर कोर का एक क्लस्टर बनाया है, लेकिन जैसा कि मैंने पहले लिखा था कि Yandex.Direct API के साथ काम करते हुए, आप 5 थ्रेड बना सकते हैं, चाहे कितने भी अकाउंट हों। आपको 5-15-100 या उससे अधिक की प्रक्रिया करने की आवश्यकता है, आप एक ही समय में एपीआई को 5 अनुरोध भेज सकते हैं।

अगला, registerDoSNOW फ़ंक्शन निर्मित क्लस्टर को प्रारंभ करता है।

उसके बाद हम foreach निर्माण का उपयोग करते हैं, जैसा कि मैंने पहले कहा था, यह निर्माण लूप के लिए बेहतर है। आप काउंटर को पहले तर्क के रूप में सेट करते हैं, उदाहरण के लिए, जिसे मैंने लॉगिन कहा है और यह प्रत्येक पुनरावृत्ति पर लॉगिन वेक्टर के तत्वों पर पुनरावृति करेगा, हम लूप के for एक ही परिणाम प्राप्त करेंगे यदि हमने for ( login in logins) लिखा है।

इसके बाद, आपको .com में उस फ़ंक्शन को इंगित करने की आवश्यकता है जिसके साथ आप प्रत्येक पुनरावृत्ति पर प्राप्त परिणामों को संयोजित करेंगे, सबसे महत्वपूर्ण विकल्प हैं:

• rbind - एक दूसरे के तहत पंक्ति द्वारा परिणामी तालिकाओं पंक्ति में शामिल हों;
• cbind - कॉलम में परिणामी तालिकाओं में शामिल हों;
• "+" - प्रत्येक पुनरावृत्ति पर प्राप्त परिणाम को संक्षेप में प्रस्तुत करें।

आप किसी अन्य फ़ंक्शन का उपयोग भी कर सकते हैं, यहां तक ​​कि स्व-लिखित भी।

तर्क .inorder = F आपको परिणाम को संयोजित करने के लिए फ़ंक्शन को थोड़ा और गति देने की अनुमति देता है यदि आप परिणामों को संयोजित करने के लिए क्या ध्यान रखते हैं, इस मामले में यह क्रम हमारे लिए महत्वपूर्ण नहीं है।

इसके बाद %dopar% ऑपरेटर आता है, जो समानांतर कंप्यूटिंग मोड में लूप शुरू करता है, यदि आप %do% ऑपरेटर का उपयोग करते हैं, तो पुनरावृत्तियों को क्रमिक रूप से निष्पादित किया जाएगा, साथ ही लूप के for सामान्य का उपयोग करते समय।

स्टॉप क्लस्टर फ़ंक्शन क्लस्टर को रोकता है।

मल्टीथ्रेडिंग, या बल्कि मल्टीथ्रेडेड मोड में foreach निर्माण, कुछ विशेषताएं हैं, वास्तव में, इस मामले में, हम प्रत्येक समानांतर प्रक्रिया को एक नए, स्वच्छ आर सत्र में शुरू करते हैं। इसलिए, जेनेरिक फ़ंक्शंस और ऑब्जेक्ट्स का उपयोग करने के लिए जो कि foreach कंस्ट्रक्शन के बाहर परिभाषित किए गए थे, आपको .export तर्क का उपयोग करके उन्हें निर्यात करने की आवश्यकता है। यह तर्क एक पाठ वेक्टर लेता है जिसमें उन वस्तुओं के नाम होते हैं जिनका उपयोग आप foreach अंदर करेंगे।

इसके अलावा, समानांतर मोड में, foreach , पहले से कनेक्ट किए गए पैकेजों को डिफ़ॉल्ट रूप से नहीं देखता है, इसलिए उन्हें .eachages के तर्क का उपयोग करते हुए इनचेक के अंदर पास करने की आवश्यकता होगी। उदाहरण के लिए .packages = c("ryandexdirect", "dplyr", "lubridate") में उनके नामों को सूचीबद्ध करके संकुल को स्थानांतरित करना भी आवश्यक है। उपरोक्त कोड उदाहरण 2 में , हम बस इस तरह से फ़ॉरेस्ट के प्रत्येक पुनरावृत्ति पर रैंडेक्सएक्सैड पैकेज को लोड करते हैं।

DoParallel पैकेज

जैसा कि मैंने ऊपर लिखा है, doSNOW और doParallel जुड़वाँ हैं, इसलिए उनका सिंटेक्स एक ही है।

 library(foreach) library(doParallel) logins <- c("login_1", "login_2", "login_3", "login_4") cl <- makeCluster(4) registerDoParallel(cl) res3 <- data.frame() res3 <- foreach(login=logins, .combine= 'rbind', .inorder=F) %dopar% {cbind(ryandexdirect::yadirGetKeyWords(Login = login), login) stopCluster(cl) 

काम का समय:
उपयोगकर्ता: 0.25
सिस्टम: 0.01
पारित: 173.28

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

तीन दृष्टिकोणों के बीच गति परीक्षण की समीक्षा की

अब rbenchmark पैकेज का उपयोग करके स्पीड टेस्ट rbenchmark ।

जैसा कि आप देख सकते हैं, यहां तक ​​कि 4 खातों के परीक्षण पर, doSNOW और doParallel को लूप के लिए अनुक्रमिक की तुलना में 2 गुना तेजी से कीवर्ड द्वारा डेटा प्राप्त हुआ, यदि आप 5 कोर का क्लस्टर बनाते हैं और 50 या 100 खातों की प्रक्रिया करते हैं, तो अंतर और भी महत्वपूर्ण होगा।

 #   library(ryandexdirect) library(foreach) library(doParallel) library(doSNOW) library(rbenchmark) #         for for_fun <- function(logins) { res1 <- data.frame() for (login in logins) { temp <- yadirGetKeyWords(Login = login) res1 <- rbind(res1, temp) } return(res1) } #         foreach   doSNOW dosnow_fun <- function(logins) { cl <- makeCluster(4) registerDoSNOW(cl) res2 <- data.frame() system.time({ res2 <- foreach(login=logins, .combine= 'rbind') %dopar% {temp <- ryandexdirect::yadirGetKeyWords(Login = login } }) stopCluster(cl) return(res2) } #         foreach   doParallel dopar_fun <- function(logins) { cl <- makeCluster(4) registerDoParallel(cl) res2 <- data.frame() system.time({ res2 <- foreach(login=logins, .combine= 'rbind') %dopar% {temp <- ryandexdirect::yadirGetKeyWords(Login = login) } }) stopCluster(cl) return(res2) } #          within(benchmark(for_cycle = for_fun(logins = logins), dosnow = dosnow_fun(logins = logins), doparallel = dopar_fun(logins = logins), replications = c(20), columns=c('test', 'replications', 'elapsed'), order=c('elapsed', 'test')), { average = elapsed/replications }) 

अंत में, मैं उपरोक्त कोड 5 का स्पष्टीकरण दूंगा, जिसके साथ हमने काम की गति का परीक्षण किया।

प्रारंभ में, हमने तीन कार्य बनाए:

for_fun - एक फ़ंक्शन जो कई खातों से कीवर्ड का अनुरोध करता है, क्रमिक रूप से उन्हें एक नियमित चक्र के माध्यम से क्रमबद्ध करता है।

dosnow_fun - doSNOW पैकेज का उपयोग करके, मल्टीथ्रेडेड मोड में कीवर्ड की एक सूची का अनुरोध करने वाला फ़ंक्शन।

dopar_fun - doParallel package का उपयोग करते हुए, मल्टीथ्रेडेड मोड में कीवर्ड की सूची का अनुरोध करने वाला फ़ंक्शन।

अगला, भीतर निर्माण के भीतर, हम benchmark फ़ंक्शन को rbenchmark पैकेज से चलाते हैं, परीक्षणों के नाम निर्दिष्ट करते हैं (for_cycle, dosnow, doparallel), और प्रत्येक फ़ंक्शन को हम क्रमशः निर्दिष्ट करते हैं: for_fun(logins = logins) ; dosnow_fun(logins = logins) ; dopar_fun(logins = logins) ।

प्रतिकृति तर्क परीक्षण की संख्या के लिए जिम्मेदार है, अर्थात्। हम प्रत्येक फ़ंक्शन को कितनी बार चलाएंगे।

कॉलम तर्क आपको यह निर्दिष्ट करने की अनुमति देता है कि आप कौन से कॉलम प्राप्त करना चाहते हैं, हमारे मामले में 'परीक्षण', 'प्रतिकृति', 'बीता' का अर्थ है कॉलम वापस करना: परीक्षण का नाम, परीक्षणों की संख्या, सभी परीक्षणों का कुल निष्पादन समय।

आप गणना किए गए कॉलम भी जोड़ सकते हैं, ( { average = elapsed/replications } ), अर्थात आउटपुट एक औसत कॉलम होगा जो कुल समय को परीक्षणों की संख्या से विभाजित करेगा, इसलिए हम प्रत्येक फ़ंक्शन के औसत निष्पादन समय की गणना करते हैं।

आदेश परीक्षा परिणामों को छांटने के लिए जिम्मेदार है।

निष्कर्ष

इस लेख में, सिद्धांत रूप में, एपीआई के साथ काम में तेजी लाने के लिए एक काफी सार्वभौमिक विधि का वर्णन किया गया है, लेकिन प्रत्येक एपीआई की अपनी सीमाएं हैं, इसलिए, विशेष रूप से इस रूप में, इतने सारे थ्रेड्स के साथ, उपरोक्त उदाहरण Yandex.Direct API के साथ काम करने के लिए उपयुक्त है, एपीआई के साथ इसका उपयोग करने के लिए। अन्य सेवाओं में, एक साथ भेजे गए अनुरोधों की संख्या के लिए एपीआई में सीमाओं के बारे में प्रलेखन को पढ़ना आवश्यक है, अन्यथा आपको Too Many Requests त्रुटि मिल सकती है।

इस लेख की निरंतरता यहाँ उपलब्ध है ।