遗传算法入门(转载)

来源: http://blog.csdn.net/bravetmac/article/details/4326275

 

遗传算法入门

(连载之一)

.

扎自<游戏编程中的人工智能技术>第三章 

(美）Mat Buckland 著

吴祖增 沙 鹰 译

．

清华大学出版社出版

生物只有经过许多世代的不断演化（evolution），才能更好地完成生存与繁衍的任务。遗传算法也遵循同样的方式，需要随着时间的推移不断成长、演化，最后才能收敛，得到针对某类特定问题的一个或多个解。因此，了解一些有关有生命的机体如何演化的知识，对理解遗传算法的演化机制是是有帮助的。本章的开始几页将扼要阐述自然演化的机制（通常称为“湿”演化算法），以及与之相关的术语。即使你当年在中学里对生物并不擅长，也无须担心。本章不会涉及到过深的细节，但对于理解自然演化的基本机制已经足够。抛开以上不论，当你读完本章或下一章后，我想，你也会和我一样，深深叹服自然母亲的令人着迷！ 

。。从本质上说，任何生物机体不过就是一大堆细胞的集合。每个细胞都包含若干组相同的DNA链，人们一般称之为染色体（chromosome）。染色体中包含的DNA分为两股，这两股DNA链以螺旋状绞合在一起，如下面图3.1所示那样，这就是我们所熟悉的DNA双螺旋结构模型。 

图 3.1.. DNA双螺旋结构  

。。单个的染色体是由称作基因（gene）的更小的结构模块组成，而基因则又由称作核苷酸（nucleotide）的物质组成。核苷酸一共只有四种类型，即：腺嘌呤(thymine)、鸟嘌呤(adenine)、胞嘧啶(cytocine)、胸腺嘧啶(guanine)。这些核苷酸相互连接起来，形成若干很长的基因链，而每个基因编码了生物机体的某种特征，如头发的颜色，耳朵的样子，等。一个基因可能具有的不同设置（如头发的黑色、棕色或金黄色），称为等位基因（allele），它们沿染色体纵向所处的物理部位称为基因的座位（locus）。 

。。一个细胞中的染色体组（collection）包含了复制该机体所需的全部信息。这就是克隆怎样实行的秘密。你可以从被克隆施主（donor）身上，哪怕是一个血细胞中包含的信息，复制出整个生物机体，例如一头羊。新的羊将会在每一个方面和施主羊完全相同。染色体的这一集合就称为生物机体的基因组（genome）。在一特殊基因组中等位基因的一种状态称为该机体的遗传类型（genotype）。这些就是用来生成实际的生物机体  －所谓表现型（phenotype） －本身的硬编码指令。你和我都是表现型。我们的DNA携带了我们的遗传类型。如将这些术语用到其他领域中，则，设计汽车用的成套蓝图就是一个遗传类型；在生产线上隆隆作响的成品汽车就是一个表现型；只有设计被定型之前的，那些完全阵旧的设计，才勉强称得上是一个基因组。 

。。行了，行话说到此已经足够了。现在让我们讨论，怎样把所有这些应用到进化中去。如果你属于偶尔有机会离开计算机屏幕的那种人（因为我的朋友告诉我，我才知道外边还有一个世界呢！），你可能已经注意到，对于千千万万的动物和植物 － 小到只有在显微镜下才能看到的单细胞生物，大到从空间卫星上也能见到的巨大珊瑚礁 －地球是它们共同的家，不管它们的大小怎样、形状或颜色又怎样。一个生物机体被认为取得了成功，如果它得到了配偶并生下了一个子机体，而后者完全有希望来继续进一步复制自己。 

。。为了做到这一点，生物机体必须善长许多工作。例如，能寻找食物和水、能面对掠食者来保卫自己、能使自己吸引潜在的配偶，等。所有这些特长在某种程度上都和生物机体的遗传类型 －生命的蓝图有关。生物机体的某些基因将会产生有助于它走向成功的属性，而另一些基因则可能要妨碍它取得成功。一个生物的成功的量度就是它的适应性。生物机体愈能适应，它的子孙后代也就愈多。下面转来讨论我们的关键部分... 

。。当两个生物机体配对和复制时，它们的染色体相互混合，产生一个由双方基因组成的全新的染色体组。这一过程就叫重组（recombination）或交叠（crossover,又译杂交,交叉,交换）。这样就意味，后代继承的可能大部分是上一代的优良基因，也可能继承了它们不少的不良基因。如果是前一种情况，后代就可能变得比它的父母更能成功（例如，它对掠食者有更强的自卫机制）；如为后一种情况，后代甚至就有可能不能再复制自己。这里要着重注意的是，愈能适应的子孙后代就愈有可能继续复制并将其基因传给下一个子孙后代。由此就会显示一种趋向，每一代总是比其父母一代生存和匹配得更完美。 

。。作为它的一个很简捷的例子，我们设想，雌性动物仅仅吸引大眼睛的雄性。这样，在追求雌性配偶的雄性中，眼睛的尺寸愈大，其获得成功的可能性也愈大。你可以说，动物的适应性正比于它的眼睛的直径。因此，你就可以看到，从一个具有不同大小眼睛的雄性群体出发，当动物进化时，在同位基因中，能产生大眼睛雄性动物的基因，相对于产生小眼睛雄性动物的基因，就更有可能被复制到下一代。由此可以推出，当进化几代之后，大眼睛将会在雄性群体占据统治地位。过些时候，你就可以说，生物正在向一种特殊的遗传基因收敛。

 

不过，有些读者可能已经会想到，如果这是繁殖期生物机体内唯一发生的事情，那幺即使经历成千上万代后，适应能力最强的成员的眼睛也只能象初始群体中最大的眼睛一样大。而根据我们对自然界的观察中发现，人类或动物的眼睛尺寸实际存在一代大于一代的趋势。之所以会发生这种情况，是因为当基因传递给子孙后代的过程中，会有很小的概率发生差错，从而使基因得到微小的改变。这多少有点象中国古老的耳语传话游戏：在一队人中，把一条消息一个接一个地传递下去；第一个人对着第二个人的耳朵轻声地讲述一个故事，第二个人再轻声地把此故事传向第三个人，等，直到最后那个人再把听到的故事讲出来。通常这都会诺出很多笑话：最后一个人讲出来故事与第一个所讲的已是面目全非。其实，这种类型的差错在把信息从一个系统传递给另一系统时实际都会发生的。图3.2显示的一列图画就是一个令人惊讶的例子。这是一次测试的结果：第一个人画出了一只鸟类的图(见左上角) 交给第二人，第二人看了以后自己重画一个给他的下一个人，这样重复下去，直到最后那个人画出来的图形就会被显著‘异化'。如果你有机会和十几个朋友聚集在一起，我推荐你做一下这个小试验，因为原始图画能有如此多变化似乎难以置信。

 

有趣的事实 
.......古代的硬币容易产生这种类型的信息丢失差错。早期厄尔利凯尔特人和条顿人所使用的硬币大量地被假冒着；在早先的原始硬币上能找到一位皇帝的头像（那时已经在许多城市和乡镇用于支付）到后来则变成一匹马或一碗果子的形状了。你一眼就能看出当时使用的假冒货币，无需使用任何高科技的紫外线设备来探测！ 

 

 

图 3.2 信息移转的一个试验。 ( Thames 和 Hudson 提供的幻想图形 )

你可以说，图形或故事的情节在从一个人到另一个人的传递过程中，已经发生了变异 （或突变，mutation） ，同样的变异在生物繁衍过程中会在它们的基因中出现。发生变异的概率通常都很小，但经历大量世代之后变异就会显得很可观。一些变异对生物将是不利的（这有最大的可能），另一些则对生物的适应性可能没有任何影响，但也有一些则可能会给生物带来一些明显的利益，使它能超过与其同类的生物。在前面我们所讲的例子中，你看到的能使动物引起眼睛直径变大的基因突变就是一种有利的突变，它将使该动物与群体其余动物相比，就好像一个超级的时髦模特儿那样显得突出。这种使眼睛变得越来越大的趋势需要基因参与才能实现。当进化过程经历成千上万代之后，就会使动物长出一对如同盛菜的盘子那样大的眼睛！见图3.3。

图 3.3 一个 Adonis 的进化

进化机制除了能改进已具备的特征之外，也能产生各种各样全新特征。让我们再以眼睛的进化作为一个例子来说明吧。

可以设想，曾有一个时期动物就根本没有眼睛。那时，动物在它们的环境中航行完全是靠嗅觉和触觉来躲避掠食它们的动物。他们也 相当擅长于这样做，因为他们靠这样已经历了成千上万个世代。在那个时候，鼻子大和手脚长的男性是受女孩子们欢迎的。然而，突然有一天，当两个动物配对时，一个基因突变发生在为皮肤细胞提供的蓝图上。这一突变使其后代在他们的头上发育出了一个具有相当光敏效应的细胞，使其后代能足够识别周围环境是亮的还是暗的。这样就给他带来了一个微小的优点，因为，如果一种食肉动物，比如一只鹰，来到了某个范围以内，则它将阻挡了光线，这时，该动物就会感觉得到，就可迅速跑到隐蔽的地方去躲藏起来。另外，这种皮肤细胞还能指示现在是晚上或白天，或告诉他现在是在地面之上或地面之下，这些信息在捕食和吸取营养时都能为它提供方便。你能看到这一新型皮肤细胞将使这一动物与群体中其余的动物相比，具备了稍多的优点，并因此也就有更多的生存和繁殖的机会。过了一段时间，由于进化机制的作用，许多动物的染色体中都会出现具有光敏皮肤细胞的基因。

现在，如果你再作一些外推，想象这一光敏细胞基因得到了进一步的有利突变，则你能看到，经过许多许多世代后，光敏细胞经过分化形成为一个区域；这个区域不断变大，产生出一些更为确定的特征，例如形成一个晶体，或产生能区别颜色的视觉细胞；还可以想象，一个突变使某个动物由一个光敏区域改变为两个光敏区域，由此就使那个动物有了立体视觉。立体视觉对一个生物体来说是一个巨大的进步，因为这能精确告诉他目标离开他有多远。当然，你也可以把会对眼睛产生不利影响的突变装入同样那些基因。但这里重要的一点是，这样生长出来的后代将不会和已具备改进型眼睛的堂表亲戚们那样取得成功，它们最终将会灭绝。只有成功的基因才会得到继承。你观察自然界中存在的任何特征就能发现，它们的进化都是利用无数微小的突变发展而来的，且它们都是对拥有者有利。难以置信吧？

这些重组和变异机制说明了进化怎么完成。我希望现在你已经理解，有机体是怎么逐步形成各种不同类型的特征，以帮助它们在其生存环境中取得更大的成功。

 

3.3 计算机内的进化 （ Evolution Inside Your Computer ）

遗传算法的工作过程本质上就是模拟生物的进化过程。首先，要规定一种编码方法，使得你的问题的任何一个潜在可行解都能表示成为一个“数字”染色体。然后，创建一个由随机的染色体组成的初始群体（每个染色体代表了一个不同的候选解），并在一段时期中，以培育适应性最强的个体的办法，让它们进化，在此期间，染色体的某些位置上要加入少量的变异。经过许多世代后，运气好一点，遗传算法将会收敛到一个解。遗传算法不保证一定能得到解，如果有解也不保证找到的是最优解，但只要采用的方法正确，你通常都能为遗传算法编出一个能够很好运行的程序。遗传算法的最大优点就是，你不需要知道怎么去解决一个问题; 你需要知道的仅仅是，用怎么的方式对可行解进行编码，使得它能能被遗传算法机制所利用。

通常，代表可行解的染色体采用一系列的二进制位作为编码。在运行开始时，你创建一个染色体的群体，每个染色体都是一组随机的２进制位。２进制位（即染色体）的长度在整个群体中都是一样的。作为一个例子，长度为 20的染色体的形状如下:

01010010100101001111

重要的事情就在于，每个染色体都用这样的方式编码成为由 0和1组成的字符串，而它们通过 译码 就能用来表示你手头问题的一个解。这可能是一个很差的解，也可能是一个十分完美的解，但每一个单个的染色体都代表了一个可行解（下面就将讨论有关编码的更多的细节）。初始群体通常都是很糟的，有点象英国板球队或美国足球队（抱歉了！）。但不管怎样，正如我前面说过的那样，一个初始的群体已经创建完成（对这一例子，不妨设共有100个成员），这样，你就可以开始做下面列出的一系列工作（你不用担心用粗体显示的那些词句，我后面马上就会来解释一切）：

 

不断进行下列循环，直到寻找出一个解 :

1.检查每个染色体，看它解决问题的性能怎样，并相应地为它分配一个适应性分数。

2. 从当前群体中选出2个成员。被选出的概率正比于染色体的适应性，适应性分数愈高，被选中的可能性也就愈大。常用的方法就是采用所谓的 轮盘赌选择法 或 赌轮选择法 (Roulette wheel selection )。

 3.按照预先设定的 杂交率 （Crossover Rate ），从每个选中染色体的一个随机的点上进行杂交（crossover ）。

 4.按照预定的 变异率 （ mutation rate ），通过对被选染色体的位的循环，把相应的位实行翻转（ flip ）。

 5.重复步骤2，3，4，直到100个成员的新群体被创建出来。

结束循环 


以上算法中步骤1 到步骤5 的一次循环称为一个代（或世代，generation）。而把这整个的循环称作一个时代（epoch），在我的正文和代码中将始终都用这样方式来称呼。

 

3.3.1 什么是轮盘赌选择？ ( What's the Roulette Wheel Selection ) 轮盘赌选择是从染色体群体中选择一些成员的方法，被选中的机率和它们的适应性分数成比例，染色体的适应性分数愈高，被选中的概率也愈多。这不保证适应性分数最高的成员一定能选入下一代，仅仅说明它有最大的概率被选中。其工作过程是这样的：

设想群体全体成员的适当性分数由一张饼图来代表 (见图3.4)，这一饼图就和用于赌博的转轮形状一样。我们要为群体中每一染色体指定饼图中一个小块。块的大小与染色体的适应性分数成比例，适应性分数愈高，它在饼图中对应的小块所占面积也愈大。为了选取一个染色体，你要做的，就是旋转这个轮子，并把一个小球抛入其中，让它翻来翻去地跳动，直到轮盘停止时，看小球停止在哪一块上，就选中与它对应的那个染色体。本章后面我就会告诉你怎样来编写这种程序的准确算法。

图 3.4　染色体的轮盘赌式选择

3.3.2 什么是杂交率？( What's the Crossover Rate ) 杂交率就是用来确定 2个染色体进行局部的位（bit）的互换以产生2个新的子代的概率。 实验表明这一数值通常取为0.7左右是理想的，尽管某些问题领域可能需要更高一些或较低一些的值。

每一次，我们从群体中选择 2个染色体，同时生成其值在0到1之间一个随机数，然后根据此数据的值来确定两个染色体是否要进行杂交。如果数值低于杂交率(0.7)就进行杂交，然后你就沿着染色体的长度随机选择一个位置，并把此位置后面所有的位进行互换。

例如，设给定的 2个染色体为:

10001001110010010

01010001001000011

沿着它们的长度你随机选择一个位置，比如说 10，然后互换第10位之后所有位。这样两个染色体就变成了（我已在开始互换的位置加了一个空格）：

 

100010011 01000011

010100010 10010010

3.3.3　什么是变异率？( What's the Mutation Rate? )

变异率（突变率） 就是在一个染色体中将位实行翻转（flip，即0 变1，1变 0）的几率。这对于二进制编码的基因来说通常都是很低的值，比如 0.001 。

因此，无论你从群体中怎样选择染色体，你首先是检查是否要杂交，然后再从头到尾检查子代染色体的各个位，并按所规定的几率对其中的某些位实行突变（翻转）。

 

3.4 帮助 Bob 回家（ Helping Bob Home ）

由于寻找路径问题被看成是游戏人工智能的一块神圣基石，我们下面就来创建一个遗传算法，用在一个非常简单的场景中解决寻找路径问题。为此，我们将创建一个迷宫，它的左边有一入口，右边有一出口，并有一些障碍物散布在其中。然后在出发点放置一个虚拟的人，我们叫他鲍勃（Bob），然后要为他解决如何寻找路径的问题，使他能找到出口，并避免与所有障碍物相碰撞。下面我将说明怎样来产生Bob的染色体的编码，但首先需要解释怎样来表示迷宫...

迷宫是一个2D整数型数组；用0来表示开放的空间，1代表墙壁或障碍物，5是起始点，8是出口。因此，整数数组:

.{ 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,.
. 1,0,1,0,0,0,0,0,1,1,1,0,0,0,1,
..5,0,0,0,0,0,0,0,1,1,1,0,0,0,1,
..1,0,0,0,1,1,1,0,0,1,0,0,0,0,1,
..1,0,0,0,1,1,1,0,0,0,0,0,1,0,1,
. 1,1,0,0,1,1,1,0,0,0,0,0,1,0,1, 
..1,0,0,0,0,1,0,0,0,0,1,1,1,0,1,
..1,0,1,1,0,0,0,1,0,0,0,0,0,0,8,
..1,0,1,1,0,0,0,1,0,0,0,0,0,0,1,
.. 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1 }

在屏幕上看起来将会有下面图3.5的样子:

图 3.5 Bob的迷宫，用红色标出了入口和出口

　　作者已把这种地图设计方法封装在一个被称作CBobsMap的类中，它定义为: 

 

 class CBobsMap
    {

       // private static int MAP_HEIGHT = 10;
      //  private static int MAP_WIDTH = 15;
        //storage for the map
        private static int[,] map = new int[10, 15]
{{1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1},
 {1, 0, 1, 0, 0, 0, 0, 0, 1, 1, 1, 0, 0, 0, 1},
 {8, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 0, 0, 1},
 {1, 0, 0, 0, 1, 1, 1, 0, 0, 1, 0, 0, 0, 0, 1},
 {1, 0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 0, 1, 0, 1},
 {1, 1, 0, 0, 1, 1, 1, 0, 0, 0, 0, 0, 1, 0, 1},
 {1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 1, 1, 0, 1},
 {1, 0, 1, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 5},
 {1, 0, 1, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 1},
 {1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1}};


        private static int m_iMapWidth = 15;
        private static int m_iMapHeight = 10;

        //index into the array which is the start point
        private static int m_iStartX = 14;
        private static int m_iStartY = 7;

        //and the finish point
        private static int m_iEndX = 0;
        private static int m_iEndY = 2;

        public CBobsMap()
        {
        }
        public double TestRoute(IList<int> vecPath, CBobsMap Bobs)
        {
            int posX = m_iStartX;
            int posY = m_iStartY;

            for (int dir = 0; dir < vecPath.Count; ++dir)
            {
                int NextDir = vecPath[dir];

                switch (vecPath[dir])
                {
                    case 0: //North

                        //check within bounds and that we can move
                        if (((posY - 1) < 0) || (map[posY - 1, posX] == 1))
                        {
                            break;
                        }

                        else
                        {
                            posY -= 1;
                        }

                        break;

                    case 1: //South

                        //check within bounds and that we can move
                        if (((posY + 1) >= m_iMapHeight) || (map[posY + 1, posX] == 1))
                        {
                            break;
                        }

                        else
                        {
                            posY += 1;
                        }

                        break;

                    case 2: //East

                        //check within bounds and that we can move
                        if (((posX + 1) >= m_iMapWidth) || (map[posY, posX + 1] == 1))
                        {
                            break;
                        }

                        else
                        {
                            posX += 1;
                        }

                        break;

                    case 3: //West

                        //check within bounds and that we can move
                        if (((posX - 1) < 0) || (map[posY, posX - 1] == 1))
                        {
                            break;
                        }

                        else
                        {
                            posX -= 1;
                        }

                        break;

                }//end switch

                //mark the route in the memory array
                //    Bobs.memory[posY,posX] = 1;

            }//next direction

            //now we know the finish point of Bobs journey, let's assign
            //a fitness score which is proportional to his distance from
            //the exit

            int DiffX = Math.Abs(posX - m_iEndX);
            int DiffY = Math.Abs(posY - m_iEndY);

            //we add the one to ensure we never divide by zero. Therefore
            //a solution has been found when this return value = 1
            return 1 / (double)(DiffX + DiffY + 1);
        }
}

　　

 

...。
.      由上可以看出，我们只需要以常量的形式来保存地图数组以及起点和终点的坐标就行了。这些数据是在文件 CBobsMap.cpp 中定义的，在光盘上你能找到它的相关的文件夹。除了存储迷宫的数据外，这个Map类也用来记录Bob在迷宫中所走过的路程： memory[][] 。这对遗传算法本身而言不是本质的，但为了显示目的，使你能看到 Bob怎样在迷宫中漫游，设置一个记录是必需的。这里重要的是成员函数TestRoute()，它需要利用一系列的行进方向来检测 Bob 走了多远。这里我不准备花费时间来列出TestRoute 函数的清单，因为这是十分简单的那种函数，但要列出来却可能需要长长的2页。我们只需要说明一下就行了。给出一个方向向量，它的每个分量能代表向北（North）、向南（South）、向东（East）、向西（West）四个方向之一，让 Bob 按照它在地图中行走， TestRoute 计算 Bob 能到达的最远点的位置，然后返回一个适应性分数，它正比于 Bob 最终位置离出口的距离。他所到达的位置离开出口愈近，奖励给他的适应性分数也愈高。如果他实际已到达了出口，则我们就要向他表示祝贺了，他将得到满分1。这时循环就会自动结束，因为你已经找到一个解了，可以喊乌拉了！

....再有，不要因为理解不了这个类的任何一点而操心。我们下面马上就会开始讨论有关的每一件事情的。

3.4.1为染色体编码
（Ecoding the Chromosome）

每个染色体必须把小人Bob 的每一个行动编入代码中。Bob的行动仅限为4个方向： 向东(East)，向南(South)，向西(West)，向北(North) 故编码后的染色体应该就是代表这4个方向信息的一个字符串。传统的编码方法就是把方 向变换成二进制的代码。四个方向只要2位就够了，例如下表所示的那样：

二进制代码	十进制译码	代表的方向
00	0	向北
01	1	向南
10	2	向东
11	3	向西

 

这样，如果你得到了一个随机的二进制字符串，你就能将它译码出Bob行动时所遵循的

一系列方向。例如染色体:

111110011011101110010101

代表的基因就是： 11,11,10,01,10,11,10,11,10,01,01,01 当把二进制代码译成十进制时，就成为 3,3,2,1,2,3,2,3,2,1,1,1 再把这些放进一个表格中，就可以使你相信这是一样的一些概念:

二进制代码	十进制译码	代表的方向
11	3	West
11	3	West
10	2	East
01	1	South
10	2	East
11	3	West
10	2	East
11	3	West
10	2	East
01	1	South
01	1	South
01	1	South

      到此，你要做的全部就是将Bob置于迷宫的起点，然后告诉他根据这张表所列的方向
一步步地走。如果按某一个方向前进将使Bob碰到墙壁或障碍物，则只需忽略该方向并继
续按下一个方向去走就行了。这样不断下去，直到所有方向用光或Bob到达出口时为止。
    
    如果你想象有几百个这样的随机的染色体，你就能看到它们中的某些可能为Bob译码
出到达出口的一套方向（问题的一个解），但它们中的大多数将是失败的。
    
    遗传算法以随机的2进制串（染色体）作为初始群体，测试它们每一个能让Bob走到
离开出口有多么接近，然后让其中最好的那些来孵化后代，期望它们的子孙中能有比Bob
走得离出口更近一点。这样继续下去，直到找出一个解，或直到Bob绝望地在一个角落里
被粘住不动为止（你将看到，这种情况是可能发生的）。
      
    因此，我们应定义一种结构，其中包含一个２进制位串（染色体），以及一个与该
染色体相联系的适应性分数。我把这个结构称为SGenome结构，它的定义如下:    

 public class SGenome
    {
        private IList<int> vecBits;
        private double dFitness;
        private static Random rand = new Random();
        public SGenome()
        {
            this.dFitness = 0;
        }
        public SGenome(int num_bits)
        {
            vecBits = new List<int>();

            for (int i = 0; i < num_bits; i++)
            {
                vecBits.Add(rand.Next(0, 2));
            }

            this.dFitness = 0;
        }
  }

　　

正如你能见到的那样，如果你在创建Sgenome对象时把一个整型数作为参数

传递给构造函数，则它就会自动创建一个以此整数为长度的随机２进制位串，

并将其适应性分数初始化为零，这样就把基因组什么都准备好了。

SGenome结构中不具备怎样为染色体（vecBits）进行译码的知识; 这是需要 由遗传算法类自己来完成的一项任务。现在让我们来快速窥视一下这个类的定义。 我已把它称作CgaBob类

 

        //--------------------------------Epoch---------------------------------
        //
        //	This is the workhorse of the GA. It first updates the fitness
        //	scores of the population then creates a new population of
        //	genomes using the Selection, Croosover and Mutation operators
        //	we have discussed
        //----------------------------------------------------------------------
        public void Epoch()
        {

            if (UpdateFitnessScores() == false)
            {
                return;
            }

            //Now to create a new population
            int NewBabies = 0;

            //create some storage for the baby genomes 
            IList<SGenome> vecBabyGenomes = new List<SGenome>();

            while (NewBabies < m_iPopSize)
            {
                //select 2 parents
                SGenome mum = RouletteWheelSelection();
                SGenome dad = RouletteWheelSelection();

                //operator - crossover
                SGenome baby1 = new SGenome(m_iChromoLength);
                SGenome baby2 = new SGenome(m_iChromoLength);

                Crossover(mum.getVecBits(), dad.getVecBits(), baby1.getVecBits(), baby2.getVecBits());

                //operator - mutate
                Mutate(baby1.getVecBits());
                Mutate(baby2.getVecBits());

                //add to new population
                vecBabyGenomes.Add(baby1);
                vecBabyGenomes.Add(baby2);

                NewBabies += 2;
            }

            //copy babies back into starter population
            m_vecGenomes = vecBabyGenomes;

            //increment the generation counter
            ++m_iGeneration;
        }
        //---------------------------UpdateFitnessScores------------------------
        //	updates the genomes fitness with the new fitness scores and calculates
        //	the highest fitness and the fittest member of the population.
        //	Also sets m_pFittestGenome to point to the fittest. If a solution
        //	has been found (fitness == 1 in this example) then the run is halted
        //	by setting m_bBusy to false
        //-----------------------------------------------------------------------
        public bool UpdateFitnessScores()
        {
            m_iFittestGenome = 0;
            m_dBestFitnessScore = 0;
            m_dTotalFitnessScore = 0;

            CBobsMap TempMemory = new CBobsMap();
            m_BobsMap = new CBobsMap();
            //update the fitness scores and keep a check on fittest so far
            for (int i = 0; i < m_iPopSize; ++i)
            {
                //decode each genomes chromosome into a vector of directions
                IList<int> vecDirections = Decode(m_vecGenomes[i].getVecBits());

                //get it's fitness score
                m_vecGenomes[i].setDFitness(m_BobsMap.TestRoute(vecDirections, TempMemory));
          //      Console.WriteLine("fitness={0}", m_vecGenomes[i].getDFitness());
                //update total
                m_dTotalFitnessScore += m_vecGenomes[i].getDFitness();

                //if this is the fittest genome found so far, store results
                if (m_vecGenomes[i].getDFitness() > m_dBestFitnessScore)
                {
                    m_dBestFitnessScore = m_vecGenomes[i].getDFitness();

                    m_iFittestGenome = i;

               //     m_BobsBrain = TempMemory;

                    //Has Bob found the exit?
                    if (m_vecGenomes[i].getDFitness() == 1)
                    {
                        //is so, stop the run
                  //      Console.WriteLine();
                    //    Console.WriteLine("difttt={0}", m_vecGenomes[i].getDFitness());
                        m_bBusy = false;
                        //foreach (int m in m_vecGenomes[i].getVecBits())
                        //{
                        //    Console.Write("{0}", m);
                        //}
                  //      Console.WriteLine();
                        return false;
                      
                    }
                }

              //  TempMemory.ResetMemory();

            }//next genome
            return true;
        }

　　

由上你可看出，当这个类的一个实例被创建时，构造函数初始化所有的变量，并调用CreateStartPopulation()。

这一短小函数创建了所需数量的基因组群体。每个基因组一开始包含的是一个由随机2进制位串组成的染色体，

其适应性分数则被设置为零。