R, भाग 2 में वेब स्क्रैपिंग। समानांतर कंप्यूटिंग के साथ प्रक्रिया को तेज करना और Rcrawler पैकेज का उपयोग करना

पिछले लेख में , स्क्रैपिंग पार्सिंग का उपयोग करते हुए, मैंने IMDB और Kinopoisk साइटों से मूवी रेटिंग एकत्र की और उनकी तुलना की। गितुब पर रिपोजिटरी।

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

जब मैंने 1000 पृष्ठों को क्रॉल करने के लिए scraping_imdb.R का उपयोग करने का निर्णय लिया

कोड अनुकूलन। read_html फ़ंक्शन का एकल उपयोग

इस लेख में, Labyrinth किताबों की दुकान के पृष्ठों के 100 लिंक का उपयोग कोड के संचालन और गति की जांच करने के लिए किया जाएगा।

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

भूलभुलैया में पेज स्क्रैपिंग की विशेषताएं

इस भाग में, मैं पिछले लेख में बताए गए डेटा को प्राप्त करने और साफ़ करने की प्रक्रिया को नहीं छूऊँगा। मैं केवल उन क्षणों का उल्लेख करता हूं, जिन्हें मैंने पहली बार बुकस्टोर की स्क्रैपबुकिंग के लिए कोड लिखते समय सामना किया था।

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

इसलिए, मैं एक साधारण बस्ट के साथ https://www.labirint.ru/books/ **** लिंक पर जाने से बेहतर कुछ भी नहीं कर सकता था। सच कहूं, तो विधि सबसे अच्छी नहीं है (यदि केवल इसलिए कि अधिकांश "प्राचीन" पुस्तकों में नाम के अलावा कोई जानकारी नहीं है और इसलिए व्यावहारिक रूप से बेकार हैं), इसलिए यदि कोई और अधिक सुरुचिपूर्ण समाधान प्रदान करता है, तो मुझे खुशी होगी। लेकिन मुझे पता चला कि भूलभुलैया की वेबसाइट पर गर्वित पहले नंबर के तहत "हाउ टू मेक मॉनशीन" नामक एक पुस्तक है। काश, ज्ञान के इस भंडार को खरीदना पहले से ही असंभव होता।

गणना के दौरान सभी पते दो प्रकारों में विभाजित किए जा सकते हैं:

• जो पृष्ठ मौजूद हैं
• जो पृष्ठ मौजूद नहीं हैं

मौजूदा पृष्ठ, बदले में, दो भागों में विभाजित किए जा सकते हैं:

• वे पृष्ठ जिनमें सभी आवश्यक जानकारी हैं
• वे पृष्ठ जिनमें सभी आवश्यक जानकारी नहीं हैं

मैं एक डेटा टेबल के साथ सात कॉलम के साथ समाप्त होता हूं:

1. आईएसबीएन - आईएसबीएन बुक नंबर
2. मूल्य - पुस्तक मूल्य
3. NAME - पुस्तक का शीर्षक
4. AUTHOR - पुस्तक के लेखक
5. प्रकाशन - प्रकाशन गृह
6. वर्ष - प्रकाशन का वर्ष
7. पृष्ठ - पृष्ठों की संख्या

पूरी जानकारी वाले पृष्ठों के साथ सब कुछ स्पष्ट है, उन्हें फिल्म साइटों के लिए कोड की तुलना में किसी भी बदलाव की आवश्यकता नहीं है।

उन पृष्ठों के लिए, जिन पर कुछ डेटा उपलब्ध नहीं है, यह उनके साथ इतना सरल नहीं है। पृष्ठ पर एक खोज केवल उन मानों को लौटाएगी जो इसे पाता है और आउटपुट लंबाई उन तत्वों की संख्या से घट जाएगी जो इसे नहीं मिलेंगे। इससे पूरा ढांचा टूट जाएगा। इससे बचने के लिए, यदि प्रत्येक तर्क में एक और ... निर्माण जोड़ा गया था, जो html_nodes फ़ंक्शन का उपयोग करने के बाद प्राप्त वेक्टर की लंबाई का मूल्यांकन करता है और यदि यह शून्य के बराबर है, तो यह पूर्वाग्रह मानों से बचने के लिए NA लौटाता है।

  PUBLISHER <- unlist(lapply(list_html, function(n){ publishing <- if(n != "NA") { publishing_html <- html_nodes(n, ".publisher a") publishing <- if(length(publishing_html) == 0){ NA } else { publishing <- html_text(publishing_html) } } else { NA } })) 

लेकिन जैसा कि आप यहाँ दो ifs के रूप में और दो के रूप में ज्यादा के रूप में नोटिस कर सकते हैं। केवल "आंतरिक" if..esle ऊपर वर्णित समस्या के समाधान के लिए प्रासंगिक है। बाहरी समस्या गैर-मौजूद पृष्ठों के साथ हल करती है।

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

possibly पैकेज का possibly फ़ंक्शन हमें इसके साथ मदद करेगा। possibly का अर्थ ( possibly quietly और safely इसके अलावा) साइड इफेक्ट्स (उदाहरण के लिए, त्रुटियों) के मुद्रित आउटपुट को बदलने के लिए है जो हमें सूट करता है। possibly एक possibly(.f, otherwise) संरचना है possibly(.f, otherwise) और यदि कोड में कोई त्रुटि होती है, तो इसके निष्पादन को रोकने के बजाय, यह डिफ़ॉल्ट मान (अन्यथा) का उपयोग करता है। हमारे मामले में, यह इस तरह दिखता है:

 book_html <- possibly(read_html, "NA")(n) 

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

और अब प्रकाशक का नाम प्राप्त करने के लिए कोड पर वापस जाएं। बाह्य यदि ... आंतरिक के समान उद्देश्यों के लिए और भी आवश्यक है, लेकिन गैर-मौजूद पृष्ठों के संबंध में। यदि वैरिएबल book_html "एनए" के बराबर है, तो "स्क्रैप किए गए" मानों में से प्रत्येक NA बराबर भी है (यहां आप पहले से ही प्रतीकात्मक दोष के बजाय "वास्तविक" NA उपयोग कर सकते हैं)। तो अंत में, हमें निम्नलिखित फॉर्म की एक तालिका मिलती है:

अब वापस स्क्रैपिंग प्रक्रिया के त्वरण के साथ।

R. स्पीड तुलना और read_html में समानांतर कंप्यूटिंग read_html फ़ंक्शन का उपयोग करते read_html

डिफ़ॉल्ट रूप से, आर में सभी गणना एक ही प्रोसेसर कोर पर की जाती है। और जब यह दुर्भाग्यपूर्ण कोर पसीना आ रहा है, तो हमारे लिए हजारों पृष्ठों के डेटा को "स्क्रैपिंग" कर रहा है, हमारे बाकी साथी कुछ अन्य कार्य करके "कूलिंग" कर रहे हैं। समानांतर कंप्यूटिंग का उपयोग करने से डेटा को संसाधित / प्राप्त करने के लिए सभी प्रोसेसर कोर को आकर्षित करने में मदद मिलती है, जो प्रक्रिया को गति देती है।

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

मैं आपको उस त्रुटि के बारे में बताऊंगा जो मैंने समानांतर कंप्यूटिंग का उपयोग करते समय की थी। प्रारंभ में, मेरी योजना यह थी: समानांतर कंप्यूटिंग का उपयोग करते हुए, मुझे 100 "रीड" read_html पृष्ठों की एक सूची read_html है, और फिर सामान्य मोड में मुझे बस वह डेटा मिलता है जिसकी मुझे आवश्यकता होती है। पहले तो सब कुछ ठीक रहा: मुझे एक सूची मिली, सामान्य मोड आर की तुलना में उस पर बहुत कम समय बिताना। लेकिन केवल जब मैंने इस सूची के साथ बातचीत करने की कोशिश की, मुझे एक त्रुटि मिली:

 Error: external pointer is not valid 

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

समानांतर कंप्यूटिंग बनाने में खुद को ज्यादा समय और कोड की लाइनें नहीं लगती हैं। पहली चीज जो आपको चाहिए वह है पुस्तकालयों को डाउनलोड करना। जीथब रिपॉजिटरी इंगित करता है कि किन तरीकों के लिए पैकेज की आवश्यकता है। यहां मैं parallel पैकेज के parLapply फ़ंक्शन का उपयोग करके समानांतर कंप्यूटिंग parLapply । ऐसा करने के लिए, बस doParallel ( parallel इस मामले में अपने आप शुरू हो जाएगा)। यदि आप अचानक अपने प्रोसेसर की संख्या को नहीं जानते या भूल गए हैं, तो पता लगाएं कि उनमें से कितने detectCores मदद करेंगे detectCores

 # detectCores - ,     number_cl <- detectCores() 

अगला, R की समानांतर प्रतियाँ बनाएँ:

  # makePSOCKcluster -    R,    cluster <- makePSOCKcluster(number_cl) registerDoParallel(cluster) 

अब हम एक फंक्शन लिख रहे हैं जो उन सभी प्रक्रियाओं को करेगा जो हमें चाहिए। मैं ध्यान देता हूं कि कब से नए सत्र बनाए जाते हैं। आर पैकेट जिन्हें हमारे स्वयं के फ़ंक्शन में उपयोग किया जाता है, उन्हें फ़ंक्शन के शरीर में लिखा जाना चाहिए। Spider_parallel.R में, यह stringr पैकेज stringr दो बार चलाने का कारण बनता है: पहले पृष्ठ के पते प्राप्त करने के लिए, और फिर डेटा को साफ़ करने के लिए।

और फिर प्रक्रिया लगभग सामान्य रूप से lapply फ़ंक्शन का उपयोग करने से अलग नहीं है। parLapply हम पते की एक सूची प्रदान करते हैं, हमारा अपना कार्य और, एकमात्र जोड़, हमारे द्वारा बनाए गए समूहों के साथ एक चर।

 # parLapply -  lapply     big_list <- parLapply(cluster, list_url, scraping_parellel_func) #    stopCluster(cluster) 

यही सब है, अब यह खर्च किए गए समय की तुलना करने के लिए रहता है।

धारावाहिक और समानांतर गणना गति की तुलना

यह सबसे छोटा बिंदु होगा। समानांतर कंप्यूटिंग सामान्य से 5 गुना तेज थी:

समानांतर कंप्यूटिंग का उपयोग किए बिना स्क्रैपिंग गति

समानांतर कम्प्यूटिंग का उपयोग करके स्क्रैपिंग स्पीड

क्या कहना है? समानांतर कंप्यूटिंग कोड बनाने में कोई कठिनाई पैदा किए बिना आपका बहुत समय बचा सकती है। नाभिक की संख्या में वृद्धि के साथ, गति उनकी संख्या के अनुपात में लगभग बढ़ जाएगी। इसलिए, कुछ परिवर्तनों के साथ, हमने पहले कोड को 7 गुना तेज कर दिया (हर कदम पर read_html गणना read_html बंद कर दिया), और फिर समानांतर गणना का उपयोग करते हुए एक और 5। समानांतर कंप्यूटिंग और foreach पैकेज का उपयोग किए बिना, समानांतर कंप्यूटिंग के बिना स्पाइडर स्क्रिप्ट, गितुब पर रिपॉजिटरी में हैं।

Rcrawler पैकेज का एक छोटा सा अवलोकन। गति तुलना।

HTML पेजों को R में स्क्रैप करने के कई अन्य तरीके हैं, लेकिन मैं Rcrawler पैकेज पर ध्यान केंद्रित करूंगा । आर भाषा में अन्य उपकरणों से इसकी विशिष्ट विशेषता साइटों को क्रॉल करने की क्षमता है। आप Rcrawler पते पर एक ही नाम का Rcrawler फ़ंक्शन सेट कर सकते हैं और यह विधिपूर्वक, पेज द्वारा पृष्ठ, पूरी साइट को बायपास करेगा। Rcrawler को स्थापित करने के लिए Rcrawler के कई तर्क हैं (उदाहरण के लिए, आप कीवर्ड द्वारा खोज सकते हैं, साइट के सेक्टर (उपयोगी जब साइट में बड़ी संख्या में पृष्ठ होते हैं), खोज की गहराई, URL मापदंडों की अनदेखी जो नकली पृष्ठ बनाते हैं, और बहुत कुछ। फ़ंक्शंस को पहले से ही समानांतर गणनाओं के लिए रखा गया है, जो तर्कों no_cores (प्रोसेसर कोर की संख्या में शामिल) और no_conn (समानांतर अनुरोधों की संख्या) द्वारा निर्दिष्ट हैं।

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

 #   ContentScraper: # CssPatterns -    CSS    . # ExcludeCSSPat -    CSS ,    . # ,   CSS     CSS ,    . # ManyPerPattern -  FALSE,       , #  .  TRUE,     ,   . # PatternsName -      .   #   c  ,      t_func <- function(n){ library(Rcrawler) t <- ContentScraper(n, CssPatterns = c("#product-title", ".authors", ".buying-price-val-number", ".buying-pricenew-val-number", ".publisher", ".isbn", ".pages2"), ExcludeCSSPat = c(".prodtitle-availibility", ".js-open-block-page_count"), ManyPerPattern = FALSE, PatternsName = c("title", "author", "price1", "price2", "publisher", "isbn", "page")) return(t) } ", #   ContentScraper: # CssPatterns -    CSS    . # ExcludeCSSPat -    CSS ,    . # ,   CSS     CSS ,    . # ManyPerPattern -  FALSE,       , #  .  TRUE,     ,   . # PatternsName -      .   #   c  ,      t_func <- function(n){ library(Rcrawler) t <- ContentScraper(n, CssPatterns = c("#product-title", ".authors", ".buying-price-val-number", ".buying-pricenew-val-number", ".publisher", ".isbn", ".pages2"), ExcludeCSSPat = c(".prodtitle-availibility", ".js-open-block-page_count"), ManyPerPattern = FALSE, PatternsName = c("title", "author", "price1", "price2", "publisher", "isbn", "page")) return(t) } ", #   ContentScraper: # CssPatterns -    CSS    . # ExcludeCSSPat -    CSS ,    . # ,   CSS     CSS ,    . # ManyPerPattern -  FALSE,       , #  .  TRUE,     ,   . # PatternsName -      .   #   c  ,      t_func <- function(n){ library(Rcrawler) t <- ContentScraper(n, CssPatterns = c("#product-title", ".authors", ".buying-price-val-number", ".buying-pricenew-val-number", ".publisher", ".isbn", ".pages2"), ExcludeCSSPat = c(".prodtitle-availibility", ".js-open-block-page_count"), ManyPerPattern = FALSE, PatternsName = c("title", "author", "price1", "price2", "publisher", "isbn", "page")) return(t) } "), #   ContentScraper: # CssPatterns -    CSS    . # ExcludeCSSPat -    CSS ,    . # ,   CSS     CSS ,    . # ManyPerPattern -  FALSE,       , #  .  TRUE,     ,   . # PatternsName -      .   #   c  ,      t_func <- function(n){ library(Rcrawler) t <- ContentScraper(n, CssPatterns = c("#product-title", ".authors", ".buying-price-val-number", ".buying-pricenew-val-number", ".publisher", ".isbn", ".pages2"), ExcludeCSSPat = c(".prodtitle-availibility", ".js-open-block-page_count"), ManyPerPattern = FALSE, PatternsName = c("title", "author", "price1", "price2", "publisher", "isbn", "page")) return(t) } 

लेकिन सभी सकारात्मक गुणों के साथ, ContentScraper फ़ंक्शन में एक बहुत ही गंभीर माइनस है - काम की गति।

समानांतर कंप्यूटिंग के बिना Rcrawler ContentScraper ContentScraper Rcrawler

समानांतर कम्प्यूटिंग का उपयोग करते हुए क्रॉलर कंटेंटस्क्रैपर ContentScraper Rcrawler

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

मैं किसी भी टिप्पणी, सुझाव, शिकायत के लिए आभारी रहूंगा
जीथब रिपोजिटरी लिंक
मेरी मंडली प्रोफ़ाइल