दिलचस्प पोस्ट
पूरी तरह से एंड्रॉइड स्टूडियो की स्थापना रद्द करने के लिए कैसे? क्या आप जावास्क्रिप्ट में हर कथन के बाद अर्धविराम का उपयोग करने की अनुशंसा करते हैं? पायथन 3 के साथ पीपी कैसे स्थापित करें? मैं किसी सी # अनाम प्रकार को एक JSON स्ट्रिंग में कैसे सीरियल कर सकता हूं? मैं जावास्क्रिप्ट फ़ाइलों को रीफ्रेश करने के लिए ग्राहकों को कैसे मजबूर कर सकता हूं? डिबग मोड के लिए एंड्रॉइड स्टूडियो में एसएचए -1 फिंगरप्रिंट सर्टिफिकेट कैसे प्राप्त करें? एफ़टीपी / एसएफटीपी एक अमेज़ॅन एस 3 बाल्टी एक्सेस एंड्रॉइड 4.1: एप्लिकेशन के लिए नोटिफिकेशन की जांच कैसे निष्क्रिय कर दी जाती है? कमांड लाइन पैरामीटर पार्स करने के लिए जावा लाइब्रेरी? अजगर में अंतर () और प्रकार () के बीच अंतर डीबी के सभी तालिकाओं, पंक्तियों और स्तंभों में स्ट्रिंग खोजें मैं गणितीय ऑपरेटर कैसे यादृच्छिक रूप से चुन सकता हूं और इसके साथ आवर्ती गणित के सवाल पूछ सकता हूं? आगे का उपयोग करने के फायदे स्क्रीन अभिविन्यास परिवर्तनों पर राज्य को खोने से कस्टम दृश्यों को कैसे रोकें मैं नए PostgreSQL JSON डेटाटाइप के अंदर फ़ील्ड कैसे संशोधित करूं?

(क्यों) हमें कैश कॉल करने की आवश्यकता है या आरडीडी पर जारी रहना चाहिए

जब एक लचीला वितरित डेटासेट (आरडीडी) एक पाठ फ़ाइल या संग्रह (या किसी अन्य RDD) से बनाई गई है, तो क्या हमें "कैश" या "लगातार" कॉल करने के लिए स्पष्ट रूप से आरडीडी डेटा को स्मृति में संग्रहीत करने की आवश्यकता है? या क्या आरडीडी डाटा को डिस्ट्रीब्यूशन में वितरित तरीके से संग्रहीत किया जाता है?

val textFile = sc.textFile("/user/emp.txt") 

मेरी समझ के अनुसार, उपरोक्त कदम के बाद, textFile एक आरडीडी है और सभी / कुछ नोड की मेमोरी में उपलब्ध है I

यदि हां, तो हमें पाठ फ़ाइल आरडीडी पर "कैश" या "जारी" कॉल करने की आवश्यकता क्यों है?

वेब के समाधान से एकत्रित समाधान "(क्यों) हमें कैश कॉल करने की आवश्यकता है या आरडीडी पर जारी रहना चाहिए"

अधिकांश आरडीडी संचालन आलसी हैं I आपरेशनों की एक श्रृंखला के विवरण के रूप में RDD के बारे में सोचें। एक RDD डेटा नहीं है तो यह पंक्ति:

 val textFile = sc.textFile("/user/emp.txt") 

यह कुछ भी नहीं करता है यह आरडीडी बनाता है जो कहते हैं, "हमें इस फाइल को लोड करना होगा"। फाइल इस बिंदु पर लोड नहीं की गई है।

आरडीडी संचालन जो डेटा की सामग्रियों को देखने की आवश्यकता होती है, आलसी नहीं हो सकती। (ये क्रियाओं को कहा जाता है ।) एक उदाहरण RDD.count – आपको फ़ाइल में पंक्तियों की संख्या बताए जाने के लिए, फ़ाइल को पढ़ना होगा। इसलिए यदि आप textFile.count , तो इस बिंदु पर फाइल पढ़ी जाएगी, लाइनों की गणना की जाएगी, और गिनती वापस की जाएगी।

क्या होगा अगर आप textFile.count फिर से कहते हैं? एक ही बात: फ़ाइल को फिर से पढ़ा जाएगा और गिना जाएगा। कुछ भी संग्रहीत नहीं है एक RDD डेटा नहीं है

तो RDD.cache क्या करता है? यदि आप ऊपर दिए गए कोड में textFile.cache जोड़ते हैं:

 val textFile = sc.textFile("/user/emp.txt") textFile.cache 

यह कुछ भी नहीं करता है RDD.cache भी एक आलसी ऑपरेशन है। फ़ाइल अभी भी पढ़ा नहीं है लेकिन अब आरडीडी कहते हैं, "यह फाइल पढ़ो और फिर सामग्री को कैश करें" यदि आप पहली बार textFile.count चलाते हैं, तो फ़ाइल लोड की जाएगी, कैश की गई, और गिना जाएगा। यदि आप दूसरी बार textFile.count कॉल textFile.count , तो ऑपरेशन कैश का उपयोग करेगा। यह केवल कैश से डेटा लेगा और लाइनों की गणना करेगा

कैश व्यवहार उपलब्ध स्मृति पर निर्भर करता है अगर फ़ाइल स्मृति में फिट नहीं होती है, उदाहरण के लिए, तब textFile.count वापस सामान्य व्यवहार में आ जाएगी और फाइल को फिर से पढ़ा जाएगा।

मुझे लगता है कि प्रश्न बेहतर रूप से तैयार होगा:

हमें कैश कॉल करने या आरडीडी पर जारी रखने की आवश्यकता क्यों है?

स्पार्क प्रक्रियाएं आलसी हैं, अर्थात यह तब तक कुछ भी नहीं होगा जब तक इसकी आवश्यकता न हो। प्रश्न के तुरंत जवाब देने के लिए, val textFile = sc.textFile("/user/emp.txt") जारी किए जाने के बाद, डेटा के साथ कुछ भी नहीं होता है, केवल स्रोत के रूप में फ़ाइल का उपयोग करके, केवल एक HadoopRDD का निर्माण HadoopRDD है

मान लीजिए कि हम उस डेटा को थोड़ा बदलते हैं:

 val wordsRDD = textFile.flatMap(line => line.split("\\W")) 

फिर, डेटा के साथ कुछ भी नहीं होता है अब एक नया wordsRDD है जिसमें testFile लिए एक संदर्भ और आवश्यक होने पर एक फ़ंक्शन लागू किया जा सकता है।

केवल जब कोई क्रिया wordsRDD.count , जैसे wordsRDD.count , wordsRDD.count श्रृंखला, जिसे वंश कहा जाता है। यही है, विभाजन, डेटा में टूट गया, स्पार्क क्लस्टर के निष्पादकों द्वारा लोड किया जाएगा, flatMap फ़ंक्शन लागू होगा और परिणाम की गणना की जाएगी।

एक रेखीय वंश पर, इस उदाहरण में, cache() की आवश्यकता नहीं है। डेटा निष्पादकों को लोड किया जाएगा, सभी परिवर्तनों को लागू किया जाएगा और अंत में count जाएगी, सभी स्मृति में – अगर डेटा मेमोरी में फिट बैठता है

cache उपयोगी है जब आरडीडी शाखाओं की वंशावली बाहर होती है। मान लीजिए कि आप पिछली उदाहरण के शब्दों को सकारात्मक और नकारात्मक शब्दों के लिए गिनने में फ़िल्टर करना चाहते हैं। आप ऐसा कर सकते हैं:

 val positiveWordsCount = wordsRDD.filter(word => isPositive(word)).count() val negativeWordsCount = wordsRDD.filter(word => isNegative(word)).count() 

यहां, प्रत्येक शाखा डेटा के एक पुनः लोड का मुकाबला करता है। एक स्पष्ट cache विवरण जोड़ने से यह सुनिश्चित होगा कि पहले किए गए प्रोसेसिंग को संरक्षित और पुनः उपयोग किया गया है। नौकरी इस तरह दिखाई देगी:

 val textFile = sc.textFile("/user/emp.txt") val wordsRDD = textFile.flatMap(line => line.split("\\W")) wordsRDD.cache() val positiveWordsCount = wordsRDD.filter(word => isPositive(word)).count() val negativeWordsCount = wordsRDD.filter(word => isNegative(word)).count() 

इस कारण से, cache को 'वंश को तोड़ना' कहा जाता है क्योंकि यह एक चेकपॉइंट बनाता है जिसे आगे की प्रक्रिया के लिए पुन: उपयोग किया जा सकता है।

अंगूठे का नियम: cache उपयोग cache जब आपके आरडीडी शाखाओं की वंश या जब कोई आरडीडी एक लूप में कई बार उपयोग किया जाता है।

क्या हमें आरडीडी डेटा को स्मृति में संग्रहीत करने के लिए स्पष्ट रूप से "कैश" या "निरंतर" कॉल करने की ज़रूरत है?

हाँ, केवल तभी आवश्यक है जब

डिफ़ॉल्ट रूप से मेमोरी में एक वितरित तरीके से संग्रहीत RDD डेटा?

नहीं!

और ये क्यों कारण हैं:

  • स्पार्क दो प्रकार के साझा किए गए चर का समर्थन करता है: प्रसारण वेरिएबल्स, जिनका इस्तेमाल सभी नोड्स पर स्मृति में मूल्य को कैश करने के लिए किया जा सकता है, और जमाकर्ताओं, जो वे चर हैं जो केवल "जोड़े गए" हैं, जैसे काउंटर और रकम

  • RDDs दो प्रकार के आपरेशनों का समर्थन करते हैं: परिवर्तन, जो मौजूदा एक से एक नया डाटासेट बनाते हैं, और क्रिया, जो डेटासेट पर एक गणना चलाने के बाद ड्राइवर कार्यक्रम में एक मान लौटाते हैं। उदाहरण के लिए, मानचित्र एक परिवर्तन है जो एक डेटा के माध्यम से प्रत्येक डाटासेट तत्व को उत्तीर्ण करता है और परिणामों का प्रतिनिधित्व करने वाला एक नया आरडीडी देता है। दूसरी ओर, कम करना एक ऐसी क्रिया है जो कुछ फ़ंक्शन का उपयोग करके आरडीडी के सभी तत्वों को जोड़ती है और अंतिम परिणाम को ड्रायवर कार्यक्रम में वापस लाती है (हालांकि एक समान डेटा भी है जो एक वितरित डाटासेट देता है)।

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

  • डिफ़ॉल्ट रूप से, हर बार बदलकर आरडीडी को हर बार जब आप उस पर एक कार्रवाई चलाते हैं, फिर से दोहराया जा सकता है। हालांकि, आप लगातार (या कैश) पद्धति का उपयोग करके स्मृति में आरडीडी को जारी रख सकते हैं, इस स्थिति में स्पार्क अगली बार जब आप पूछते हैं तो तत्वों को बहुत तेज पहुंच के लिए क्लस्टर पर रखेंगे। डिस्क पर RDDs जारी रखने के लिए, या एकाधिक नोड्स में दोहराए जाने के लिए समर्थन भी है।

अधिक जानकारी के लिए कृपया स्पार्क प्रोग्रामिंग गाइड की जांच करें।

जोड़ने के लिए एक अन्य कारण जोड़ने (या अस्थायी रूप से जोड़) cache विधि कॉल

डीबग स्मृति मुद्दों के लिए

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

नीचे तीन स्थितियों को आप अपनी आरडीडी कैश करनी चाहिए:

एक RDD का उपयोग कई बार

एक ही RDD पर कई कार्रवाई करने

(या बहुत महंगा) परिवर्तनों की लंबी श्रृंखला के लिए