दिलचस्प पोस्ट
एंड्रॉइड – SPAN_EXCLUSIVE_EXCLUSIVE स्पैन की शून्य लंबाई नहीं हो सकती मैं XML को एक सूची <स्ट्रिंग> या स्ट्रिंग में कैसे रूपांतरित कर सकता / सकती हूं? जीआईटी लाने या पुल के साथ स्वत: काट देना एक पृष्ठभूमि प्रक्रिया को आदेश भेजें उप-डायरेक्टरी में अलग-अलग फाइलों से वर्गों को आयात करना सी ++ में पाठ फ़ाइल में एक विशिष्ट पंक्ति में जाने का कोई तरीका है? पीडीएफबॉक्स: पीडीएफ पेज को छवि में बदलने में समस्या "Sed त्रुटि – अवैध बाइट अनुक्रम" (बाश में) प्राप्त करना ES6 टेम्पलेट लिटरल्स के लिए निष्पादन हटाएं कहाँ में (आईडी की सरणी) सत्र का उपयोग किए बिना एएसपी.एक्स.के. के पृष्ठों के मूल्यों को कैसे पारित किया जाए एकाधिक स्तंभों में एक स्तंभ को विभाजित करें इंटरॉप के लिए .NET के रूप में प्रॉपर्टी के रूप में एक्सपोज़िंग अनुरोधित नेट फ्रेमवर्क डेटा प्रदाता को खोजने में असमर्थ इसे शायद स्थापित न किया जा सके। – जब mvc3 asp.net ट्यूटोरियल का अनुसरण करते हैं मूल रखने के दौरान स्ट्रिंग पर मैं पर्ल प्रतिस्थापन कैसे करूं?

स्पार्क RDD के समान आकार के विभाजन के लिए कस्टम विभाजन को कैसे परिभाषित करें, जहां प्रत्येक विभाजन में समान तत्व हैं?

मैं स्पार्क के लिए नया हूँ मेरे पास तत्वों का एक बड़ा डाटासेट है [आरडीडी] और मैं इसे तत्वों के क्रम को बनाए रखने के दो बराबर आकार के विभाजनों में विभाजित करना चाहता हूं। मैंने RangePartitioner का उपयोग करने की कोशिश की

 var data = partitionedFile.partitionBy(new RangePartitioner(2, partitionedFile)) 

यह संतोषजनक परिणाम नहीं देता है क्योंकि यह लगभग बांटता है, लेकिन तत्वों के क्रम को बनाए रखने के बराबर समान नहीं है। उदाहरण के लिए अगर वहाँ 64 तत्व हैं, तो हम Rangepartitioner उपयोग Rangepartitioner , फिर यह 31 तत्वों और 33 तत्वों में बांटता है।

मुझे एक पार्टिशनर की ज़रूरत है कि मुझे आधे से पहले 32 तत्व मिलते हैं और दूसरे भाग में 32 तत्वों का दूसरा सेट होता है। क्या आप कृपया अनुकूलित पार्टीशनर का उपयोग करने का सुझाव देकर मेरी सहायता कर सकते हैं, जैसे तत्वों के क्रम को बनाए रखने के लिए मुझे समान रूप से दो हिस्सों का आकार मिलता है?

Solutions Collecting From Web of "स्पार्क RDD के समान आकार के विभाजन के लिए कस्टम विभाजन को कैसे परिभाषित करें, जहां प्रत्येक विभाजन में समान तत्व हैं?"

Partitioner लिए एक कुंजी निर्दिष्ट करके Partitioner कार्य। इस तरह के विभाजनकर्ता को बनाने के लिए आपको कुंजी वितरण के पूर्व ज्ञान की आवश्यकता होगी, या सभी चाबियाँ देखें यही कारण है कि स्पार्क आपको एक के साथ नहीं प्रदान करता है

सामान्य तौर पर आपको ऐसे विभाजनकर्ता की आवश्यकता नहीं है। वास्तव में मैं उपयोग के मामले में नहीं आ सकता, जहां मुझे समान आकार वाले विभाजन की आवश्यकता होगी। यदि तत्वों की संख्या अजीब है तो क्या होगा?

वैसे भी, हम कहते हैं कि आपके पास क्रमिक Ints द्वारा आरडीडी कुंजी लगाई गई है, और आप जानते हैं कि कुल में कितने हैं तब आप इस तरह एक कस्टम Partitioner लिख सकते हैं:

 class ExactPartitioner[V]( partitions: Int, elements: Int) extends Partitioner { def getPartition(key: Any): Int = { val k = key.asInstanceOf[Int] // `k` is assumed to go continuously from 0 to elements-1. return k * partitions / elements } } 

इस उत्तर में डैनियल से कुछ प्रेरणा मिली है, लेकिन लोगों की कॉपी और पेस्ट की जरूरतों के लिए एक उदाहरण के साथ पूर्ण कार्यान्वयन ( दलाल मेरी लाइब्रेरी पैटर्न का उपयोग करके) प्रदान करता है 🙂

 import RDDConversions._ trait RDDWrapper[T] { def rdd: RDD[T] } // TODO View bounds are deprecated, should use context bounds // Might need to change ClassManifest for ClassTag in spark 1.0.0 case class RichPairRDD[K <% Ordered[K] : ClassManifest, V: ClassManifest]( rdd: RDD[(K, V)]) extends RDDWrapper[(K, V)] { // Here we use a single Long to try to ensure the sort is balanced, // but for really large dataset, we may want to consider // using a tuple of many Longs or even a GUID def sortByKeyGrouped(numPartitions: Int): RDD[(K, V)] = rdd.map(kv => ((kv._1, Random.nextLong()), kv._2)).sortByKey() .grouped(numPartitions).map(t => (t._1._1, t._2)) } case class RichRDD[T: ClassManifest](rdd: RDD[T]) extends RDDWrapper[T] { def grouped(size: Int): RDD[T] = { // TODO Version where withIndex is cached val withIndex = rdd.mapPartitions(_.zipWithIndex) val startValues = withIndex.mapPartitionsWithIndex((i, iter) => Iterator((i, iter.toIterable.last))).toArray().toList .sortBy(_._1).map(_._2._2.toLong).scan(-1L)(_ + _).map(_ + 1L) withIndex.mapPartitionsWithIndex((i, iter) => iter.map { case (value, index) => (startValues(i) + index.toLong, value) }) .partitionBy(new Partitioner { def numPartitions: Int = size def getPartition(key: Any): Int = (key.asInstanceOf[Long] * numPartitions.toLong / startValues.last).toInt }) .map(_._2) } } 

फिर एक और फ़ाइल में हमारे पास है

 // TODO modify above to be implicit class, rather than have implicit conversions object RDDConversions { implicit def toRichRDD[T: ClassManifest](rdd: RDD[T]): RichRDD[T] = new RichRDD[T](rdd) implicit def toRichPairRDD[K <% Ordered[K] : ClassManifest, V: ClassManifest]( rdd: RDD[(K, V)]): RichPairRDD[K, V] = RichPairRDD(rdd) implicit def toRDD[T](rdd: RDDWrapper[T]): RDD[T] = rdd.rdd } 

तब आपके उपयोग के मामले के लिए आप बस चाहते हैं (मान लें कि यह पहले ही सॉर्ट किया गया है)

 import RDDConversions._ yourRdd.grouped(2) 

अस्वीकरण: परीक्षण नहीं किया गया है, थोड़े ने इसे सीधे SO उत्तर में लिखा है