Question

我需要一份有偏见的随机布尔值列表。每个布尔值都需要具有相同的True概率（伯努利分布式）。这些布尔值传递给一个函数，该函数每个输入布尔值产生零个或多个输出布尔值。我需要一个无限的列表，因为我事先并不知道需要多少布尔才能提供足够的输出。请参阅以下（简化）代码：

import System.Random.MWC
import System.Random.MWC.Distributions

foo :: [Bool] -> [Bool] -- foo outputs zero or more Bools per input Bool

main = do
  gen <- create
  bits <- sequence . repeat $ bernoulli 0.25 gen
  print . take 32 . foo $ bits

不幸的是，此代码只挂在main的第二行。我想在Control.Monad.ST的某个地方发生了一些非懒惰的事情？

（我可以使用System.Random.randoms执行此类操作，但结果值不具备所需的分配。）

我可以在继续使用System.Random.MWC库时修复此问题吗？或者这是否需要我切换到其他实现？

Answer 1

mwc-random个包提供了两个PrimMonad个实例，一个用于IO，另一个用于ST s。只要在所有状态标记ST上参数化s计算，我们就可以运行计算并使用runST :: (forall s. ST s a) -> a提取值。由于我们失去了状态：随机生成器的种子，但这本身并不是非常有用，但mwc-random也为handle the seeds提供了明确的方法：

save :: PrimMonad m => Gen (PrimState m) -> m Seed
restore :: PrimMonad m => Seed -> m (Gen (PrimState m))

只要生成器在forall s. ST s中，我们就可以使用这些来计算从生成单个值的计算生成值流。

{-# LANGUAGE RankNTypes #-}
{-# LANGUAGE ScopedTypeVariables #-}

import System.Random.MWC
import Control.Monad.ST
import System.Random.MWC.Distributions

randomStream :: forall s a. (forall s. GenST s -> ST s a) -> GenST s -> ST s [a]
randomStream item = go
    where
        go :: forall s. GenST s -> ST s [a]
        go gen = do
            x <- item gen
            seed <- save gen
            return (x:runST (restore seed >>= go))

有了这个，我们可以把你的例子写成

main = do
    bits <- withSystemRandom (randomStream (bernoulli 0.25))
    print . take 32 $ bits

我们实际上可以为流中的每个项目构建比使用相同生成器更复杂的生成器。我们可以沿流线程化一个状态，这样每个值都可以取决于之前的值。

unfoldStream :: forall s a b. (forall s. b -> GenST s -> ST s (a, b)) -> b -> GenST s -> ST s [a]
unfoldStream item = go
    where
        go :: forall s. b -> GenST s -> ST s [a]
        go b gen = do
            (x,b') <- item b gen
            seed <- save gen
            return (x:runST (restore seed >>= go b'))

以下示例流的结果在每次结果False时都会增加。

import Control.Monad.Primitive

interesting :: (PrimMonad m) => Double -> Gen (PrimState m) -> m (Bool, Double)
interesting p gen = do
    result <- bernoulli p gen
    let p' = if result then p else p + (1-p)*0.25
    return (result, p')

main = do
    bits <- withSystemRandom (unfoldStream interesting 0)
    print . take 32 $ bits

Answer 2

罪魁祸首是sequence . repeat - 这会挂起（几乎？）每个monad，因为你必须执行潜在的无限数量的效果。

最简单的解决方案是使用不同的库 - 如果您依赖于mwc-random生成的数字的质量，这可能是不可能的。下一个最简单的解决方案是重写foo以使其类型[IO Bool] -> IO [Bool]并将其传递给repeat (bernoulli 0.25 gen) - 这将允许foo选择何时停止执行由无限的清单。但是你在IO内部的逻辑并不是很好。

当您需要无限的随机数列表时，标准技巧是使用纯函数f :: StdGen -> (Result, StdGen)。然后是unfoldr (Just . f) :: StdGen -> [Result]，输出是无限列表。乍一看，似乎mwc-random只有monadic函数，并且没有纯接口。但是，情况并非如此，因为ST s是PrimMonad的实例。您还拥有将Gen转换为Seed的功能。使用这些，您可以获得任何monadic的RNG功能：

{-# LANGUAGE RankNTypes #-}

import System.Random.MWC
import System.Random.MWC.Distributions 
import Control.Monad.ST 
import Data.List 

pureRand :: (forall s . GenST s -> ST s t) -> Seed -> (t, Seed) 
pureRand f s = runST $ do 
  s'  <- restore s
  r   <- f s' 
  s'' <- save s' 
  return (r, s'')

pureBernoulli :: Double -> Seed -> (Bool, Seed)
pureBernoulli a = pureRand (bernoulli a) 

foo :: [Bool] -> [Bool]
foo = id 

main = do
  gen <- create >>= save
  let bits = unfoldr (Just . pureBernoulli 0.25) gen 
  print . take 32 . foo $ bits

不幸的是，默认情况下mwc-random没有公开这种界面，但很容易到达。

另一个选项稍微有点吓人 - 使用不安全的功能。

import System.IO.Unsafe

repeatM rand = go where
  go = do
    x  <- rand
    xs <- unsafeInterleaveIO go
    return (x : xs)

main2 = do
  gen <- create
  bits <- repeatM (bernoulli 0.25 gen) 
  print . take 32 . foo $ bits

当然，这伴随着围绕unsafe的常见警告 - 只有当您对纯粹的功能极为不便时才使用它。 unsafeInterleaveIO可能会重新排序或从不执行效果 - 例如，如果foo忽略一个元素，则永远不会计算它，并且更新gen中存储的状态的相应效果可能不会发生。例如，以下内容将不会打印任何内容：

snd <$> ((,) <$> unsafeInterleaveIO (putStrLn "Hello") <*> return ())

Haskell无限列表伯努利分布的布尔值

2 个答案: