遗传算法 GA

引言

编程中很多算法都是基于一些严谨的理论来作为基础，从而进行编程实现，解决问题。但我认为遗传算法是比较特殊的一种。首先，它是基于生物进化理论来的，理论虽然已被证明，但总归觉得有一些概率，可以说是运气在里面。其实，往往使用遗传算法去解决问题时，和常规的直面问题，制定严谨的执行步骤去解决问题不同，遗传算法总是将问题往这个模型上靠，制定简单的进化规则，然后运行起来后，它就按照这些既定的简单理论开始自己进化，从而得到一个往往不是最优解的答案，但往往用它来解决一些问题，你总归是会得到一个可用的答案。

什么是遗传算法

如果要讲遗传算法（Genetic Algorithm），那要从生物进化理论来讲。一个种群，起初是由一定规模的生物个体组成，在自然界竞争中优胜劣汰，从而一代一代进化下来，能够成功进化到下一代的种群，肯定有一个帮它克服大自然，良好地适应于恶劣环境的特点。比如，人类进化过程中，刚开始都不会直立行走，但某一些第一个尝试直立行走的祖先当中，他们解放了双手，进行了更有效的生产劳动，从而得到了更多的生产资源，存活了下来，而那些未能尝试学习直立行走的部分，要么被淘汰，要么没有进化，种群没能良好的适应环境。而这群尝试直立行走的种群，得到了更多的生存机会，进一步进化过程中，那些强壮的个体，某一方面能力出众的个体，适应环境更好，得到了更多繁衍生息后代的机会，就这样一代一代进化成我们现在的样子。如果假设我们现在的状态为最佳状态（当然不是），第一批猴子为人类初始状态，那么人类进化的过程可以看作是人类进化过程中的一个解决方案，按照这条路走，总归会达到现在的样子，当然可能有更多更好的方法，但至少这种方法可以达到现在状态。
　 　我们知道，人类的特性控制是由基因控制的，每一个性状都是一对基因的体现，基因也在不段的繁衍中，进行着各种杂交和突变，这才给了一些良好基因生存的机会，那些被证明杂交过程中留下来的基因，大多是更能适应环境的基因，而突变也给了基因一些闪亮的机会，并且最终突显出来。
　 　根据上面的描述，不难看出，遗传过程中的几个重要步骤：

• 一个种群
• 种群中进行繁衍的亲本
• 基因杂交
• 基因突变

那这些与我们的编程算法有什么关系呢？
很多种实际问题，其实它们的解可以类比为基因的排序，比如一个机器人去走迷宫，从入口找到出口，那么它的街轨迹，就是找到出口的解，即类似于，上下左右，四个方向，左->上->左->右->下，这个问题的解就是类似于这样的一个序列，我们可以把它看作是一个染色体，每一步可以看作是一对基因，如果我们随机给出一个种群，种群中每个个体都是一套染色体，每个染色体就包含这样一个基因序列，即给出一组随机的基因序列，那我们怎么去解决这个问题呢：

• 先生产出一个群体，里面个体的基因序列随机；
• 让每个基因组（即机器人走迷宫的步骤），去尝试走迷宫，看看它能走多远；
• 根据结果对这组基因进行打分；
• 从结果中，按照一定规则选出两个亲本，可以按照打分情况来随机选，让分数高的更容易被选上；
• 用这两个亲本，进行杂交（比如随机选择一些片段整合一下），产生两个子代；
• 对这两个子代亲本，按照一定变异率进行基因变异（比如一定概率基因值取反）；
• 把这两个子段放进下一代的种群中，依然再选择亲本，按照上面的方法产生子代，形成一个和上一代同等规模的种群；
• 让这个种群去走下迷宫，得到他们的分数，依次类推，看是否有哪一条基因找到了出口；
• 依次往复，直到得到答案。

关键点

从一个种群到下一个种群，适应下来的解，局部最优的解更容易得到繁衍的机会，而杂交算法的加入，会使得，这些优质的解可以取长补短，让子代有机会达到更佳，但局部最优可能不是全局最优，很有可能劣质基因的积累，让整个种群慢慢特征收敛，万一进入死胡同，将没有机会得到最优解，而变异就给了种群有了多样性的可能。这些算子的整合，就产生了一个完整的遗传算法。

代码演示

'''
 * Created on: Oct 11, 2017
 * Author:     Heng Xiangzhong
 * 
 * May the code be with you!
 '''

import random
import copy

map = [[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],
	   [0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 0, 0, 1],
	   [1, 0, 0, 0, 1, 0, 1, 0, 0, 1, 0, 0, 0, 0, 1],
	   [1, 0, 0, 0, 1, 0, 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]]

map_shadow = [[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],
	   [0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 0, 0, 1],
	   [1, 0, 0, 0, 1, 0, 1, 0, 0, 1, 0, 0, 0, 0, 1],
	   [1, 0, 0, 0, 1, 0, 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]]


def _print_map(map):
	for x,row in enumerate(map):
		for y, i in enumerate(row):
			if i == 999:
				print("\033[0;32m* \033[0m", end="")
			elif i > 1:
				print("\033[0;31m%d \033[0m" % (i), end="")
			elif x == 2 and y == 0:
				print("\033[0;32m%d \033[0m" % (i), end="")
			elif i == 0:
				print("  ", end="")
			elif i == 1:
				print("+ ", end="")

		print("")

class Genome:
	def __init__(self):
		self.bits = []
		self.fitness = 0

		for i in range(0, 100):
			self.bits.append(random.randint(0, 1))

	def clear(self):
		self.bits.clear()

class GARobot:
	def __init__(self):
		self.genomes = []
		self.pop_size = 200
		self.mutation_rate = 0.001
		self.chromo_length = 0
		self.gene_length = 0
		self.fittest_genome = 0
		self.best_fitness_score = 0
		self.total_fitness_score = 0
		self.crossover_rate = 0.7
		self.generation = 0
		self.map = map
		self.busy = False

		for i in range(0, self.pop_size):
			self.genomes.append(Genome())

	def epoch(self):
		self.__test_route()

		new_genomes = []
		for i in range(0, self.pop_size >> 1):
			mum = self.__roulette_wheel_selection()
			dad = self.__roulette_wheel_selection()

			#print("mum (%f), dad (%f), best (%f)" % (mum.fitness, dad.fitness, self.best_fitness_score))

			#Crossover
			baby = self.__crossover(mum, dad)
			baby_temp = baby[0]
			self.__mutate(baby[0])
			self.__mutate(baby[1])
			self.__mutate(baby_temp)
			new_genomes.append(baby[0])
			new_genomes.append(baby[1])

		self.genomes = new_genomes

	def __decode_direction(self, a, b):
		if a == 1 and b == 1:
			return (-1, 0)
		elif a == 1 and b == 0:
			return (1, 0)
		elif a == 0 and b == 0:
			return (0, -1)
		else:
			return (0, 1)

	def __show_path(self, genome):
		start = ()
		for x,row in enumerate(map):
			for y,val in enumerate(row):
				if val == 5:
					start = (x, y)

		temp_map = copy.deepcopy(map)
		pos = start
		for couple in range(0, len(genome.bits) >> 1):
			# Check whether is wall
			direction = self.__decode_direction(genome.bits[couple << 1], genome.bits[(couple << 1) + 1])
			next_x = pos[0] + direction[0]
			next_y = pos[1] + direction[1]
			if next_x >= 0 and next_x < len(map) and next_y >=0 and next_y < len(map[next_x]) and map[next_x][next_y] != 1:
				pos = (next_x, next_y)

				temp_map[pos[0]][pos[1]] = 999

		_print_map(temp_map)

	def __test_route(self):
		start = ()
		for x,row in enumerate(map):
			for y,val in enumerate(row):
				if val == 5:
					start = (x, y)

		#print("%d, %d, (%d)" % (start[0], start[1], map[start[0]][start[1]]))
		self.best_fitness_score = 0;
		self.total_fitness_score = 0
		for genome in self.genomes:
			pos = start
			for couple in range(0, len(genome.bits) >> 1):
				# Check whether is wall
				direction = self.__decode_direction(genome.bits[couple << 1], genome.bits[(couple << 1) + 1])
				next_x = pos[0] + direction[0]
				next_y = pos[1] + direction[1]
				#print("direction(%d, %d), next_x(%d), next_y(%d)" % (direction[0], direction[1], next_x, next_y))
				if next_x >= 0 and next_x < len(map) and next_y >=0 and next_y < len(map[next_x]) and map[next_x][next_y] != 1:
					pos = (next_x, next_y)

			genome.fitness = 1 / (abs(pos[0] - 2) + abs(pos[1] - 0) + 1)

			if (genome.fitness == 1.0):
				print("Fina a path!")
				self.__show_path(genome)
				exit(0)

			self.total_fitness_score += genome.fitness
			if genome.fitness > self.best_fitness_score:
				self.best_fitness_score = genome.fitness
			#print(genome.fitness)

			if (map_shadow[pos[0]][pos[1]] == 0):
				map_shadow[pos[0]][pos[1]] = 2
			else:
				map_shadow[pos[0]][pos[1]] += 1

	def __roulette_wheel_selection(self):
		slice = random.random() * self.total_fitness_score
		#print(slice, self.total_fitness_score)
		total = 0
		for genome in self.genomes:
			total += genome.fitness
			if total > slice:
				return genome

		return self.genomes[0]

	def __crossover(self, mum, dad):
		baby1 = Genome()
		baby2 = Genome()
		baby1.clear()
		baby2.clear()
		if random.random() > self.crossover_rate or mum == dad:
			baby1 = dad
			baby2 = mum
			return (baby1, baby2)

		crossover_point = random.randint(0, len(mum.bits) - 1)
		#print(crossover_point)

		for i in range(0, crossover_point):
			baby1.bits.append(mum.bits[i])
			baby2.bits.append(dad.bits[i])

		for i in range(crossover_point, len(mum.bits)):
			baby1.bits.append(dad.bits[i])
			baby2.bits.append(mum.bits[i])

		return (baby1, baby2)

	def __mutate(self, genome):
		for i,val in enumerate(genome.bits):
			if random.random() < self.mutation_rate:
				genome.bits[i] = not genome.bits[i]

_print_map(map_shadow)

bob = GARobot()

for i in range(0, 1000):
	map_shadow = copy.deepcopy(map)
	bob.epoch()
	_print_map(map_shadow)
	#if map_shadow[2][0] > 0:
	#	break;

上面是　python 代码，用以演示前面提到的理论，代码仅作展示用，没有优化，本人对 python 也不熟，你当然可以选任何你喜欢的语言去实现，此代码只用于展示思路和可行性，不具有大的参考价值。

运行效果

运行程序，可以看到整个算法运行过程中，答案的收敛过程，以及发现可行路径的解，当然可以添加一些打印，观察不同算子对算法的影响，以及得到解的过程中，都是怎么进化的。