遗传算法入门(连载之二）

遗传算法入门

(连载之二)

.

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

(美）Mat Buckland 著

吴祖增 沙 鹰 译

．

清华大学出版社出版

 

 

 

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进制位串组成的染色体，
其适应性分数则被设置为零。