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)
