Php 我的GAHelloWorld实现中的逻辑有什么问题？

我有一个时间表生成任务，根据，它可以通过遗传算法来解决

我通过谷歌搜索找到了许多非常有用的文献和两个“Hello World！”的例子。到目前为止，我已经尝试将它们翻译成php，并重新封装，使代码可用于我未来的任务

下面是一系列例子的链接（抱歉，最后一个是关于俄语的，但是，这里的代码可能有用）

以下是我的实现：

<?php    
abstract class Creature
    {
        protected $fitness;

        public function __construct()
            {
                $this->fitness = 0;
            }

        public function getFitness()
            {
                return $this->fitness;
            }

        abstract public function calculateFitness();

        public function compareTo($creature)
            {
                return $this->fitness - $creature->fitness;
            }

        abstract public function mateWith($creature);

        abstract public function mutate();
    }

abstract class Population
    {
        protected $creatures;
        protected $generation;

        public function __construct()
            {
                $this->creatures    = array();
                $this->generation   = 1;

                $this->populate();
            }

        public function __destruct()
            {
                unset($this->creatures);
            }

        public function get($index)
            {
                return isset($this->creatures[$index]) ? $this->creatures[$index] : null;
            }

        public function getCount()
            {
                return count($this->creatures);
            }

        public function getGeneration()
            {
                return $this->generation;
            }

        abstract protected function populate();

        public function sort($order = SORT_ASC)
            {
                switch($order)
                    {
                        case SORT_ASC:
                            $fn = function($c1, $c2){ return $c1->compareTo($c2); };
                        break;

                        case SORT_DESC:
                            $fn = function($c1, $c2){ return $c2->compareTo($c1); };
                        break;

                        default: return false;
                    }

                return usort($this->creatures, $fn);
            }

        public function select(array $params)
            {
                $result = false;

                if(isset($params['top']))
                    {
                        $length = round(abs($this->getCount() * $params['top']) / 100);

                        $this->creatures = array_slice($this->creatures, 0, $length);

                        $result = true;
                    }

                if(isset($params['fn']) && is_callable($params['fn']))
                    {
                        $this->creatures = array_filter($this->creatures, $params['fn']);

                        $result = true;
                    }

                return $result;
            }

        public function breed()
            {
                $candidates = $this->creatures;

                shuffle($candidates);

                $candidates = array_chunk($candidates, 2);
                $result     = 0;

                foreach($candidates as &$pair)
                    {
                        if(count($pair) < 2)continue;

                        list($mother, $father) = $pair;

                        $children = $mother->mateWith($father);

                        $result += count($children);

                        $this->creatures = array_merge($this->creatures, $children);
                    }

                $this->generation++;

                return $result;
            }
    }

class HWCreature extends Creature
    {
        protected $string;

        protected function randChar()
            {
                return chr(rand(0, 255));
            }

        protected function fill()
            {
                $length = strlen(Algorithm::TARGET);

                for($i = 0; $i < $length; $i++)
                    {
                        $this->string .= $this->randChar();
                    }
            }

        public function __construct($fill = true)
            {
                parent::__construct();

                $this->string = '';

                if(!$fill)return;

                $this->fill();
                $this->calculateFitness();
            }

        public function __toString()
            {
                return $this->string;
            }

        public function calculateFitness()
            {
                $length = strlen($this->string);
                $target = Algorithm::TARGET;

                for($i = 0; $i < $length; $i++)
                    {
                        $this->fitness += abs(ord($this->string[$i]) - ord($target[$i]));
                    }
            }

        public function mateWith($creature)
            {
                $length = strlen(Algorithm::TARGET) - 1;
                $place  = rand(0, $length);

                $child1 = new self(false);
                $child1->string = substr($this->string, 0, $place) . substr($creature->string, $place);
                $child1->mutate();
                $child1->calculateFitness();

                $child2 = new self(false);
                $child2->string = substr($creature->string, 0, $place) . substr($this->string, $place);
                $child2->mutate();
                $child2->calculateFitness();

                return array($child1, $child2);
            }

        public function mutate()
            {
                if(rand(1, 100) > Algorithm::MUTATION_RATE)return;

                $char   = $this->randChar();
                $length = strlen(Algorithm::TARGET);
                $place  = rand(0, $length - 1);

                $this->string = substr_replace($this->string, $char, $place, 1);
            }
    }

class HWPopulation extends Population
    {
        protected function populate()
            {
                for($i = 0; $i < Algorithm::POPULATION_SIZE; $i++)
                    {
                        $this->creatures[] = new HWCreature();
                    }
            }
    }

class Algorithm
    {
        const POPULATION_SIZE   = 100; // 1000 in my original test
        const ELITE_RATE        = 50; // %
        const MUTATION_RATE     = 25; // %
        const MAX_GENERATIONS   = 1000;

        const TARGET    = 'Hello World!';

        protected $population;

        public function __construct()
            {
                $this->population = new HWPopulation();
            }

        public function __destruct()
            {
                unset($this->population);
            }

        public function __invoke()
            {
                do
                    {
                        $generation = $this->population->getGeneration();
                        $representer    = $this->population->get(0);

                        echo sprintf(
                                'gen %d > %s',
                                $generation, $representer
                            ),
                            '<br>',
                            PHP_EOL;

                        if($representer == self::TARGET)break;

                        $selector = array('top' => self::ELITE_RATE);

                        $this->population->sort();
                        $this->population->select($selector);
                        $this->population->breed();
                    }
                while($generation < self::MAX_GENERATIONS);
            }
    }

$algorithm = new Algorithm();
$algorithm();
unset($algorithm);
?>

所以，看起来效率非常低。我相信，问题可能在于选择或繁殖策略。。。我完全迷路了

请任何人解释一下，为什么会这样？另外，我只与基因/生物精英群体交配，这是不是做错了什么

---

任何帮助都将不胜感激。

对于调试/测试，至少您可能需要长时间运行该算法，因此您应该在php.ini中增加

max\u execution\u time

的值（或使用该函数）

代码中的术语似乎有些混乱。从非常简短的一瞥来看，你似乎没有实施精英主义。你似乎拥有的是。这样选择父母是错误的吗？它通常是次优的，因为它完全抛弃了较弱的候选者，这些候选者虽然自身不可行，但可能包含可能有助于最终解决方案的遗传物质。在这个简单的例子中，这可能并不重要，但一般来说，您可能会发现一个更有效的方法，例如轮盘赌轮选择。这种策略有利于更强的个体，但允许较弱的候选人被选为父母

若你们想实行精英主义，你们应该将未经修改的精英候选者复制到下一代，然后通过从整个当代（包括精英个体）中选择父母来繁育这一代的其余部分。通过精英主义保留下来的候选人比例应该在5%左右（你可以通过实验找到最佳比例）

其他一些意见：

如果降低变异概率，也可能得到更好的结果。太多的变异会毁掉优秀的个体

你的适应度函数似乎关心每个字母的接近程度（即，如果第一个字母是“G”，则得分为1，而“M”则得分为5）。然而，你的变异函数不太复杂，只是随机替换字母，所以无论字母之间有多近都无关紧要（一个“X”和一个“G”一样有可能被一个“H”替换）。如果你不打算改变变异，将字母改为字母表中相邻的字母，那么把每个字母都记为1（错误）或0（正确）可能更简单、更有效

---

你能再解释一下输出吗，我是说“HfkkoWotlc！”。上一代的产量相同吗？@AkashdeepSaluja是的。当适合度在8到20之间时，搜索不知何故会停止。结果应该等于string

Hello World。就我而言，一千代人都找不到它。然而，在我作为链接提供的java示例中，50代就足够了。谢谢。我会考虑所有这些。至于最大执行时间，这不是问题，因为我将在后台执行它。不过，以后应该会非常优化。再次感谢您。这是一个非常有用的链接，你在那里提供的。我刚刚改变了配置，适应度函数和排序顺序，正如你所建议的，它在第25代中找到了字符串。
...
gen 739 > HfkkoWotlc!
gen 740 > HfkkoWotlc!
gen 741 > HfkkoWotlc!
gen 742 > HfkkoWotlc!
gen 743 > HfkkoWotlc!
gen 744 > HfkkoWotlc!
gen 745 > HfkkoWotlc!

Fatal error: Maximum execution time of 30 seconds exceeded in {script} on line 126