关于scala：Spark：在(键，值)RDD中获取每个键的前K个频繁值的有效方法？


Spark: Efficient way to get top K frequent values per key in (key, value) RDD?

我有一个 (key, value) 对的 RDD。我需要根据每个键的频率获取前 k 个值。

我知道最好的方法是使用 combineByKey。

目前这里是我的 combineByKey 组合器的样子

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
object TopKCount {
    //TopK Count combiners
    val k: Int = 10
    def createCombiner(value: String): Map[String, Long] = {
      Map(value -> 1L)
    }
    def mergeValue(combined: Map[String, Long], value: String): Map[String, Long] = {
      combined ++ Map(value -> (combined.getOrElse(value, 0L) + 1L))
    }
    def mergeCombiners(combined1: Map[String, Long], combined2: Map[String, Long]): Map[String, Long] = {
      val top10Keys1 = combined1.toList.sortBy(_._2).takeRight(k).toMap.keys
      val top10Keys2 = combined2.toList.sortBy(_._2).takeRight(k).toMap.keys

      (top10Keys1 ++ top10Keys2).map(key => (key, combined1.getOrElse(key, 0L) + combined2.getOrElse(key, 0L)))
        .toList.sortBy(_._2).takeRight(k).toMap
    }
  }

我是这样使用的：

1
2
3
4
5
6
// input is RDD[(String, String)]
 val topKValueCount: RDD[(String, Map[String, Long])] = input.combineByKey(
      TopKCount.createCombiner,
      TopKCount.mergeValue,
      TopKCount.mergeCombiners
    )

对当前代码的一个优化是在 mergeCombiners 期间使用 min-queue。

我更关心网络 I/O。是否有可能一旦我在一个分区中进行合并，我只将这个分区中的 topK 条目发送到驱动程序，而不是发送整个 Map，我在当前情况下正在这样做。

非常感谢任何反馈。

相关讨论

我已经能够令人满意地解决这个问题，如下所示。诀窍是将问题分成两部分，在第一部分将键及其值组合在一起，以获取相同 k，v 发生的次数，然后将其与新的 topk 组合器一起使用以获取发生的 topk价值观。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
case class TopKCount(topK: Int = 10) {

  //sort and trim a traversable (String, Long) tuple by _2 value of the tuple
  def topNs(xs: TraversableOnce[(String, Long)], n: Int) = {
    var ss = List[(String, Long)]()
    var min = Long.MaxValue
    var len = 0
    xs foreach { e =>
      if (len < n || e._2 > min) {
        ss = (e :: ss).sortBy((f) => f._2)
        min = ss.head._2
        len += 1
      }
      if (len > n) {
        ss = ss.tail
        min = ss.head._2
        len -= 1
      }
    }
    ss
  }

  //seed a list for each key to hold your top N's with your first record
  def createCombiner(value: (String, Long)): Seq[(String, Long)] = Seq(value)

  //add the incoming value to the accumulating top N list for the key
  def mergeValue(combined: Seq[(String, Long)], value: (String, Long)): Seq[(String, Long)] =
    topNs(combined ++ Seq((value._1, value._2)), topK)

  //merge top N lists returned from each partition into a new combined top N list
  def mergeCombiners(combined1: Seq[(String, Long)], combined2: Seq[(String, Long)]): Seq[(String, Long)] =
    topNs(combined1 ++ combined2, topK)
}

object FieldValueCount {
  //Field Value Count combiners
  def createCombiner(value: String): (Double, Long) =
    if (Try(value.toDouble).isSuccess) (value.toDouble, 1L)
    else (0.0, 1L)

  def mergeValue(combined: (Double, Long), value: String): (Double, Long) =
    if (Try(value.toDouble).isSuccess) (combined._1 + value.toDouble, combined._2 + 1L)
    else (combined._1, combined._2 + 1L)

  def mergeCombiners(combined1: (Double, Long), combined2: (Double, Long)): (Double, Long) =
    (combined1._1 + combined2._1, combined1._2 + combined2._2)
}

// Example usage. Here input is the RDD[(String, String)]
val topKCount = TopKCount(10)

input.cache()

// combine the k,v from the original input to convert it into (k, (v, count))
val combined: RDD[(String, (String, Long))] = input.map(v => (v._1 +"|" + v._2, 1L))
  .reduceByKey(_ + _).map(k => (k._1.split("\\\\|", -1).head, (k._1.split("\\\\|", -1).drop(1).head, k._2)))

val topKValueCount: RDD[(String, Seq[(String, Long)])] = combined.combineByKey(
  topKCount.createCombiner,
  topKCount.mergeValue,
  topKCount.mergeCombiners
)

TopKCount 已转换为案例类，以便我们可以根据需要更改 k 的值。如果 k 不需要是可变的，它可以作为一个对象。

为什么不使用 Spark 的 RDD GroupByKey 功能或 GroupBy？如果您使用大型 RDD，使用 Spark 功能几乎总是更快，对吧？

1
2
//assuming input is RDD[(String, String)]
val groupinput = input.groupBy(_._2).map(x=>(x._1,x._2.map(y=>y._2).groupBy(identity).map(z=>(z._1,z._2.size)).toList.sortBy(-_._2)))

这条紧凑的 1 行应该可以满足您的需求。该行首先按您的键对 RDD 进行分组，输出 RDD(keys, Map(Key,values))。现在第二个 GroupBy 对 Mapping 的值进行分组，并输出这些值在新 Map 中出现的频率。

最后，我将地图转换为列表(使用数组或任何您认为合适的东西)并按计数(或频率)排序。所以你有一个

的 RDD

1
RDD[(key, List[(value, frequency)])]

现在您可以在 List 上使用 take(k) 来获得 k 个最频繁的值。

相关讨论