def docross(self,lives,x, y): child1 = self.getChild(1,lives, x, y) child2 = self.getChild(2,lives, x, y) child1=self.modify_circle(child1) child2=self.modify_circle(child2) lives[x] = Life(child1) lives[y] = Life(child2)
def initPopulation(self): """初始化种群""" self.lives = [] for i in range(self.lifeCount): if i==0 and self.prim_path: gene = self.prim_path life = Life(gene) self.lives.append(life) else: gene = [ x for x in range(self.geneLenght) ] random.shuffle(gene) life = Life(gene) self.lives.append(life)
def __init__(self, x_rate=0.7, mutation_rate=0.005, life_count=50, gene_length=100, judge=lambda lf, av: 1, save=lambda: 1, mk_life=lambda: None, x_func=None, m_func=None): self.x_rate = x_rate self.mutation_rate = mutation_rate self.mutation_count = 0 self.generation = 0 self.lives = [] self.bounds = 0.0 # 得分总数 self.best = None self.life_count = life_count self.gene_length = gene_length self.__judge = judge self.save = save self.mk_life = mk_life # 默认的产生生命的函数 self.x_func = (x_func, self.__x_func)[x_func == None] # 自定义交叉函数 self.m_func = (m_func, self.__m_func)[m_func == None] # 自定义变异函数 for i in range(life_count): self.lives.append(Life(self, self.mk_life()))
def main(): #initialize # Assumes Linux setup cmd = "cd ~/Documents; pwd 2>/dev/null >/tmp/life_directory; cd - > /dev/null" output = subprocess.check_output(cmd, shell=True).split() documents_directory_path = subprocess.check_output( "cat /tmp/life_directory", shell=True).split()[0] life_directory = documents_directory_path + "/RealLifeGTA/" life_filename = "gta.data" life_complete_path = life_directory + life_filename try: life = _load_from_file(life_complete_path) #print "Loading life from datastore" except: #traceback.print_exc(file=sys.stdout) print "Couldn't load life from datastore, creating a new file at path:" + life_directory subprocess.check_output("mkdir -p " + life_directory, shell=True) life = Life() # start main loop CommandLineInterface(life)._process_single_command() #persist data try: _save_to_file(life, life_complete_path) except: traceback.print_exc(file=sys.stdout)
def next(self): """产生下一代""" self.judge() newLives = [] """for lf in self.lives: if lf.score > 5*self.initScore: newLives.append(lf)""" newLives.append(self.best) #把最好的个体加入下一代 basicgene = [0 for x in range(self.geneLenght)] #把最基本的加入下一代 newLives.append(Life(basicgene)) newLives.append(Life(self.init)) #把DFS得到的加入下一代 while len(newLives) < self.lifeCount: newLives.append(self.newChild()) self.lives = newLives self.generation += 1
def __init__(self, xRate=0.7, mutationRate=0.005, lifeCount=50, geneLength=100, judge=lambda lf, av: 1, save=lambda: 1, mkLife=lambda: None, xFunc=None, mFunc=None): self.xRate = xRate self.mutationRate = mutationRate self.mutationCount = 0 self.generation = 0 self.lives = [] self.bounds = 0.0 # 得分总数 self.best = None self.lifeCount = lifeCount self.geneLength = geneLength self.__judge = judge self.save = save self.mkLife = mkLife # 默认的产生生命的函数 self.xFunc = (xFunc, self.__xFunc)[xFunc == None] # 自定义交叉函数 self.mFunc = (mFunc, self.__mFunc)[mFunc == None] # 自定义变异函数 for i in range(lifeCount): self.lives.append(Life(self, self.mkLife()))
def initPopulation(self): """初始化种群""" self.lives = [] for i in range(self.lifeCount): gene = [x for x in range(self.geneLenght)] random.shuffle(gene) life = Life(gene) self.lives.append(life)
def initPopulation(self): """初始化种群""" self.lives = [] for i in range(self.lifeCount): gene = [x for x in range(self.geneLenght)] # 初始化染色体 # shuffle() 方法将序列的所有元素随机排序。 random.shuffle(gene) life = Life(gene) # 生成个体 self.lives.append(life)
def initPopulation(self): """初始化种群""" self.lives = [] for i in range(self.lifeCount): gene = self.initOrder #print(gene) #random.shuffle(gene) # 随机洗牌 # life = Life(gene) self.lives.append(life)
def initPopulation(self): """初始化种群""" self.lives = [] count = 0 while count < self.lifeCount: gene = np.random.randint(0, 2, self.geneLenght) life = Life(gene) random.shuffle(gene) # 随机洗牌 # self.lives.append(life) count += 1
def newChild(self): """产生新后的""" mutationLives = [] # 按概率突变 for i in self.notBests: gene = self.mutation(i) mutationLives.append(Life(gene)) return mutationLives
def make_viewer(n, m, row, col, *strings): """Makes a Life and LifeViewer object. n, m: rows and columns of the Life array row, col: upper left coordinate of the cells to be added strings: list of strings of '0' and '1' """ life = Life(n, m) # n行m列的格子 life.add_cells(row, col, *strings) # 左上角坐标 viewer = LifeViewer(life) # 瞅一眼 return viewer
def newChild(self): """产生新后的""" parent1 = self.getOne() parent2 = self.getOne() rate = random.random() # 按概率交叉 if rate < self.croessRate: # 交叉 gene1, gene2 = self.cross(parent1, parent2) else: gene1, gene2 = parent1.gene, parent2.gene # 按概率突变 rate = random.random() if rate < self.mutationRate: gene1, gene2 = self.mutation(gene1), self.mutation_bk(gene2) return Life(gene1), Life(gene2)
def initPopulation(self): """initial the population""" self.population = [] for i in range(self.population_size): #gene = [0,1,…… ,self.chromosome_length-1] gene = self.init_chromosome[:] random.shuffle(gene) pop = Life(gene) # put individual in the population self.population.append(pop)
def initPopulation(self): """初始化种群""" self.lives = [] for i in range(self.lifeCount): gene = [ x for x in range(self.geneLenght) ] random.shuffle(gene) #将序列的所有元素随机排序 self.modify_circle(gene) life = Life(gene) self.lives.append(life) self.best=self.lives[0] self.judge()
def judge(self, f=lambda lf, av: 1): # 根据传入的方法 f ,计算每个个体的得分 lastAvg = self.bounds / float(self.lifeCount) self.bounds = 0.0 self.best = Life(self) self.best.setScore(-1.0) for lf in self.lives: lf.score = f(lf, lastAvg) if lf.score > self.best.score: self.best = lf self.bounds += lf.score
def newChild(self): """产生新后的""" parent1 = self.getOne() gene = parent1.gene # 按概率突变 rate = random.random() if rate < self.mutationRate: gene = self.mutation(gene) return Life(gene)
def getNewChild(self): logging.debug('select 2 parent lives') parent1 = self.selection() parent2 = self.selection() while self.hammingDist(parent1._gene, parent2._gene) == 0: parent2 = self.selection() pass variableCount = len(self._boundaryList) encodeLength = int(self._geneLength / variableCount) # logging.debug('parent1: \n%s' % self.decodedOneGene(parent1._gene)) # logging.debug('parent2: \n%s' % parent1._gene.reshape((variableCount, encodeLength))) # logging.debug('parent2: \n%s' % self.decodedOneGene(parent2._gene)) # logging.debug('parent2: \n%s' % parent2._gene.reshape((variableCount, encodeLength))) logging.debug( 'hamming distance between parent1 and parent2: %d' % self.hammingDist(parent1._gene, parent2._gene)) # 按概率交叉 rate = random.random() if rate < self._crossoverRate: logging.debug('crossover') # 交叉 gene1, gene2 = self.crossover(parent1, parent2) logging.debug( 'hamming distance between gene1 and gene2 after crossover: %d' % self.hammingDist(gene1, gene2)) else: gene1, gene2 = parent1._gene, parent2._gene # 按概率突变 rate = random.random() if rate < self._mutationRate: logging.debug('mutation') gene1, gene2 = self.mutation(gene1), self.mutation(gene2) logging.debug( 'hamming distance between gene1 and gene2 after mutation: %d' % self.hammingDist(gene1, gene2)) # 计算子代适应度 life1 = Life(gene1) life2 = Life(gene2) life1._fitness = self._fitnessClass.fitnessFunc(self.decodedOneGene(gene1)) life2._fitness = self._fitnessClass.fitnessFunc(self.decodedOneGene(gene2)) return life1, life2
def __init__(self, sense): self.sense = sense self.FACE = 1, RobotFace(sense) self.RADIO = 2, Radio(sense) self.LIFE = 3, Life(sense, 8, 8) self.MUSICPLAYER = 4, MusicPlayer(sense) self.stateList = (self.FACE, self.RADIO, self.LIFE, self.MUSICPLAYER) # Start with some state self.current = self.MUSICPLAYER self.current[1].select()
def newChild(self): parent1 = self.getOne() rate = random.random() if rate < self.crossRate: parent2 = self.getOne() gene = self.cross(parent1, parent2) else: gene = parent1.gene rate = random.random() if rate < self.mutationRate: gene = self.mutation(gene) return Life(gene)
def initPopulation(self): """初始化种群""" start1 = time.clock() self.lives = [] for i in range(self.lifeCount): gene = self.initLife() life = Life(gene) self.lives.append(life) end1 = time.clock() runtime = end1 - start1 print("----------------初始化种群,用时" + str(("%.2f") % (runtime)) + "秒------------------")
def next(self): """产生下一代""" self.generation += 1 self.judge() do_best = self.domutation(self.best1.gene) push_best = self.pushmutation(self.best1.gene) newLives = [] newLives.append(Life(self.best.gene)) # 把最好的个体加入下一代 newLives.append(Life(do_best)) newLives.append(Life(push_best)) newLives.append(Life(self.best1.gene)) self.setRoulette() while len(newLives) < self.lifeCount: newLives.append(self.getOne()) newLives = self.crossover(newLives) newLives = self.mutation(newLives) self.lives = newLives
def add_life(self, life_img, count): if count < 3: count = 3 self.life = count for num in range(0, count): life = Life(life_img, [20 + num * life_img.get_rect().width, 20]) self.lifeGroup.add(life) self.lifeC.append(life)
def initPopulation(self): """初始化种群""" self.lives = [] for _ in range(self.lifeCount): # gene = [0,1,…… ,self.geneLength-1] gene = list(range(self.geneLength)) # 将0到33序列的所有元素随机排序得到一个新的序列 random.shuffle(gene) # Life这个类就是一个基因序列,初始化life的时候,两个参数,一个是序列gene,一个是这个序列的初始适应度值 # 因为适应度值越大,越可能被选择,所以一开始种群里的所有基因都被初始化为-1 life = Life(gene) #把生成的这个基因序列life填进种群集合里 self.lives.append(life)
def run_game(board_size, life_cells, refresh): """ Play the game with the given parameters. :param board_size: the grid size of the board :param life_cells: the number of starter life cells :param refresh: the refresh rate of the game """ print( f'Total cells: {board_size * board_size}, Life cells: {life_cells}\n') life_game = Life(size=board_size, initial_cells=life_cells, interval=refresh) life_game.play()
def initPopulation(self): logging.debug('init population') self._population = [] if self._binaryEncode: # 将变量进行二进制编码 if self._boundaryList is None: raise ValueError("boundaryList must be configured!") # 获取编码长度列表 self._encodeLengths = self.getEncodedLengths() # 基因长度为每个变量编码长度之和 self._geneLength = np.sum(self._encodeLengths) # 随机化初始种群为0 for i in range(self._populationSize): # 随机生成基因 gene = np.random.randint(0, 2, self._geneLength) # 生成个体,并计算适应度 life = Life(gene) life._fitness = self._fitnessClass.fitnessFunc(self.decodedOneGene(gene)) # 把生成个体添加至种群集合里 self._population.append(life) else: # 编码方式为[0, 1, 2, ..., self._geneLength-1] if self._geneLength is None: raise ValueError("geneLength must be configured!") for i in range(self._populationSize): gene = np.array(range(self._geneLength)) # 将基因乱序 random.shuffle(gene) # 生成个体,并计算适应度 life = Life(gene) life._fitness = self._fitnessClass.fitnessFunc(gene) # 把生成个体添加至种群集合里 self._population.append(life) # 根据适应度值对种群的个体降序排列,并记录最佳个体和最佳适应度 self._population = self.sortPopulation(self._population) self._bestLife = self._population[0] self._bestFitnessHistory.append(self._bestLife._fitness) # 计算总适应度 self._totalFitness = self.calTotalFitness(self._population) self._totalFitnessHistory.append(self._totalFitness)
def next(self): start = time.clock() """产生下一代""" self.judge() newLives = [] newLives.extend(self.newChild()) while len(newLives) < self.lifeCount: newLives.append(Life(self.initLife())) self.lives = newLives self.generation += 1 end = time.clock() runtime = end - start print("----------------迭代一轮需要用时" + str(("%.2f") % (runtime)) + "秒------------------")
def next(self, n=1): # 演化至下n代 while n > 0: # self.__getBounds() self.judge(self.__judge) new_lives = [Life(self, self.best.gene)] # self.bestHistory.append(self.best) while len(new_lives) < self.life_count: new_lives.append(self.__new_child()) self.lives = new_lives self.generation += 1 # print("gen: %d, mutation: %d, best: %f" % (self.generation, self.mutationCount, self.best.score)) self.save(self.best, self.generation) n -= 1
def next(self, n=1): # 演化至下n代 while n > 0: # self.__getBounds() self.judge(self.__judge) newLives = [] newLives.append(Life(self, self.best.gene)) # 将最好的父代加入竞争 while (len(newLives) < self.lifeCount): newLives.append(self.__newChild()) self.lives = newLives self.generation += 1 print("gen: %d, best: %f" % (self.generation, 1 / self.best.score)) self.save(self.best, self.generation) n -= 1
def __bear(self, p1, p2): # 根据父母 p1, p2 生成一个后代 r = random.random() if r < self.xRate: # 交叉 gene = self.xFunc(p1, p2) else: gene = p1.gene r = random.random() if r < self.mutationRate: # 突变 gene = self.mFunc(gene) self.mutationCount += 1 return Life(self, gene)