Pyspark: पुनर्गठन बनाम विभाजन

Question

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

rdd = sc.parallelize([('a', 1), ('a', 2), ('b', 1), ('b', 3), ('c',1), ('ef',5)]) 
rdd1 = rdd.repartition(4) 
rdd2 = rdd.partitionBy(4) 

rdd1.glom().collect() 
[[('b', 1), ('ef', 5)], [], [], [('a', 1), ('a', 2), ('b', 3), ('c', 1)]] 

rdd2.glom().collect() 
[[('a', 1), ('a', 2)], [], [('c', 1)], [('b', 1), ('b', 3), ('ef', 5)]] 

मैं दोनों के कार्यान्वयन पर एक नज़र ले लिया, और फर्क सिर्फ इतना है कि मैं अधिकांश भाग के लिए ध्यान दिया है:

यहां कुछ नमूना कोड है डिफ़ॉल्ट रूप से portable_hash। तो विभाजन में, सभी एक ही कुंजी एक ही विभाजन में होना चाहिए। पुनरावृत्ति में, मैं अपेक्षा करता हूं कि विभाजन विभाजनों पर अधिक समान रूप से वितरित किए जाएंगे, लेकिन यह मामला नहीं है।

यह देखते हुए, कोई भी पुन: विभाजन का उपयोग क्यों करेगा? मुझे लगता है कि केवल एक बार जब मैं इसे इस्तेमाल कर सकता हूं तो यह है कि अगर मैं पीएआरआरडीडी के साथ काम नहीं कर रहा हूं, या मेरे पास बड़ी डेटा स्कू है?

क्या ऐसा कुछ है जो मुझे याद आ रहा है, या कोई मेरे लिए एक अलग कोण से प्रकाश डाल सकता है?

Answer 1

repartition आरडीडी में पहले से मौजूद है, और कुंजी द्वारा विभाजित नहीं करता है (या ऑर्डरिंग को छोड़कर किसी भी अन्य मानदंड से)। अब PairRDDs कुंजी की धारणा जोड़ते हैं और बाद में एक और विधि जोड़ते हैं जो उस कुंजी द्वारा विभाजन करने की अनुमति देता है।

तो हाँ, यदि आपका डेटा कुंजी है, तो आपको उस कुंजी से बिल्कुल विभाजन करना चाहिए, जो कि कई मामलों में पहली जगह में एक पीएआरआरडीडी का उपयोग करने का बिंदु है (जुड़ने के लिए, कम करने के लिए, और इसी तरह)।

Answer 2

पुनरावृत्ति() का उपयोग कोर की संख्या और आपके पास मौजूद डेटा की मात्रा पर विचार करने वाले विभाजनों की संख्या निर्दिष्ट करने के लिए किया जाता है।

विभाजन बाई() का उपयोग शफल कार्यों को और अधिक कुशल बनाने के लिए किया जाता है, जैसे कि कम करने के लिए बाईके(), join(), cogroup() आदि .. यह केवल उन मामलों में फायदेमंद है जहां कई बार आरडीडी का उपयोग किया जाता है, इसलिए यह आमतौर पर जारी() के बाद। कार्रवाई में दोनों के बीच

अंतर:

pairs = sc.parallelize([1, 2, 3, 4, 2, 4, 1, 5, 6, 7, 7, 5, 5, 6, 4]).map(lambda x: (x, x)) 

pairs.partitionBy(3).glom().collect() 
[[(3, 3), (6, 6), (6, 6)], 
[(1, 1), (4, 4), (4, 4), (1, 1), (7, 7), (7, 7), (4, 4)], 
[(2, 2), (2, 2), (5, 5), (5, 5), (5, 5)]] 

pairs.repartition(3).glom().collect() 
[[(4, 4), (2, 2), (6, 6), (7, 7), (5, 5), (5, 5)], 
[(1, 1), (4, 4), (6, 6), (4, 4)], 
[(2, 2), (3, 3), (1, 1), (5, 5), (7, 7)]]