RDD स्पार्क का उपयोग: अपाचे स्पार्क का बिल्डिंग ब्लॉक

RDD पर स्पार्क का उपयोग करने वाला यह ब्लॉग आपको RDD का एक विस्तृत और व्यापक ज्ञान प्रदान करेगा, जो स्पार्क की मूलभूत इकाई है और यह कितना उपयोगी है।

, शब्द ही हर Hadoop इंजीनियर के दिमाग में एक चिंगारी उत्पन्न करने के लिए पर्याप्त है। सेवा मेरे n इन-मेमोरी प्रसंस्करण उपकरण जो क्लस्टर कंप्यूटिंग में बिजली-तेज है। MapReduce की तुलना में, इन-मेमोरी डेटा शेयरिंग RDDs बनाता है 10-100x और तेज नेटवर्क और डिस्क शेयरिंग की तुलना में और यह सब RDDs (रिसिलिएंट डिस्ट्रिब्यूटेड डेटा सेट्स) के कारण संभव है। स्पार्क लेख का उपयोग कर इस RDD में आज हम जिन प्रमुख बिंदुओं पर ध्यान केंद्रित कर रहे हैं, वे हैं:

RDDs की आवश्यकता है

हमें RDD की आवश्यकता क्यों है? -RDD स्पार्क का उपयोग करके





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

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



यह कहाँ है RDDs (लचीला वितरित डेटासेट) बड़ी तस्वीर के लिए आता है।

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



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

RDD क्या हैं?

RDD या ( लचीला वितरित डेटा सेट ) एक मौलिक है डेटा संरचना स्पार्क में। शब्द लचीला स्वचालित रूप से या डेटा उत्पन्न करने की क्षमता को परिभाषित करता है समेट लेना तक मूल अवस्था जब डेटा हानि की संभावना के साथ एक अप्रत्याशित आपदा होती है।

RDDs में लिखा गया डेटा है विभाजन हुआ और में संग्रहीत कई निष्पादन योग्य नोड्स यदि एक निष्पादन नोड विफल रहता है दौड़ के समय में, यह तुरंत वापस ऊपर से हो जाता है अगला निष्पादन योग्य नोड । यही कारण है कि अन्य पारंपरिक डेटा संरचनाओं की तुलना में RDD को एक उन्नत प्रकार की डेटा संरचना माना जाता है। RDDs संरचित, असंरचित और अर्ध-संरचित डेटा संग्रहीत कर सकते हैं।

स्पार्क ब्लॉग का उपयोग करके अपने RDD के साथ आगे बढ़ें और RDDs की विशिष्ट विशेषताओं के बारे में जानें जो इसे अन्य प्रकार के डेटा संरचनाओं पर बढ़त देता है।

RDD की विशेषताएं

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

स्पार्क का उपयोग कर आरडीडी का निर्माण

RDDs में बनाया जा सकता है तीन तरीके से:

कैसे एक कृत्रिम बुद्धि इंजीनियर बनने के लिए
  1. से डेटा पढ़ना समानांतर संग्रह
वैल पीसीआरडीडी = स्पार्क.स्पार्ककोटेक्स्ट.परेलराइज (एरे ('मोन', 'टयू', 'वेड', 'थू', 'शुक्र', 'सैट'), 2) वैल रिजल्ट डीआरडीसी / पीसीआरडीडी.कलेक्ट () resultRDD.collect () ) .पेच (प्रिंटल)
  1. लगाना परिवर्तन पिछले RDDs पर
वैल शब्द = स्पार्क। स्पार्क कॉन्टेक्स्ट। समानांतर (सीक ('स्पार्क', 'है', 'ए', 'ए', 'पावरफुल', 'लैंग्वेज')) वेल वर्डेयर = शब्द.मैप (w = (w.charAt) 0), w)) wordpair.collect ()। फ़ॉरच (प्रिंटल)
  1. से डेटा पढ़ना बाह्य भंडारण या फ़ाइल पथ की तरह HDFS या HBase
वैल स्पार्कफाइल = स्पार्क। ट्रेड.टेक्स्ट फ़िले ('/ उपयोगकर्ता / edureka_566977 / स्पार्क / स्पार्क। टेक्स्ट') स्पार्कफाइल.कलेक्ट ()

RDDs पर किया गया संचालन:

मुख्य रूप से दो प्रकार के ऑपरेशन होते हैं, जो आरडीडी पर किए जाते हैं, जैसे:

  • रूपांतरण
  • क्रिया

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

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

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

  • संकीर्ण रूपांतरण
  • वाइड ट्रांसफॉर्मेशन

संकीर्ण रूपांतरण हम एक पर संकीर्ण परिवर्तनों को लागू करते हैं एकल विभाजन आरडीडी को संसाधित करने के लिए आवश्यक डेटा के रूप में एक नया आरडीडी उत्पन्न करने के लिए माता-पिता आरडीडी के एक ही विभाजन पर उपलब्ध है माता-पिता ए.एस.डी. । संकीर्ण परिवर्तनों के उदाहरण हैं:

  • नक्शा()
  • फ़िल्टर ()
  • फ्लैटपाइप ()
  • विभाजन ()
  • मैपपार्टीज ()

विस्तृत रूपांतरण: हम व्यापक परिवर्तन लागू करते हैं कई विभाजन एक नया आरडीडी उत्पन्न करने के लिए। आरडीडी को संसाधित करने के लिए आवश्यक डेटा के कई विभाजन पर उपलब्ध है माता-पिता ए.एस.डी. । व्यापक परिवर्तनों के उदाहरण हैं:

  • से कम()
  • संघ ()

क्रिया : कार्य अपाचे स्पार्क को लागू करने का निर्देश देते हैं संगणना और परिणाम या ड्राइवर आरडीडी को एक अपवाद वापस पास करें। कुछ कार्यों में शामिल हैं:

  • इकट्ठा ()
  • गिनती ()
  • लेना()
  • प्रथम()

हमें व्यावहारिक रूप से RDDs पर परिचालन लागू करने दें:

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

  • पहले तो, आइए आईपीएल के एक सीएसवी मैच डेटा डाउनलोड करें। इसे डाउनलोड करने के बाद, यह पंक्तियों और स्तंभों के साथ एक EXCEL फ़ाइल के रूप में देखना शुरू कर देता है।

अगले चरण में, हम स्पार्क फायर करते हैं और माचिस को लोड करते हैं। एससीवी फाइल अपने स्थान से, मेरे मामले मेंसीएसवीफ़ाइल स्थान है 'Auser/edureka_566977/test/matches.csv'

अब हम इसके साथ शुरू करते हैं परिवर्तन पहला भाग:

  • नक्शा():

हम उपयोग करते हैं नक्शा परिवर्तन RDD के प्रत्येक तत्व पर एक विशिष्ट परिवर्तन ऑपरेशन लागू करने के लिए। यहाँ हम CKfile नाम से एक RDD बनाते हैं जहाँ हमारा स्टोर होता हैसीएसवीफ़ाइल। हम राज्यों को एक और आरडीडी नाम देंगे शहर का विवरण संग्रहीत करें

स्पार्क 2-शेल वैल CKfile = sc.textFile ('/ user / edureka_566977 / test / match.csv') CKfile.collect.foreach (println) वैल स्टेट्स =KKile.map (_।, विभाजन) (',') (2))। राज्यों। रंग ()।

  • फ़िल्टर ():

फ़िल्टर परिवर्तन, नाम ही इसके उपयोग का वर्णन करता है। हम दिए गए डेटा के संग्रह में से चयनात्मक डेटा को फ़िल्टर करने के लिए इस परिवर्तन ऑपरेशन का उपयोग करते हैं। हम आवेदन करते हैं फ़िल्टर संचालन यहाँ वर्ष के आईपीएल मैचों के रिकॉर्ड पाने के लिए 2017 और इसे फिल्म RDD में संग्रहीत करें।

वैल फिल्म = CKfile.filter (लाइन => line.contains ('2017')) fil.lectlect ()। foreach (println)।

  • फ्लैटपाइप ():

हम लागू करते हैं कि एक नए आरआरडीडी बनाने के लिए आरडीडी के प्रत्येक तत्व के लिए फ्लैटपॉपर एक ट्रांसफॉर्मेशन ऑपरेशन है। यह मानचित्र परिवर्तन के समान है। यहाँ हम आवेदन करते हैंसपाट सासेवा मेरे हैदराबाद शहर के मैचों को बाहर थूकना और डेटा को इसमें संग्रहीत करेंfilRDDRDD।

Val filRDD = fil.flatMap (पंक्ति => line.split ('हैदराबाद'))। collect ()

  • विभाजन ():

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

वैल फिल्म = CKfile.filter (लाइन => line.contains ('2017')) fil.part..ize

  • मैपपार्टिशन ():

हम MapPatitions को Map () और के विकल्प के रूप में मानते हैंप्रत्येक के लिए() सम्मिलित रूप से। हम खोजने के लिए यहाँ mapPartitions का उपयोग करें पंक्तियों की संख्या हम अपनी फिल्म आरडीडी में हैं।

वैल फिल्म = CKfile.filter (लाइन => line.contains ('2016')) fil.mapPartitions (idx => Array (idx.size) .iterator) .collect

  • से कम():

हम उपयोग करते हैंसे कम() पर की-वैल्यू जोड़े । हमने इस परिवर्तन का उपयोग कियासीएसवीके साथ खिलाड़ी को खोजने के लिए फ़ाइल सबसे ज्यादा मैन ऑफ द मैच

Val ManOfTheMatch = CKfile.map (_। विभाजित करें (',') (13)) val MOTMcount = ManOfTheMatch.map (Wincount => (Wincount, 1)) valOTOTH = MOTMcount.reduceByKey (x, y) = x x = + y) .map (tup => (tup._2, tup._1)) SortByKey (false) ManOTH.take (10) .foreach (println)।

  • संघ ():

नाम यह सब समझाता है, हम संघ परिवर्तन का उपयोग करते हैं क्लब दो RDDs एक साथ । यहाँ हम दो RDDs बना रहे हैं अर्थात् फिल्म और फिल्म 2। फिल्म आरडीडी में 2017 आईपीएल मैचों के रिकॉर्ड और फिल्म 2 आरडीडी में 2016 आईपीएल मैच रिकॉर्ड शामिल हैं।

Val fil = CKfile.filter (लाइन => line.contains ('2017')) val fil2 = CKfile.filter (लाइन => line.contains ('2016')) val uninDDD = fil.union (fil2)

शुरुआत करते हैं क्रिया वह हिस्सा जहां हम वास्तविक आउटपुट दिखाते हैं:

  • इकट्ठा ():

संग्रह वह क्रिया है जिसका हम उपयोग करते हैं सामग्री प्रदर्शित करें RDD में।

वैल CKfile = sc.textFile ('/ user / edureka_566977 / test / match.csv') CKfile.collect.foreach (println)

  • गिनती ():

गिनतीएक ऐसी क्रिया है जिसका उपयोग हम गिनती करने के लिए करते हैं रिकॉर्ड की संख्या RDD में मौजूद है।यहाँहम अपने मैचों के रिकॉर्ड की कुल संख्या की गणना करने के लिए इस ऑपरेशन का उपयोग कर रहे हैं। फाइल फ़ाइल।

वैल CKfile = sc.textFile ('/ user / edureka_566977 / test / match.csv') CKfile.count ()

  • लेना():

टेक ए कलेक्शन के समान एक एक्शन ऑपरेशन है लेकिन अंतर केवल इतना है कि इसे कोई भी प्रिंट कर सकता है पंक्तियों की चयनात्मक संख्या उपयोगकर्ता के अनुरोध के अनुसार। यहां हम प्रिंट करने के लिए निम्नलिखित कोड लागू करते हैं शीर्ष दस प्रमुख रिपोर्ट

Val Statecountm = Scount.reduceByKey ((x, y) => x + y) .map (tup => (tup._2, tup._1)) SortByKey (false) Stateccm.collect ()। foreach (println) Statecountm। ले (10) .foreach (println)

  • प्रथम():

पहला () इकट्ठा करने (और लेने) () के समान एक एक्शन ऑपरेशन हैयहसबसे ज्यादा रिपोर्ट के आउटपुट को प्रिंट करने के लिए उपयोग किया जाता है। यहां हम पहले () ऑपरेशन का उपयोग करते हैं किसी विशेष शहर में अधिकतम मैच खेले गए और हमें आउटपुट के रूप में मुंबई मिलता है।

val CKfile = sc.textFile ('/ user / edureka_566977 / test / match.csv') val अवस्थाएँ = CKfile.map (_। विभाजित) (',') (2): val Scount = states.map (Scount =>)। Scount, 1)) scala & gt val Statecount = Scount.reduceByKey ((x, y) => x + y) .collect.foreach (println) Scount.reduceByKey (x, y) => x + y) .collect.foreach (Println) वैल स्टेटकाउंट = स्काउट.्रेड्यूसबायके ((x, y) => + + y) .मैप (tup => (tup._2, tup._1)) SortByKey (झूठा) Statecountm.first ()

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

RDD स्पार्क का उपयोग: नि प्रयोग केस

  • पहले तो, आइए हम एक Pokemon.csv फ़ाइल डाउनलोड करें और इसे स्पार्क-शेल पर लोड करें जैसा कि हमने Matches.csv फ़ाइल में किया था।
val PokemonDataRDD1 = sc.textFile ('/ user / edureka_566977 / PokemonFile / PokemonData.csv') PokemonDataRDD1.collect () - foreach (println)।

पोकेमॉन वास्तव में एक विशाल विविधता में उपलब्ध हैं, आइए हम कुछ किस्मों को खोजें।

  • Pokemon.csv फ़ाइल से स्कीमा को निकालना

हमें जरूरत नहीं है स्कीमा Pokemon.csv फ़ाइल की। इसलिए, हम इसे हटा देते हैं।

Val Head = PokemonDataRDD1.first () val NoHeader = PokemonDataRDD1.filter (लाइन =>! line.equals (हेड)

  • की संख्या ज्ञात करना विभाजन हमारे pokemon.csv में वितरित किया जाता है।
Println ('संख्या-गुणन =' + NoHeader.partitions.size)

  • पानी का नि

ढूँढना पानी पोकेमॉन की संख्या

वैल वाटर आरआरडीडी = पोकेमॉनडॉटआरडी 1 (फाइटर) (लाइन => लाइन.कंटेनर्स ('वाटर') वाटर आरडीडी.क्लेक्ट ()। फ़ॉरच (प्रिंटल)

कठपुतली बनाम महाराज बनाम डॉकटर
  • फायर पोकेमॉन

ढूँढना आग पोकेमॉन की संख्या

val FireRDD = PokemonDataRDD1.filter (लाइन => line.contains (Fire Fire ’)) FireRDD.collect ()। foreach (println)।

  • हम इसका भी पता लगा सकते हैं आबादी गिनती फ़ंक्शन का उपयोग करके एक अलग प्रकार के पोकेमॉन के
WaterRDD.count () FireRDD.count ()

  • चूंकि मुझे खेल पसंद है रक्षात्मक रणनीति आइए हम पोकेमॉन को ढूंढते हैं अधिकतम बचाव।
Val defenceList = NoHeader.map {x => x.split (',')} मानचित्र। {x => (x (6) .toDouble)} Println ('Highest_Defence: + defenceList.max ())

  • हम अधिकतम जानते हैं रक्षा शक्ति मूल्य लेकिन हम नहीं जानते हैं कि यह कौन सा है। तो, आइए हम पाते हैं कि कौन सी है पोकेमॉन।
val defWithPokemonName = NoHeader.map {x => x.split ((',')})। map {x => (x (6) .toDouble, x (1))} val MaxDenceencePokemon = defWithPokemonName.groupByKey.takeOrdered (1)। (ऑर्डरिंग [डबल] .reverse.on (_._ 1)) MaxDefencePokemon.foreach (printn)

  • अब हम पोकेमॉन को सॉर्ट करते हैं कम से कम रक्षा
Val minDefencePokemon = defenceList.distinct.sortBy (x => x.toDouble, true, 1) minDefencePokemon.take (5) .foreach (println)

  • अब हम पोकेमॉन को एक के साथ देखते हैं कम रक्षात्मक रणनीति।
val PokemonDataRDD2 = sc। .map {x => x.split (',')}। नक्शा {x => (x (6) .toDouble, x (1))} val MinDefencePokemon2 = defWithPokemonNy2.groupByKey.takeOrdered (1) (ऑर्डरिंग [डबल) ] .on (_._ 1)) MinDefencePokemon2.foreach (println)

तो, इस के साथ, हम स्पार्क लेख का उपयोग करके इस आरडीडी के अंत में आते हैं। मुझे आशा है कि हमने RDDs, उनकी विशेषताओं और उन पर किए जा सकने वाले विभिन्न प्रकार के ऑपरेशनों के बारे में आपके ज्ञान पर थोड़ा प्रकाश डाला।

इस लेख पर आधारित आपको Cloudera Hadoop और Spark Developer प्रमाणन परीक्षा (CCA175) के लिए तैयार करने के लिए डिज़ाइन किया गया है। आपको अपाचे स्पार्क और स्पार्क इकोसिस्टम पर गहराई से ज्ञान मिलेगा, जिसमें स्पार्क आरडीडी, स्पार्क एसक्यूएल, स्पार्क एमएललिब और स्पार्क स्ट्रीमिंग शामिल हैं। आपको स्केल प्रोग्रामिंग लैंग्वेज, एचडीएफएस, सकूप, फ्लूम, स्पार्क ग्राफएक्स और मैसेजिंग सिस्टम जैसे काफ्का पर व्यापक ज्ञान मिलेगा।