स्पार्क में दो अलग-अलग एपीआई क्यों हैं और गुना क्यों हैं?

Question

स्काला मानक lib का उपयोग कर, मैं इस तरह somthing कर सकते हैं:

scala> val scalaList = List(1,2,3) 
scalaList: List[Int] = List(1, 2, 3) 

scala> scalaList.foldLeft(0)((acc,n)=>acc+n) 
res0: Int = 6 

कई Ints में से एक इंट बनाना।

और मैं कुछ इस तरह कर सकते हैं:

scala> scalaList.foldLeft("")((acc,n)=>acc+n.toString) 
res1: String = 123 

कई Ints में से एक स्ट्रिंग बनाना।

तो, फ़ोल्ड लेफ्ट या तो सजातीय या विषम हो सकता है, जो भी हम चाहते हैं, यह एक एपीआई में है।

स्पार्क में रहते हुए, अगर मैं कई Ints में से एक इंट चाहते हैं, मैं यह कर सकता:

scala> val rdd = sc.parallelize(List(1,2,3)) 
rdd: org.apache.spark.rdd.RDD[Int] = ParallelCollectionRDD[1] at parallelize at <console>:12 
scala> rdd.fold(0)((acc,n)=>acc+n) 
res1: Int = 6 

गुना एपीआई foldLeft के समान है, लेकिन यह, केवल सजातीय है एक RDD [इंट] कर सकते हैं केवल फोल्ड के साथ int उत्पादन।

scala> rdd.aggregate("")((acc,n)=>acc+n.toString, (s1,s2)=>s1+s2) 
res11: String = 132 

यह विषम है, एक RDD [इंट] अब एक स्ट्रिंग उत्पादन कर सकते हैं:

भी चिंगारी में एक कुल एपीआई नहीं है।

तो, स्पार्क में दो अलग-अलग एपीआई के रूप में फोल्ड और कुल क्यों लागू किए गए हैं?

वे फ़ोल्डलिफ्ट की तरह क्यों डिज़ाइन नहीं किए गए हैं जो एकरूप और विषम दोनों हो सकते हैं?

(मैं बहुत स्पार्क के लिए नया हूँ, कृपया मुझे क्षमा करें अगर यह एक मूर्खतापूर्ण सवाल है।)

Answer 1

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

(इसके अलावा यह सुविधा के लिए सामान्य स्थिति के लिए एक सरल एपीआई के लिए अच्छा है। मानक lib इस कारण के लिए reduce के साथ-साथ foldLeft है)

Answer 2

विशेष रूप से स्पार्क में, गणना वितरित और समानांतर में किया जाता है, इसलिए foldLeft को लागू नहीं किया जा सकता क्योंकि यह मानक पुस्तकालय में है।

def aggregate[U: ClassTag](zeroValue: U)(seqOp: (U, T) => U, combOp: (U, U) => U): U 

Answer 3

: इसके बजाय, कुल दो काम करता है, एक है कि प्रकार T के प्रत्येक तत्व पर fold के समान कार्य करता है, प्रकार U के एक मूल्य के उत्पादन, और एक अन्य है कि अंतिम मूल्य में प्रत्येक विभाजन से U को जोड़ती है की आवश्यकता है

foldLeft, foldRight, reduceLeft, reduceRight, scanLeft और scanRight ऐसे ऑपरेशन हैं जहां संचित पैरामीटर इनपुट पैरामीटर ((A, B) -> B) से भिन्न हो सकता है और उन परिचालनों को क्रमशः निष्पादित किया जा सकता है।

fold एक ऑपरेशन है जहां संचित पैरामीटर इनपुट पैरामीटर ((A, A) -> A) का एक ही प्रकार होना चाहिए। फिर इसे समानांतर में निष्पादित किया जा सकता है।

aggregation एक ऑपरेशन है जहां संचित पैरामीटर इनपुट पैरामीटर के रूप में अलग-अलग प्रकार का हो सकता है, लेकिन फिर आपको एक अतिरिक्त फ़ंक्शन प्रदान करना होगा जो परिभाषित करता है कि संचित पैरामीटर को अंतिम परिणाम में कैसे समेकित किया जा सकता है। यह ऑपरेशन समानांतर निष्पादन की अनुमति देता है। aggregation ऑपरेशन foldLeft और fold का संयोजन है।

अधिक विस्तृत जानकारी के लिए, यदि आप "समानांतर प्रोग्रामिंग के लिए" Coursera वीडियो पर एक नज़र पाठ्यक्रम हो सकता है:

• https://www.coursera.org/learn/parprog1/lecture/efzVT/data-parallel-operations-i
• https://www.coursera.org/learn/parprog1/lecture/shwKn/data-parallel-operations-ii