[SCALA] 스파크 : RDD 모든 가능한 조합의 생산 RDD [(X, X)] [X]

스파크 : RDD 모든 가능한 조합의 생산 RDD [(X, X)] [X]

그것은 스칼라 컬렉션에서 '.combinations'기능을 구현하는 불꽃의 수 있습니까?

   /** Iterates over combinations.
   *
   *  @return   An Iterator which traverses the possible n-element combinations of this $coll.
   *  @example  `"abbbc".combinations(2) = Iterator(ab, ac, bb, bc)`
   */

예를 들어 어떻게 크기 = 2의 조합 RDD에 RDD [X] [X] 목록 [] 또는 RDD [(X, X)]에서 얻을 그리고 RDD의 모든 값이 고유하다고 가정 할 수 있습니다.

해결법

1. ==============================

   1.데카르트의 제품과 조합은 두 개의 서로 다른 것들, 크기 rdd.size의 RDD을 만듭니다 ^ 2 조합 크기 rdd.size ()의 RDD을 생성합니다 데카르트 제품은 () 2를 선택

   데카르트의 제품과 조합은 두 개의 서로 다른 것들, 크기 rdd.size의 RDD을 만듭니다 ^ 2 조합 크기 rdd.size ()의 RDD을 생성합니다 데카르트 제품은 () 2를 선택

   val rdd = sc.parallelize(1 to 5)
   val combinations = rdd.cartesian(rdd).filter{ case (a,b) => a < b }`.
   combinations.collect()
   

   순서화는리스트의 요소에 정의 된 경우 우리가 사용하기 때문에 <본 것입니다 만 일을합니다. 이 사람은 두 개의 선택을위한 작동하지만 쉽게 순서대로 확인 관계은

2. ==============================

   2.이 직교 변환과 스파크 RDD가 기본적으로 지원된다.

   이 직교 변환과 스파크 RDD가 기본적으로 지원된다.

   예 :. :

   val rdd = sc.parallelize(1 to 5)
   val cartesian = rdd.cartesian(rdd)
   cartesian.collect
   
   Array[(Int, Int)] = Array((1,1), (1,2), (1,3), (1,4), (1,5), 
   (2,1), (2,2), (2,3), (2,4), (2,5), 
   (3,1), (3,2), (3,3), (3,4), (3,5), 
   (4,1), (4,2), (4,3), (4,4), (4,5), 
   (5,1), (5,2), (5,3), (5,4), (5,5))
   

3. ==============================

   3.논의 된 바와 같이, 데카르트는 자체로 RDD의 직교 제품의 ^ 2 개 요소 N을 줄 것이다. 이 알고리즘은 먼저 N ^ 2 개 요소를 계산하지 않고도 RDD의 조합 (N, 2) 계산 (타입 T로 일반화 입력으로 문자열을 사용하여 현재 목적을 모호 할 classtags 일부 배관 소요)

   논의 된 바와 같이, 데카르트는 자체로 RDD의 직교 제품의 ^ 2 개 요소 N을 줄 것이다. 이 알고리즘은 먼저 N ^ 2 개 요소를 계산하지 않고도 RDD의 조합 (N, 2) 계산 (타입 T로 일반화 입력으로 문자열을 사용하여 현재 목적을 모호 할 classtags 일부 배관 소요)

   이 직교 + 인해 반복 카운트 필터링 힘 상기 RDD의 계산을하지만, 더 효율적인 공간은 (N, 2) = N! / (2 * (N 만 C를 계산로한다는 작업을 수행하는 것이 아마도 짧은 시간 효율적인 -2))! = (N * (N-1) / 2) 요소 대신 직교 제품의 N ^ 2.

    import org.apache.spark.rdd._
   
    def combs(rdd:RDD[String]):RDD[(String,String)] = {
       val count = rdd.count
       if (rdd.count < 2) { 
           sc.makeRDD[(String,String)](Seq.empty)
       } else if (rdd.count == 2) {
           val values = rdd.collect
           sc.makeRDD[(String,String)](Seq((values(0), values(1))))
       } else {
           val elem = rdd.take(1)
           val elemRdd = sc.makeRDD(elem)
           val subtracted = rdd.subtract(elemRdd)  
           val comb = subtracted.map(e  => (elem(0),e))
           comb.union(combs(subtracted))
       } 
    }
   

4. ==============================

   4.이것은 RDD의 요소에 대한 순서없이 어떤 RDD에 대한 모든 조합 (N, 2) 작품을 만듭니다.

   이것은 RDD의 요소에 대한 순서없이 어떤 RDD에 대한 모든 조합 (N, 2) 작품을 만듭니다.

   val rddWithIndex = rdd.zipWithIndex
   rddWithIndex.cartesian(rddWithIndex).filter{case(a, b) => a._2 < b._2}.map{case(a, b) => (a._1, b._1)}
   

   a._1 및 b._1 원래 RDD 요소 동안 a._2 및 b._2는 인덱스이다.

   예:

   (가) 여기지도에서 그 주, 어떤 순서가 정의되지 않습니다.

   val m1 = Map('a' -> 1, 'b' -> 2)
   val m2 = Map('c' -> 3, 'a' -> 4)
   val m3 = Map('e' -> 5, 'c' -> 6, 'b' -> 7)
   val rdd = sc.makeRDD(Array(m1, m2, m3))
   val rddWithIndex = rdd.zipWithIndex
   rddWithIndex.cartesian(rddWithIndex).filter{case(a, b) => a._2 < b._2}.map{case(a, b) => (a._1, b._1)}.collect
   

   산출:

   Array((Map(a -> 1, b -> 2),Map(c -> 3, a -> 4)), (Map(a -> 1, b -> 2),Map(e -> 5, c -> 6, b -> 7)), (Map(c -> 3, a -> 4),Map(e -> 5, c -> 6, b -> 7)))
   

from https://stackoverflow.com/questions/26557873/spark-produce-rddx-x-of-all-possible-combinations-from-rddx by cc-by-sa and MIT license