पुस्तक "प्रभावी स्पार्क। स्केलिंग और अनुकूलन "

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

अन्य प्रोग्रामिंग भाषाओं में काम करने का मतलब हमेशा यह नहीं होता है कि आपको जेवीएम से आगे जाने की जरूरत है, और जेवीएम में काम करने से प्रदर्शन के मामले में कई फायदे हैं - मुख्य रूप से इस तथ्य के कारण कि आपको डेटा कॉपी करने की आवश्यकता नहीं है। हालाँकि यह आवश्यक नहीं है कि स्लैक भाषा के बाहर से स्पार्क तक पहुँचने के लिए विशेष बाध्यकारी पुस्तकालयों या एडेप्टर का उपयोग किया जाए, अन्य प्रोग्रामिंग भाषाओं से स्काला कोड को लागू करना मुश्किल हो सकता है। स्पार्क फ्रेमवर्क लैम्ब्डा एक्सप्रेशन में जावा 8 के उपयोग का समर्थन करता है, और जो जेडीके के पुराने संस्करणों का उपयोग करते हैं, उनके पास org.apache.spark.api.java.function पैकेज से उपयुक्त इंटरफ़ेस को लागू करने का अवसर है। यहां तक ​​कि उन मामलों में जहां आपको डेटा की प्रतिलिपि बनाने की आवश्यकता नहीं है, दूसरी प्रोग्रामिंग भाषा में काम करने के लिए प्रदर्शन से संबंधित छोटी लेकिन महत्वपूर्ण बारीकियों हो सकती हैं।

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

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

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

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

उदाहरण 7.1 शब्द गणना (जावा)

import scala.Tuple2;  import org.apache.spark.api.java.JavaRDD; import org.apache.spark.api.java.JavaPairRDD import org.apache.spark.api.java.JavaSparkContext;  import java.util.regex.Pattern; import java.util.Arrays;  public final class WordCount { private static final Pattern pattern = Pattern.compile(" ");  public static void main(String[] args) throws Exception { JavaSparkContext jsc = new JavaSparkContext(); JavaRDD<String> lines = jsc.textFile(args[0]); JavaRDD<String> words = lines.flatMap(e -> Arrays.asList(                                           pattern.split(e)).iterator()); JavaPairRDD<String, Integer> wordsIntial = words.mapToPair(  e -> new Tuple2<String, Integer>(e, 1));   } } 

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

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

डमी क्लास टैग बनाने के लिए, आप scala.reflect.ClassTag $ .MODULE $ .AnyRef () विधि का उपयोग कर सकते हैं या scala.reflect.ClassTag $ .MassULE $ .apply (CLASS) का उपयोग करके वास्तविक प्राप्त कर सकते हैं, जैसा कि उदाहरण 7.2 और 7.3 में दिखाया गया है।

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

डमी क्लास टैग का उपयोग अक्सर जेनेरिक या टेम्प्लेट कोड में किया जाता है, जहां सटीक प्रकार संकलन के समय अज्ञात होते हैं। इस तरह के टैग अक्सर पर्याप्त होते हैं, हालांकि स्काला कोड के पक्ष में कुछ बारीकियों को खोने की संभावना है; बहुत ही दुर्लभ मामलों में, स्काला कोड को सटीक कक्षा टैग जानकारी की आवश्यकता होती है। इस मामले में, आपको एक वास्तविक टैग का उपयोग करना होगा। ज्यादातर मामलों में, इसके लिए अधिक प्रयास की आवश्यकता नहीं होती है और प्रदर्शन में सुधार होता है, इसलिए जहां भी संभव हो ऐसे टैग का उपयोग करने का प्रयास करें।

उदाहरण 7.2। जावा / स्काला आरडीडी को डमी क्लास टैग के साथ संगत बनाना

 public static JavaPairRDD wrapPairRDDFakeCt( RDD<Tuple2<String, Object>> RDD) { //       AnyRef —   //        , //        , //        //    ClassTag<Object> fake = ClassTag$.MODULE$.AnyRef(); return new JavaPairRDD(rdd, fake, fake); } 

उदाहरण 7.3। जावा / स्काला आरडीडी संगतता सुनिश्चित करना

 public static JavaPairRDD wrapPairRDD( RDD<Tuple2<String, Object>> RDD) { //    ClassTag<String> strCt = ClassTag$.MODULE$.apply(String.class); ClassTag<Long> longCt = ClassTag$.MODULE$.apply(scala.Long.class); return new JavaPairRDD(rdd, strCt, longCt); } 

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

जावा भाषा में उपयोगकर्ता-परिभाषित फ़ंक्शन (UDFs), और उस मामले के लिए, स्काला को छोड़कर अधिकांश अन्य भाषाओं में, उन्हें फ़ंक्शन द्वारा लौटाए गए मान के प्रकार को निर्दिष्ट करने की आवश्यकता होती है, क्योंकि यह तार्किक रूप से कटौती नहीं की जा सकती है, यह कैसे समान भाषा में किया जाता है (उदाहरण 7.4) ।

उदाहरण 7.4। जावा के लिए यूडीएफ नमूना

 sqlContext.udf() .register("strlen", (String s) -> s.length(), DataTypes.StringType); 

हालाँकि, स्काला और जावा एपीआई द्वारा आवश्यक प्रकार भिन्न हैं, जावा संग्रह प्रकारों को लपेटने के लिए अतिरिक्त प्रतिलिपि की आवश्यकता नहीं है। पुनरावृत्तियों के मामले में, एडेप्टर के लिए आवश्यक प्रकार का रूपांतरण विलंबित तरीके से किया जाता है क्योंकि तत्व एक्सेस किए जाते हैं, जो स्पार्क ढांचे को डेटा को डंप करने की अनुमति देता है यदि आवश्यक हो (जैसा कि अनुभाग में चर्चा की गई है "MapPartitions फ़ंक्शन का उपयोग करते हुए पेज 121 पर")। यह बहुत महत्वपूर्ण है क्योंकि कई सरल कार्यों के लिए डेटा की प्रतिलिपि बनाने की लागत स्वयं की लागत से अधिक हो सकती है।

स्काला और जेवीएम से परे

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

स्पार्क के बाहर सीधे समर्थित पहली गैर-जेवीएम प्रोग्रामिंग भाषा पाइथन है, इसका एपीआई और इंटरफ़ेस मॉडल बन गया है, जिस पर अन्य गैर-जेवीएम प्रोग्रामिंग भाषाओं के लिए कार्यान्वयन आधारित हैं।

कैसे PySpark काम करता है

PySpark, JVM Spark को श्रमिकों पर चैनलों और Py4J, एक विशेष पुस्तकालय का उपयोग करके जोड़ता है जो ड्राइवर पर Python / Java इंटरैक्शन प्रदान करता है। इसके तहत, पहली नज़र में, साधारण वास्तुकला बहुत सारी जटिल बारीकियों को छिपाती है, जिसकी बदौलत PySpark काम करती है, जैसा कि अंजीर में दिखाया गया है। 7.1। मुख्य समस्याओं में से एक: यहां तक ​​कि जब डेटा को पायथन कार्यकर्ता से जेवीएम में कॉपी किया जाता है, तो यह इस रूप में नहीं है कि एक आभासी मशीन आसानी से पार्स कर सकती है। जेवीएम को विभाजन जैसे कार्यों के लिए पर्याप्त जानकारी है, यह सुनिश्चित करने के लिए पायथन और जावा कार्यकर्ता दोनों की ओर से विशेष प्रयासों की आवश्यकता है।

PySpark RDD किट

जेवीएम से और साथ ही पायथन निष्पादक को चलाने के लिए डेटा स्थानांतरित करने के लिए संसाधनों की लागत महत्वपूर्ण है। आप DataFrame / Dataset API का उपयोग करके PySpark RDD Suite API के साथ कई प्रदर्शन समस्याओं से बच सकते हैं, क्योंकि JVM में डेटा यथासंभव लंबे समय तक रहता है।

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

प्रत्येक परिवर्तन के लिए डेटा विनिमय के लिए चैनलों का संगठन (दो दिशाओं में) बहुत महंगा होगा। परिणामस्वरूप, PySpark Python दुभाषिया के अंदर पाइपलाइन को रूपांतरित करता है (यदि संभव हो तो), फ़िल्टर ऑपरेशन का पीछा करते हुए, और इसके बाद मैप, विशेष PipelinedRDr कक्षा का उपयोग करते हुए Python ऑब्जेक्ट इटरेटर पर। यहां तक ​​कि जब आपको डेटा को फेरबदल करने की आवश्यकता होती है और किसी व्यक्ति की वर्चुअल मशीन में PySpark रूपांतरणों की श्रृंखला करने में सक्षम नहीं होता है, तो आप पायथन दुभाषिया का पुन: उपयोग कर सकते हैं, इसलिए दुभाषिया को शुरू करने की लागत और अधिक धीमी नहीं होगी।

यह पहेली का ही एक हिस्सा है। नियमित PipedRDD स्ट्रिंग प्रकार के साथ काम करते हैं, जो एक प्राकृतिक कुंजी की कमी के कारण फेरबदल करना इतना आसान नहीं है। PySpark में, और इसकी छवि और कई अन्य प्रोग्रामिंग भाषाओं के लिए बाध्य पुस्तकालयों में समानता में, PairwiseRDD का एक विशेष प्रकार का उपयोग किया जाता है, जहां कुंजी एक लंबा पूर्णांक है, और इसकी deserialization स्कैला भाषा में उपयोगकर्ता कोड द्वारा किया जाता है, जिसका उद्देश्य पायथन मानों को पार्स करने के लिए है। इस deserialization की लागत बहुत अधिक नहीं है, लेकिन यह दर्शाता है कि स्पार्क ढांचे में स्काला मूल रूप से पायथन कोड के परिणामों को "अपारदर्शी" बाइट सरणियों के रूप में काम करने के लिए मानता है।

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

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

दो दृष्टिकोण आमतौर पर एमएललिब के साथ बातचीत करने के लिए उपयोग किए जाते हैं: या तो पाइस्पार्क स्कैला प्रकार के रूपांतरण के साथ एक विशेष डेटा प्रकार का उपयोग करता है, या एल्गोरिथ्म पायथन में फिर से लागू किया जाता है। स्पार्क एमएल पैकेज के साथ इन समस्याओं से बचा जा सकता है, जो डेटाफ़्रेम / डेटासेट इंटरफ़ेस का उपयोग करता है, जो आमतौर पर जेवीएम में डेटा संग्रहीत करता है।

PySpark DataFrame और डेटासेट किट

DataFrame और Dataset सेट में Python RDD सेट API के साथ कई प्रदर्शन समस्याएँ नहीं होती हैं क्योंकि वे JVM में यथासंभव लंबे समय तक डेटा संग्रहीत करते हैं। वही प्रदर्शन परीक्षण जो हमने RDD सेट (देखें चित्र 3.1) पर डेटाफ़्रेम सेट की श्रेष्ठता को दर्शाने के लिए आयोजित किया था, जब पायथन (चित्र 7.2) में चल रहे महत्वपूर्ण अंतर को दर्शाता है।

DataFrame और Dataset सेट के साथ कई ऑपरेशनों के लिए, आपको JVM से डेटा को स्थानांतरित करने की आवश्यकता नहीं हो सकती है, हालांकि विभिन्न UDF, UDAF और पायथन लैम्ब्डा अभिव्यक्तियों का उपयोग करके स्वाभाविक रूप से JVM में कुछ डेटा को स्थानांतरित करने की आवश्यकता होती है। यह कई कार्यों के लिए निम्नलिखित सरलीकृत योजना की ओर जाता है, जो कि अंजीर में दिखाए गए की तरह दिखता है। 7.3।

स्कैला में अंतर्निहित जावा ऑब्जेक्ट और मिश्रित कोड तक पहुंच

पाइस्पार्क वास्तुकला का एक महत्वपूर्ण परिणाम यह है कि स्पार्क पायथन फ्रेमवर्क कक्षाओं में से कई वास्तव में अजगर कोड से कॉल को एक जेवीएम फॉर्म में अनुवाद करने के लिए अनुकूल हैं।

यदि आप स्काला / जावा डेवलपर्स के साथ काम करते हैं और उनके कोड के साथ बातचीत करना चाहते हैं, तो अग्रिम में आपके कोड तक पहुंचने के लिए कोई एडेप्टर नहीं होगा, लेकिन आप अपने जावा / स्काला यूडीएफ को पंजीकृत कर सकते हैं और उन्हें पायथन कोड से उपयोग कर सकते हैं। स्पार्क 2.1 के साथ शुरू, यह sqlContext ऑब्जेक्ट के registerJavaFunction पद्धति का उपयोग करके किया जा सकता है।

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

"बड़ी क्वेरी योजनाओं और पुनरावृति एल्गोरिदम" पृष्ठ पर उपधारा में। 91 हमने क्वेरी प्लान को कम करने के लिए डेटाफ़्रेम और आरडीडी सेट के जेवीएम संस्करण का उपयोग करने के महत्व को नोट किया। यह वर्कअराउंड है, क्योंकि स्पार्क SQL ऑप्टिमाइज़र द्वारा प्रोसेसिंग के लिए जब क्वेरी प्लान बहुत बड़ा हो जाता है, तो SQL ऑप्टिमाइज़र, RDD को बीच में सेट करने के कारण, RDD में डेटा दिखाई देने वाले पल से परे देखने की क्षमता खो देता है। सार्वजनिक पायथन एपीआई की मदद से एक ही चीज हासिल की जा सकती है, हालांकि, एक ही समय में, डेटाफ़्रेम सेट के कई फायदे खो जाएंगे, क्योंकि सभी डेटा को पायथन के काम करने वाले नोड्स के माध्यम से आगे और पीछे जाना होगा। इसके बजाय, आप जेवीएम में डेटा को स्टोर करके मूल ग्राफ को कम कर सकते हैं (जैसा कि उदाहरण 7.5 में दिखाया गया है)।

उदाहरण 7.5 पायथन का उपयोग करके डेटाफ़्रेम के लिए एक बड़ी क्वेरी योजना को ट्रिम करना

 def cutLineage(df): """    DataFrame —     .. :              >>> df = RDD.toDF() >>> cutDf = cutLineage(df) >>> cutDf.count() 3 """ jRDD = df._jdf.toJavaRDD() jSchema = df._jdf.schema() jRDD.cache() sqlCtx = df.sql_ctx try: javaSqlCtx = sqlCtx._jsqlContext except: javaSqlCtx = sqlCtx._ssql_ctx newJavaDF = javaSqlCtx.createDataFrame(jRDD, jSchema) newDF = DataFrame(newJavaDF, sqlCtx) return newDF 

आम तौर पर, कन्वेंशन द्वारा, _j [संक्षिप्त_नाम] सिंटैक्स का उपयोग अधिकांश पायथन ऑब्जेक्ट्स के आंतरिक जावा संस्करणों तक पहुंचने के लिए किया जाता है। इसलिए, उदाहरण के लिए, SparkContext ऑब्जेक्ट में _jsc है, जो आपको आंतरिक SparkContext जावा ऑब्जेक्ट प्राप्त करने की अनुमति देता है। यह केवल ड्राइवर प्रोग्राम में संभव है, इसलिए जब आप PySpark ऑब्जेक्ट्स को नोड्स में काम करने के लिए भेजते हैं, तो आप आंतरिक जावा घटक तक नहीं पहुंच पाएंगे और अधिकांश एपीआई काम नहीं करेंगे।

जेवीएम में स्पार्क क्लास तक पहुंचने के लिए, जिसमें पायथन एडाप्टर नहीं है, आप ड्राइवर पर Py4J गेटवे का उपयोग कर सकते हैं। SparkContext ऑब्जेक्ट में गेटवे के पास _gateway प्रॉपर्टी का लिंक होता है। वाक्य-विन्यास sc._gateway.jvm। [Full_class_name_in_JVM] किसी भी जावा ऑब्जेक्ट तक पहुँचने की अनुमति देगा।

एक समान तकनीक आपके स्वयं के स्काला वर्गों के लिए काम करेगी यदि उन्हें क्लासपाथ के अनुसार व्यवस्थित किया जाता है। आप स्पार्क-जमा कमांड के साथ --jars पैरामीटर का उपयोग करके या spark.driver.extraClassPath कॉन्फ़िगरेशन गुणों को सेट करके स्पार्क-जमा कमांड का उपयोग करके JAR फ़ाइलों को जोड़ सकते हैं। उदाहरण 7.6, जिसने चावल पैदा करने में मदद की। 7.2, जानबूझकर मौजूदा स्काला कोड का उपयोग करके प्रदर्शन परीक्षण के लिए डेटा उत्पन्न करने के लिए डिज़ाइन किया गया है।

उदाहरण 7.6 Py4J का उपयोग करके गैर-स्पार्क-जेवीएम कक्षाओं को कॉल करना

 sc = sqlCtx._sc #  SQL Context,   2.1, 2.0   , #  2.0, —  ,   :p try: try: javaSqlCtx = sqlCtx._jsqlContext except: javaSqlCtx = sqlCtx._ssql_ctx except: javaSqlCtx = sqlCtx._jwrapped jsc = sc._jsc scalasc = jsc.sc() gateway = sc._gateway #  java-,   RDD JVM- # Row (Int, Double).   RDD  Python   #  RDD  Java (   Row),   # ,      . #   Java-RDD  Row —     #    DataFrame,     #    RDD  Row. java_rdd = (gateway.jvm.com.highperformancespark.examples. tools.GenerateScalingData. generateMiniScaleRows(scalasc, rows, numCols)) #     JSON     . #  Python-     Java-. schema = StructType([ StructField("zip", IntegerType()), StructField("fuzzyness", DoubleType())]) #   2.1 /  2.1 try: jschema = javaSqlCtx.parseDataType(schema.json()) except: jschema = sqlCtx._jsparkSession.parseDataType(schema.json()) #  RDD (Java)  DataFrame (Java) java_dataframe = javaSqlCtx.createDataFrame(java_rdd, jschema) #  DataFrame (Java)  DataFrame (Python) python_dataframe = DataFrame(java_dataframe, sqlCtx) #  DataFrame (Python)   RDD pairRDD = python_dataframe.rdd.map(lambda row: (row[0], row[1])) return (python_dataframe, pairRDD) 

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

»पुस्तक की अधिक जानकारी प्रकाशक की वेबसाइट पर पाई जा सकती है
» सामग्री
» अंश

स्प्रेयर - स्पार्क के लिए कूपन पर 20% की छूट