Question

我想从Google N-Grams dataset中提取最常用的单词，其未压缩格式约为20 GB。我不想要整个数据集，最常见的5000个。但如果我写

take 5000 $ sortBy (flip $ comparing snd) dataset
-- dataset :: IO [(word::String, frequency::Int)]

这将是一个无休止的等待。但我该怎么做呢？

我知道有Data.Array.MArray包可用于就地数组计算，但我在其文档页面上看不到任何修改项目的功能。还有Data.HashTable.IO，但它是无序的数据结构。

我想使用简单的Data.IntMap.Strict（具有方便的lookupLE功能），但我不认为它会非常有效，因为它会在每个地方生成一个新地图改造。 ST monad可以改善吗？

UPD：我还在CoreReview.SX上发布了最终版本的程序。

Answer 1

怎么样

使用splitAt将数据集划分为前5000个项目和其余部分。
按频率（升序）
完成剩下的工作
- 如果项目的频率高于已排序项目中的最低频率
- 从已排序的项目中删除最低频率项目
- 将新项目插入已排序项目

然后，该过程变为有效线性，但如果对具有次线性min-delete和插入的已排序的5000个元素使用数据结构，则系数会得到改善。

例如，使用Data.Heap from the heap package：

import Data.List (foldl')
import Data.Maybe (fromJust)
import Data.Heap hiding (splitAt)

mostFreq :: Int -> [(String, Int)] -> [(String, Int)]
mostFreq n dataset = final
  where
    -- change our pairs from (String,Int) to (Int,String)
    pairs = map swap dataset
    -- get the first `n` pairs in one list, and the rest of the pairs in another
    (first, rest) = splitAt n pairs
    -- put all the first `n` pairs into a MinHeap
    start = fromList first :: MinHeap (Int, String)
    -- then run through the rest of the pairs
    stop = foldl' step start rest
    -- modifying the heap to replace its least frequent pair
    -- with the new pair if the new pair is more frequent
    step heap pair = if viewHead heap < Just pair
                       then insert pair (fromJust $ viewTail heap)
                       else heap
    -- turn our heap of (Int, String) pairs into a list of (String,Int) pairs
    final = map swap (toList stop)
    swap ~(a,b) = (b,a)

Answer 2

你尝试这个或者你只是猜测？因为许多Haskell排序函数都尊重 laziness ，当你只要求前5000名时，他们会很乐意避免对其余元素进行排序。

同样，要非常小心＆＃34;它会在每次更改时生成一张新地图＆＃34;。在这种数据结构中，大多数插入操作都是O（log n），n限制为5000：所以你可能会在每次更改时在堆中分配~30个新单元格，但这不是特别的巨大的成本，肯定不会像5000那么大。

如果Data.List.sort不能很好地运作，那么您需要的是：

import Data.List (foldl')
import Data.IntMap.Strict (IntMap)
import qualified Data.IntMap.Strict as IM

type Freq = Int
type Count = Int
data Summarizer x = Summ {tracking :: !IntMap [x], least :: !Freq, 
                        size :: !Count, size_of_least :: !Count }

inserting :: x -> Maybe [x] -> Maybe [x]
inserting x Nothing = Just [x]
inserting x (Just xs) = Just (x:xs)

sizeLimit :: Summarizer x -> Summarizer x
sizeLimit skip@(Summ strs f_l tot lst) 
    | tot - lst < 5000 = skip
    | otherwise        = Summ strs' f_l' tot' lst'
        where (discarded, strs') = IM.deleteFindMin strs
              (f_l', new_least) = IM.findMin dps'
              tot' = tot - length discarded
              lst' = length new_least

addEl :: (x, Freq) -> Summarizer x -> Summarizer x
addEl (str, f) skip@(Summ strs f_l tot lst)
    | i < f_l && tot >= 5000 = skip
    | otherwise              = sizeLimit $ Summ strs' f_l' tot' lst'
        where strs' = IM.alter (inserting str) f strs
              tot' = tot + 1
              f_l' = min f_l f
              lst' = case compare f_l f of LT -> lst; EQ -> lst + 1; GT -> 1

请注意，我们存储字符串列表以处理重复频率;我们主要是跳过更新，当我们做更新时，它会进行O（log n）操作以将新元素放入，有时（再次依赖于重复）操作O（log n）操作删除最小的元素，以及O（log n）操作以找到新的最小元素。

最有效的数据结构，用于查找最常见的项目

2 个答案: