如何在 Scala 中编写一个高效的 groupBy-size 过滤器，可以是近似的

Question

给定 Scala 中的 List[Int]，我希望得到所有 Int 中至少出现 thresh 次的 Set[Int]。我可以使用 groupBy 或 foldLeft，然后使用 filter。例如：

val thresh = 3
val myList = List(1,2,3,2,1,4,3,2,1)
myList.foldLeft(Map[Int,Int]()){case(m, i) => m + (i -> (m.getOrElse(i, 0) + 1))}.filter(_._2 >= thresh).keys

会给Set(1,2).

现在假设 List[Int] 非常大。很难说有多大，但无论如何这看起来很浪费，因为我不关心每个 Int 的频率，我只关心它们是否至少为 thresh。一旦通过 thresh 就不需要再检查了，只需将 Int 添加到 Set[Int].

问题是：对于非常大的 List[Int]、

，我能否更有效地执行此操作？

a) 如果我需要真实、准确的结果（不允许出错）

b) 如果结果可以是近似的，例如通过使用一些散列技巧或布隆过滤器，其中 Set[Int] 可能包含一些误报，或者 {Int > thresh} 的频率是否真的不是 Boolean 但 Double 在 [0-1].

Answer 1

您可以使用增量构建的 mutable.Set 稍微更改 foldLeft 示例，同时使用 [=15] 作为过滤器迭代 Seq =].但是，因为我使用的是 withFilter，所以我不能使用 foldLeft，必须使用 foreach 和一个可变映射：

import scala.collection.mutable

def getItems[A](in: Seq[A], threshold: Int): Set[A] = {
  val counts: mutable.Map[A, Int] = mutable.Map.empty
  val result: mutable.Set[A] = mutable.Set.empty

  in.withFilter(!result(_)).foreach { x =>
    counts.update(x, counts.getOrElse(x, 0) + 1)

    if (counts(x) >= threshold) {          
      result += x
    }
  }
  result.toSet
}

因此，这将丢弃在运行到 Seq 时已经添加到结果集中的项目，因为 withFilter 过滤了 Seq在附加函数中 (map, flatMap, foreach) 而不是返回过滤后的 Seq.

编辑：

我更改了我的解决方案以不使用 Seq.count，这是愚蠢的，正如 Aivean 正确指出的那样。

使用 Aiveans microbench 我可以看到它仍然比他的方法慢一点，但仍然比作者的第一种方法好。

Authors solution
377
Ixx solution: 
399
Ixx solution2 (eliminated excessive map writes): 
110
Sascha Kolbergs solution: 
72
Aivean solution: 
54

Answer 2

您可以使用 foldleft 来收集匹配的项目，如下所示：

val tuple = (Map[Int,Int](), List[Int]())
myList.foldLeft(tuple) {
  case((m, s), i) => {
    val count = (m.getOrElse(i, 0) + 1) 
    (m + (i -> count), if (count == thresh) i :: s else s)
  }
}

我可以用一个小列表测量大约 40% 的性能改进，所以这绝对是一个改进...

编辑为使用 List 和前置，这需要恒定的时间（见评论）。

Answer 3

首先，您不能比 O(N) 做得更好，因为您需要至少检查一次初始数组的每个元素。您当前的方法是 O(N)，假设使用 IntMap 的操作实际上是恒定的。

现在你可以尝试什么来提高效率：

仅当当前计数器值小于或等于阈值时才更新地图。这将消除大量最昂贵的操作——地图更新
尝试使用更快的地图而不是 IntMap。如果您知道初始 List 的值在固定范围内，则可以使用 Array 而不是 IntMap （索引作为键）。另一个可能的选项是具有足够初始容量的可变 HashMap。正如我的基准测试所示，它实际上产生了显着差异
正如@ixx 所建议的那样，在递增地图中的值后，检查它是否等于 3，在这种情况下，立即将其添加到结果列表中。这将为您节省一次线性遍历（对于大输入似乎没有那么重要）

我看不出有什么近似解可以更快（只有当你随机忽略一些元素时）。否则还是O(N).

更新

我创建了微基准测试来衡量不同实现的实际性能。对于足够大的输入和输出，Ixx 关于立即将元素添加到结果列表的建议不会产生显着的改进。然而，可以使用类似的方法来消除不必要的 Map 更新（这似乎是最昂贵的操作）。

基准测试结果（预热后 1000000 个元素平均运行次）：

Authors solution:
447 ms
Ixx solution:
412 ms
Ixx solution2 (eliminated excessive map writes):
150 ms
My solution:
57 ms

我的解决方案涉及使用可变 HashMap 而不是不可变 IntMap 并包括所有其他可能的优化。

Ixx 的更新解决方案：

val tuple = (Map[Int, Int](), List[Int]())
val res = myList.foldLeft(tuple) {
  case ((m, s), i) =>
    val count = m.getOrElse(i, 0) + 1
    (if (count <= 3) m + (i -> count) else m, if (count == thresh) i :: s else s)
}

我的解决方案：

val map = new mutable.HashMap[Int, Int]()
val res = new ListBuffer[Int]
myList.foreach {
  i =>
    val c = map.getOrElse(i, 0) + 1
    if (c == thresh) {
      res += i
    }
    if (c <= thresh) {
      map(i) = c
    }
}

完整的微基准源可用 here。

Answer 4

如果 "more efficiently" 你的意思是 space 效率（在极端情况下列表是无限的），有一个叫做 Count Min Sketch 的概率数据结构来估计里面项目的频率它。然后你可以丢弃那些频率低于你的阈值的。

Algebird 库中有一个 Scala 实现。

如何在 Scala 中编写一个高效的 groupBy-size 过滤器，可以是近似的

How to write an efficient groupBy-size filter in Scala, can be approximate

scala

group-by

bloom-filter

foldleft