Haskell堆栈溢出

Question

我正在编写一种遗传算法来生成字符串“ helloworld”。 但是当n为10,000或更大时，evolve函数会产生堆栈溢出。

module Genetics where

import Data.List (sortBy)
import Random (randomRIO)
import Control.Monad (foldM)

class Gene g where
    -- How ideal is the gene from 0.0 to 1.0?
    fitness :: g -> Float

    -- How does a gene mutate?
    mutate :: g -> IO g

    -- How many species will be explored?
    species :: [g] -> Int

orderFitness :: (Gene g) => [g] -> [g]
orderFitness = reverse . sortBy (\a b -> compare (fitness a) (fitness b))

compete :: (Gene g) => [g] -> IO [g]
compete pool = do
    let s = species pool
    variants <- (mapM (mapM mutate) . map (replicate s)) pool
    let pool' = (map head . map orderFitness) variants
    return pool'

evolve :: (Gene g) => Int -> [g] -> IO [g]
evolve 0 pool = return pool
evolve n pool = do
    pool' <- compete pool
    evolve (n - 1) pool'

species pool = 8 ，由8个基因组成的库将复制到8个组中。 每组发生突变，并选择每组的最适体进行进一步进化（返回8个基因）。

的GitHub

Answer 1

如果您对性能感兴趣，可以使用快速随机数生成器，例如：

• mersenne-random软件包

其次，尽管看起来有些庞大的结构，但是compete看起来非常可疑，因为它完全是懒惰的。 尝试使用deepseq锤将其重写为更严格一点 ：

import Control.DeepSeq    

compete :: (Gene g, NFData g) => [g] -> IO [g]
compete pool = do
    let s = species pool
    variants <- (mapM (mapM mutate) . map (replicate s)) pool
    let pool' = (map head . map orderFitness) variants
    pool' `deepseq` return pool'

不过，这些东西都不需要放在IO中（单独的问题）。 像Rand monad这样的东西可能更适合 。

Answer 2

多亏了Don的deepseq建议，我得以将问题缩小到mapM mutate ，这导致了太多的问题。 新版本具有mutate' ，它使用seq防止变形。

module Genetics where

import Data.List (maximumBy)
import Random (randomRIO)

class Gene g where
    -- How ideal is the gene from 0.0 to 1.0?
    fitness :: g -> Float

    -- How does a gene mutate?
    mutate :: g -> IO g

    -- How many species will be explored in each round?
    species :: [g] -> Int

best :: (Gene g) => [g] -> g
best = maximumBy (\a b -> compare (fitness a) (fitness b))

-- Prevents stack overflow
mutate' :: (Gene g) => g -> IO g
mutate' gene = do
    gene' <- mutate gene
    gene' `seq` return gene'

drift :: (Gene g) => [[g]] -> IO [[g]]
drift = mapM (mapM mutate')

compete :: (Gene g) => [g] -> IO [g]
compete pool = do
    let islands = map (replicate (species pool)) pool
    islands' <- drift islands
    let representatives = map best islands'
    return representatives

evolve :: (Gene g) => Int -> [g] -> IO [g]
evolve 0 pool = return pool
evolve n pool = compete pool >>= evolve (n - 1)

的GitHub

Answer 3

代替使用orderFitness是sortBy (map head . map orderFitness) ，您可以使用maximumBy和一个map 。 这样做并不会节省太多（因为您是从O（n log n）到O（n），并且可能会从消除双重映射中得到另一个因子2），但是至少在某种程度上更简单，更有效。 您还将摆脱对反向调用的要求。

我怀疑这是否可以解决deepseq问题，但是仍然应该是一个改进。

编辑：如果标准库和GHC是完美的，则head . sortBy head . sortBy将产生与maximumBy和map head . map sortBy相同的代码map head . map sortBy 不幸的是， map head . map sortBy将产生相同的代码来map (head . sortBy) ，但实际上这两种情况都不是真的。 sortBy往往会做大量额外的内存分配，因为它是分而治之的算法。 组合地图有时是一种优化，但不应指望。

更重要的是，使用maximumBy更具声明性。 可以很容易地看到代码的功能以及所需的时间。 利用优化也应该更容易，因为我们知道目标是什么，而不仅仅是我们如何实现它。