def __init__(self, agents, shelves, orderGoods, graph_nodes, graph):
self.agents = agents
self.shelves = shelves
self.orderGoods = orderGoods
self.graph = graph
self.graph_nodes = graph_nodes
self.path_queues = [MyQUEUE() for i in xrange(NUM_AGENTS)]
self.current_overall_plans = {} # agent_id overall plans
self.initStartgoal()
self.population_size = 100
self.task_chromosome = []
for order_id in xrange(ORDER_NUM):
for goods_class in GOODS_ORDER[order_id]:
self.shelves[int(goods_class / 10)].in_order = order_id
self.shelves[int(
goods_class /
10)].unloading_position = UNLOADING_POSITION[order_id]
self.task_chromosome = self.task_chromosome + [
int(goods_class / 10)
]
# print self.task_chromosome
# raw_input('prompt')
# instance the GA class
self.ga = GA(cross_rate=0.7,
mutation_rate=0.02,
population_size=self.population_size,
init_chromosome=self.task_chromosome,
chromosome_length=len(self.task_chromosome),
fitness_Fun=self.fitnessFun())
self.GA_run(GA_iteration)
self.eachAgentTask()
def run_pop_algos_for_vid():
"run the pop algos for proj4 vid"
# setup data to use
data = Data('abalone', pd.read_csv(r'data/abalone.data', header=None), 8,
False)
# take a sample as results do not matter for this
df = data.df.sample(100)
data.split_data(data_frame=df)
gen_algo = GA(1000, 4, data, max_runs=1000, mutation_rate=1)
print("----------------------- RUNNING THE GA -----------------")
# get chromosome object from GA
bestC = gen_algo.run_GA()
print("Best fitting vector From the GA")
print(bestC.net_vector)
client = NetworkClient(data)
network = NeuralNetwork(data)
new_Net = network.GADEnet(bestC.layers, bestC.net_vector)
print("Printing testing results from the GA")
print(client.testing(new_Net, bestC.outputs, bestC.network))
print("----------------------- GA DONE -----------------")
print("---------------------------------------------------")
print("---------------------------------------------------")
print("---------------------------------------------------")
print("----------------------- RUNNING DE -----------------")
de_algo = DE(10, .7, 2, 4, data, max_runs=100, mutation_rate=.03)
bestC = de_algo.run_DE()
print("Best fitting vector from DE")
print(bestC.net_vector)
client = NetworkClient(data)
network = NeuralNetwork(data)
new_Net = network.GADEnet(bestC.layers, bestC.net_vector)
print("Printing testing results from DE")
print(client.testing(new_Net, bestC.outputs, bestC.network))
print("----------------------- DE DONE -----------------")
def new(self, evt=None):
self.isRunning = False
self.ga = GA(aCrossRate=0.7,
aMutationRage=0.02,
aLifeCount=self.lifeCount,
aGeneLenght=len(self.citys),
aMatchFun=self.matchFun())
def new(self, evt=None):
self.__lock.acquire()
self.__running = False
self.__lock.release()
self.clear()
self.nodes = [] # 节点坐标
self.nodes2 = [] # 节点图片对象
for i in range(self.n):
x = random.random() * (self.width - 60) + 30
y = random.random() * (self.height - 60) + 30
self.nodes.append((x, y))
node = self.canvas.create_oval(
x - self.__r,
y - self.__r,
x + self.__r,
y + self.__r,
fill="#ff0000",
outline="#000000",
tags="node",
)
self.nodes2.append(node)
self.ga = GA(lifeCount=50,
mutationRate=0.05,
judge=self.judge(),
mkLife=self.mkLife(),
xFunc=self.xFunc(),
mFunc=self.mFunc(),
save=self.save())
self.order = range(self.n)
self.line(self.order)
def main():
filename = FILENAMES['berlin']
network = None
if filename == FILENAMES['berlin']:
network = readBerlin('./resources/' + filename)
else:
network = readFile('./resources/' + filename)
gaParam = {
'popSize': 10,
'noGen': 1000,
'network': network
}
problParam = {
'function': pathFunction,
'noNodes': network['noNodes']
}
ga = GA(gaParam, problParam)
ga.initialisation()
ga.evaluation()
bestFitness = []
for i in range(gaParam['noGen'] - 1):
ga.oneGenerationElitism()
bestFitness.append(ga.bestChromosome().fitness)
bestChromosome = ga.bestChromosome()
print(bestChromosome)
plt.plot(bestFitness)
plt.ylabel('Best fitness')
plt.xlabel('Generation')
plt.show()
def __init__(self, data, N, mating_rate=0.7, variation_rate=0.02):
self.data = data
self.scale_N = N # 群体规模N
self.mating_rate = mating_rate
self.variation_rate = variation_rate
self.ga = GA(data, N, mating_rate, variation_rate)
self.distance = 0
def main():
MIN=0
MAX=0
gaParam={'popSize':500,'nrGen':200}
propParam = citire2("file.gml")
for i in range(propParam['n']):
print(propParam['matrix'][i])
print(propParam['degrees'])
print(propParam['edges'])
propParam['function']=modularity
ga = GA(gaParam,propParam)
ga.initialisation()
ga.evaluation()
best = ga.bestChromosome()
fitnees = best.fitness
for i in range(gaParam['nrGen']):
bestSolution = ga.bestChromosome()
#print(bestSolution)
if bestSolution.fitness > fitnees:
best = bestSolution
fitnees = best.fitness
# if i%2 == 0:
# ga.oneGeneration()
# else:
print(bestSolution.fitness)
ga.oneGenerationElitism()
dict=[[]]
x=best.repres
v=[0]*propParam['n']
k=1
for i in range(propParam['n']):
if v[x[i]]==0:
v[x[i]]=k
k+=1
ii=i+1
dict.append([ii])
else:
b=v[x[i]]
ii=i+1
dict[b].append(ii)
print(k-1)
for i in range(k):
print(dict[i])
class TSP():
#city城市列表,init_city初始城市的序号,count次数
def __init__(self, address, node, init_city, count):
self.ADDRESS = address
self.NODE = node
self.INITCITY = init_city
self.Count = count
self.ga = GA(cross_rate=0.7,
variation_rate=0.02,
city_num=len(self.NODE),
population_count=self.Count,
adaptabilty=self.adaptabilty())
#距离
def distance(self, order):
distance = 0
for i in range(self.INITCITY, self.INITCITY - len(order), -1):
distance += self.ADDRESS[order[i]][order[i + 1]]
return distance
#适应度为1/距离
def adaptabilty(self):
return lambda life: 1.0 / self.distance(life.gene)
def run(self, n=0):
while n > 0:
self.ga.next()
distance = self.distance(self.ga.best.gene)
if n % 100 == 0:
print("{}:{}".format(self.ga.generation, distance))
print(self.ga.best.gene)
n -= 1
print("经过%d次迭代，最优解距离为：%f" % (self.ga.generation, distance))
return self.ga.best.gene
def main(file: str):
graph = Graph(file)
alg = GA(graph)
best_route = alg.loop()
print(best_route.gen)
print(-best_route.fitness)
graph.show(best_route.gen)
def __init__(self, lifeCount=100):
self.lifeCount = lifeCount
self.ga = GA(mutationRate=0.9,
lifeCount=self.lifeCount,
days=days_query,
price=price_query,
matchFun=self.matchFun())
def __init__(self,address,node,init_city,count):
self.ADDRESS=address
self.NODE=node
self.INITCITY=init_city
self.Count=count
self.ga=GA(cross_rate=0.7,variation_rate=0.02,city_num=len(self.NODE),
population_count=self.Count,adaptabilty=self.adaptabilty())
def restart(self):
self.canvas.delete("line")
self.canvas.delete("city_num")
self.ga = GA(aCrossRate=0.7,
aMutationRate=0.2,
aLifeNum=self.lifeNum,
aGeneLen=len(self.citys),
aSsess=self.assess())
def __init__(self, searchSet, aLifeCount=100):
self.citys = searchSet
self.lifeCount = aLifeCount
self.ga = GA(aCrossRate=0.9,
aMutationRate=0.07,
aLifeCount=self.lifeCount,
aGeneLength=len(self.citys),
aMatchFun=self.matchFun())
def __init__(self, city_file, aLifeNum = 99, aCrsRate=0.7, aMutaRate=0.7):
self.initCitys(city_file)
self.lifeNum = aLifeNum
self.ga = GA(aCrossRate = aCrsRate,
aMutationRate = aMutaRate,
aLifeNum = self.lifeNum,
aGeneLen = len(self.citys),
aSsess = self.assess())
def __init__(self, aLifeCount = 100,):
self.initCitys()
self.lifeCount = aLifeCount
self.ga = GA(aCrossRate = 0.7,
aMutationRage = 0.02,
aLifeCount = self.lifeCount,
aGeneLenght = len(self.citys),
aMatchFun = self.matchFun())
class TSP(object):
def __init__(self, aLifeCount=100):
self.initCitys()
self.lifeCount = aLifeCount
self.ga = GA(aCrossRate=0.7,
aMutationRate=0.02,
aLifeCount=self.lifeCount,
aGeneLength=len(self.citys),
aMatchFun=self.matchFun())
def initCitys(self):
self.citys = []
#这个文件里是34个城市的经纬度
f = open("distanceMatrix.txt", "r", encoding='UTF-8')
while True:
#一行一行读取
loci = str(f.readline())
if loci:
pass # do something here
else:
break
#用readline读取末尾总会有一个回车，用replace函数删除这个回车
loci = loci.replace("\n", "")
#按照tab键分割
loci = loci.split("\t")
# 中国34城市经纬度读入citys
self.citys.append((float(loci[1]), float(loci[2]), loci[0]))
#order是遍历所有城市的一组序列，如[1,2,3,7,6,5,4,8……]
#distance就是计算这样走要走多长的路
def distance(self, order):
distance = 0.0
#i从-1到32,-1是倒数第一个
for i in range(-1, len(self.citys) - 1):
index1, index2 = order[i], order[i + 1]
city1, city2 = self.citys[index1], self.citys[index2]
distance += math.sqrt((city1[0] - city2[0])**2 +
(city1[1] - city2[1])**2)
return distance
#适应度函数，因为我们要从种群中挑选距离最短的，作为最优解，所以（1/距离）最长的就是我们要求的
def matchFun(self):
return lambda life: 1.0 / self.distance(life.gene)
def run(self, n=0):
while n > 0:
self.ga.next()
distance = self.distance(self.ga.best.gene)
print(("%d : %f") % (self.ga.generation, distance))
print(self.ga.best.gene)
n -= 1
print("经过%d次迭代，最优解距离为：%f" % (self.ga.generation, distance))
print("遍历城市顺序为：")
# print "遍历城市顺序为：", self.ga.best.gene
#打印出我们挑选出的这个序列中
for i in self.ga.best.gene:
print(self.citys[i][2])
def new(self, evt=None):
self.isRunning = False
order = range(len(self.citys))
self.line(order)
self.ga = GA(aCrossRate=0.7,
aMutationRage=0.02,
aIndividualCount=self.individualCount,
aGeneLenght=len(self.citys),
aMatchFun=self.matchFun())
def __init__(self, city, init_city, count):
self.CITY = city
self.INITCITY = init_city
self.Count = count
self.ga = GA(cross_rate=0.7,
variation_rate=0.02,
city_num=len(self.CITY),
population_count=self.Count,
adaptabilty=self.adaptabilty())
def desen(ret):
seed(1)
# plot the function to be optimised
noDim = 1
xref = [[generateNewValue(0, ret['noNodes'] - 1) for _ in range(noDim)]
for _ in range(0, 1000)]
xref.sort()
yref = [fcEval(xi) for xi in xref]
plt.ion()
plt.plot(xref, yref, 'b-')
plt.xlabel('x values')
plt.ylabel('y = f(x) values')
plt.show()
# initialise de GA parameters
# gaParam = {'popSize' : 10, 'noGen' : 3, 'pc' : 0.8, 'pm' : 0.1}
# problem parameters
# problParam = {'min' : MIN, 'max' : MAX, 'function' : fcEval, 'noDim' : noDim, 'noBits' : 8}
# store the best/average solution of each iteration (for a final plot used to anlyse the GA's convergence)
allBestFitnesses = []
allAvgFitnesses = []
generations = []
ga = GA(gaParam, problParam)
ga.initialisation()
ga.evaluation()
for g in range(gaParam['noGen']):
#plotting preparation
allPotentialSolutionsX = [c.repres for c in ga.population]
allPotentialSolutionsY = [c.fitness for c in ga.population]
bestSolX = ga.bestChromosome().repres
bestSolY = ga.bestChromosome().fitness
allBestFitnesses.append(bestSolY)
allAvgFitnesses.append(
sum(allPotentialSolutionsY) / len(allPotentialSolutionsY))
generations.append(g)
plotAFunction(xref, yref, allPotentialSolutionsX,
allPotentialSolutionsY, bestSolX, [bestSolY],
'generation: ' + str(g))
#logic alg
ga.oneGeneration()
# ga.oneGenerationElitism()
# ga.oneGenerationSteadyState()
bestChromo = ga.bestChromosome()
print('Best solution in generation ' + str(g) + ' is: x = ' +
str(bestChromo.repres) + ' f(x) = ' + str(bestChromo.fitness))
plt.ioff()
best, = plt.plot(generations, allBestFitnesses, 'ro', label='best')
mean, = plt.plot(generations, allAvgFitnesses, 'bo', label='mean')
plt.legend([best, (best, mean)], ['Best', 'Mean'])
plt.show()
class TSP(object):
def __init__(
self,
aLifeCount=250,
):
self.initCitys()
self.lifeCount = aLifeCount
self.ga = GA(aCrossRate=0.7,
aMutationRage=0.02,
aLifeCount=self.lifeCount,
aGeneLenght=len(self.citys),
aMatchFun=self.matchFun())
def initCitys(self):
self.citys = []
self.citys.append((16, 3))
self.citys.append((17, 39))
self.citys.append((12, 31))
self.citys.append((10, 60))
self.citys.append((30, 29))
self.citys.append((40, 4))
self.citys.append((10, 38))
self.citys.append((11, 40))
self.citys.append((29, 22))
self.citys.append((55, 45))
self.citys.append((160, 35))
self.citys.append((170, 88))
self.citys.append((120, 31))
self.citys.append((100, 60))
self.citys.append((99, 55))
self.citys.append((78, 87))
self.citys.append((100, 38))
self.citys.append((111, 40))
self.citys.append((64, 22))
self.citys.append((123, 123))
def distance(self, order):
distance = 0.0
for i in range(-1, len(self.citys) - 1):
index1, index2 = order[i], order[i + 1]
city1, city2 = self.citys[index1], self.citys[index2]
distance += math.sqrt((city1[0] - city2[0])**2 +
(city1[1] - city2[1])**2)
return distance
def matchFun(self):
return lambda life: 1.0 / self.distance(life.gene)
def run(self, n=0):
while n > 0:
self.ga.next()
distance = self.distance(self.ga.best.gene)
print(self.ga.generation, float('%.5f' % distance),
self.ga.best.gene)
n -= 1
def new(self, evt=None):
self.isRunning = False
order = range(len(self.citys))
self.line(order)
self.ga = GA(aCrossRate=0.8,
aMutationRage=0.02,
aLifeCount=self.lifeCount,
aGeneLenght=len(self.citys),
aD=self.get_list(),
aMatchFun=self.matchFun())
def main():
ga = GA(gaParam, problParam)
ga.initialisation()
ga.evaluation()
ga.oneGeneration()
bestChromo=ga.bestChromosome()
print('Solutia cea mai buna este: ' + str(afisare(bestChromo.repres)) + ' cost = ' + str(bestChromo.fitness))
def main():
gaParam, problParam = initParams(FILENAMES['dolphins'])
ga = GA(gaParam, problParam)
ga.initialisation()
ga.evaluation()
currentGeneration = 0
bestFitnessArr = []
while currentGeneration <= gaParam['noGen']:
ga.oneGeneration()
bestChromosome = ga.bestChromosome()
print('=== [Gen ' + str(currentGeneration) + '] ===')
print(bestChromosome)
print('Fitness: ' + str(bestChromosome.fitness))
print('Number of communities: ' +
str(getNumberOfCommunities(problParam, bestChromosome.repres)))
print('')
bestFitnessArr.append(bestChromosome.fitness)
currentGeneration += 1
plt.plot(bestFitnessArr)
plt.ylabel('Best fitness')
plt.xlabel('Generation')
plt.show()
def main():
graph = read_graph("exemplu.txt")
print(graph)
# initialise de GA parameters
gaParam = {'popSize': 5, 'noGen': 3000, 'pc': 0.8, 'pm': 0.1}
# problem parameters
problParam = {'noNodes': len(graph), 'graph': graph, 'function': evalPath}
ga = GA(gaParam, problParam)
ga.initialisation()
ga.evaluation()
bestChromosomes = []
bestFitness = []
for g in range(gaParam['noGen']):
# logic alg
#ga.oneGeneration()
ga.oneGenerationElitism()
#ga.oneGenerationSteadyState()
bestChromo = ga.bestChromosome()
bestChromosomes.append(bestChromo)
bestFitness.append(bestChromo.fitness)
print('Best solution in generation ' + str(g) + ' is: f(x) = ' +
str(1 / bestChromo.fitness))
x = []
y = []
for i in range(len(bestFitness)):
x.append(i)
y.append(bestFitness[i])
plt.plot(x, y)
plt.show()
def main():
reader = Reader()
reader._init_("mediumF.txt")
net = reader.readNetwork()
gaParam = {"popSize": 500, "noGen": 500}
problParam = {
'function': roadValue,
'noNodes': net['noNodes'],
'net': net['mat']
}
ga = GA(gaParam, problParam)
ga.initialisation()
ga.evaluation()
stop = False
g = -1
solutions = []
while not stop and g < gaParam['noGen']:
g += 1
ga.oneGenerationElitism()
bestChromo = ga.bestChromosome()
solutions.append(bestChromo)
print('Best solution in generation ' + str(g) + ' is: x = ' +
str(bestChromo.repres) + ' f(x) = ' + str(bestChromo.fitness))
heapify(solutions)
print(str(solutions[0]))
def main():
crtDir = os.getcwd()
filePath = os.path.join(crtDir, 'hardE.txt')
#network = readNetwork1(filePath)
network = readNetwork2(filePath)
gaParam = {'popSize': 100, 'noGen': 100}
problParam = {'network': network, 'function': routeFitness}
ga = GA(gaParam, problParam)
ga.initialisation()
ga.evaluation()
best = []
for g in range(gaParam['noGen']):
#ga.oneGenerationElitism()
ga.oneGenerationSteadyState()
bestChromo = ga.bestChromosome()
print('Generatia de platina ' + str(g) + ' este: x = ' +
str(bestChromo.repres) + '\nf(x) = ' + str(bestChromo.fitness) +
'\nDistanta = ' + str(bestChromo.distance))
best.append(bestChromo.distance)
plt.plot(best)
plt.ylabel('Lungime minima')
plt.xlabel('Generatie')
plt.show()
def main():
#graph = readGraph("inputFiles/easy_01_4.txt")
#print(graph)
#gaParam = {'popSize': 100, 'noGen': 100, 'pc': 0.8, 'pm': 0.1}
#problParam = {'noNodes': len(graph),'graph':graph, 'function': fitness_func}
data = readFromFile("inputFiles/hard_02_52.txt")
gaParam = {'popSize': 100, 'noGen': 5000}
ga = GA(gaParam, data)
ga.initialisation()
ga.evaluation()
bestChromosomes = []
bestFitness = 99999999
bestChromosomeRepres = None
for g in range(gaParam['noGen']):
ga.oneGenerationElitism()
bestChromo = ga.bestChromosome()
if (bestChromo.fitness < bestFitness):
bestChromosomeRepres = bestChromo.repres
bestFitness = bestChromo.fitness
bestChromosomes.append(bestChromo)
print('Generation ' + str(g) + '/\n best chromosome: ' +
str(bestChromo.repres) + '/\n -> fitness: ' +
str(bestChromo.fitness))
print('\n ---------\nBest overall solution: ' + str(bestChromosomeRepres) +
' \n fitness = ' + str(bestFitness))
def worker(self):
ga = GA(5)
initPool = ga.createRandomInitPool(5,5)
for pos in initPool:
#explore it then !!!!
ga.updateMatrixData(pos[0],pos[1],True)
def new(self, evt=None):
self.isRunning = False
order = range(len(self.citys))
self.line(order)
self.ga = GA(aCrossRate=0.65,
aMutationRage=0.035,
aLifeCount=self.lifeCount,
aGeneLenght=len(self.citys),
aMatchFun=self.matchFun())
self.canvas.delete("dis")
self.title("TSP")
def main(file_name, method_name, n_gens, findShortest, run_idx, restore_chkpt):
# read in the data
points = np.genfromtxt(file_name, delimiter=',')
prob = int(file_name[3])
N = points.shape[0]
# method list
baselines = ['random search', 'hill climber']
name2method = {
'random search': random_search,
'hill climber': hill_climber,
'GA': GA
}
if method_name in baselines:
solver = name2method[method_name](points,
findShortest=findShortest,
prob=prob,
run_idx=run_idx)
solver.run(n_gens)
elif method_name == 'GA':
solver = GA(points,
findShortest=findShortest,
prob=prob,
run_idx=run_idx)
solver.run(population_size=100,
n_gens=n_gens,
p_cross=0.3,
p_mut=0.9,
restore_from_chkpt=restore_chkpt)
else:
raise NotImplementedError(
'unknown method: options are \'random search,\' \'hill climber,\' \'GA\''
)
# plot path
path_pts = points[solver.best_path.order.astype(int), :]
plt.plot(path_pts[:, 0],
path_pts[:, 1],
label='{} distance: {}'.format(method_name,
solver.best_path_length),
color='C1',
zorder=0,
linewidth=0.5)
plt.scatter(points[:, 0], points[:, 1], zorder=5)
plt.legend(loc='upper right')
plt.show()
# visualize fitness
plt.plot(solver.fitness_hist, label=method_name)
plt.legend()
plt.xlabel('evaluations')
plt.ylabel('fitness')
plt.show()
def gen_words(langs, words, weightFunc, popsize, generations, mutationProb, avg=True):
out = {}
for word in words:
fitness = getFitnessFunction(langs, word, weightFunc, avg)
population = []
for l in langs:
for wd, wt in l[word].items():
population.append(wd)
popfactor = math.ceil(popsize/len(population))
ga = GA(population * popfactor, fitness, rs, rep, mutationProb, mut)
ga.run(generations)
sortedPop = sorted(ga.population, key=fitness, reverse=True)
out[word] = list(zip(sortedPop, map(fitness, sortedPop)))
print('best for %s: %s (fitness %f)' % (word, out[word][0][0], out[word][0][1]))
return out
def new(self, evt=None):
self.__lock.acquire()
self.__running = False
self.__lock.release()
self.clear()
self.nodes = [] # 节点坐标
self.nodes2 = [] # 节点图片对象
for i in range(self.n):
x = random.random() * (self.width - 60) + 30
y = random.random() * (self.height - 60) + 30
self.nodes.append((x, y))
node = self.canvas.create_oval(x - self.__r,
y - self.__r, x + self.__r, y + self.__r,
fill="#ff0000",
outline="#000000",
tags="node",
)
self.nodes2.append(node)
self.ga = GA(
lifeCount=50,
mutationRate=0.05,
judge=self.judge(),
mkLife=self.mkLife(),
xFunc=self.xFunc(),
mFunc=self.mFunc(),
save=self.save()
)
self.order = range(self.n)
self.line(self.order)
def __init__(self, aLifeCount = 100,):
self.initCitys()
self.lifeCount = aLifeCount
self.ga = GA(aCrossRate = 0.7,
aMutationRage = 0.02,
aLifeCount = self.lifeCount,
aGeneLenght = len(self.citys),
aMatchFun = self.matchFun())
def new(self, evt = None):
self.isRunning = False
order = range(len(self.citys))
self.line(order)
self.ga = GA(aCrossRate = 0.7,
aMutationRage = 0.02,
aLifeCount = self.lifeCount,
aGeneLenght = len(self.citys),
aMatchFun = self.matchFun())
def graphical_mode(tsp_file_path='./data/dj.txt', pop_size=10000, generations=100):
global plt, fig, ax
# matplotlib init
plt.ion()
fig = plt.figure()
ax = fig.add_subplot(1, 1, 1)
# make ga solver
my_ga = GA(file_path=tsp_file_path, pop_size=pop_size, generations=generations)
my_ga.start()
while my_ga.isAlive():
update_plot(my_ga.best_tour)
print('update plot')
time.sleep(15)
# saving model
with open('saving.pkl', 'wr+') as f:
pickle.dump(my_ga.best_tour, f)
return my_ga.best_tour
def singleGA(populationCount, crossRate, murationRate, iteraNum, filename):
cvrp = CVRP()
name, dimension, capacity, CustomerDistance, Requirement = LoadData(filename)
ga = GA(GeneLenght=(dimension-1), PopulationCount=populationCount, CrossRate=crossRate, MurationRate=murationRate, DistanceMat=CustomerDistance, Requirement=Requirement, Capacity=capacity)
ga.initPopulation()
population = copy.copy(ga.population)
#population.append([21, 31, 19, 17, 13, 7, 26, 12, 1, 16, 30, 27, 24, 29, 18, 8, 9, 22, 15, 10, 25, 5, 20, 14, 28, 11, 4, 23, 3, 2, 6])
bestGene = []
minDistance = 100000
minItera = 0
for itera in range(iteraNum):
newPopulation = []
while True:
selectNum1, selectNum2, bestNum, distance, bestPath, bestFit = ga.selectGene(population)
child1, child2 = ga.cross(selectNum1, selectNum2)
newPopulation.extend(ga.muration([child1, child2]))
if len(newPopulation) > populationCount:
newPopulation.append(population[bestNum])
bestGene = copy.copy(population[bestNum])
if distance < minDistance:
minItera = itera
minDistance = distance
population = copy.copy(newPopulation)
break
print minItera, bestPath, minDistance, bestFit
return minItera, bestPath, minDistance, bestFit
class TSP(object):
def __init__(self, aLifeCount = 100,):
self.initCitys()
self.lifeCount = aLifeCount
self.ga = GA(aCrossRate = 0.7,
aMutationRage = 0.02,
aLifeCount = self.lifeCount,
aGeneLenght = len(self.citys),
aMatchFun = self.matchFun())
def initCitys(self):
self.citys = []
"""
for i in range(34):
x = random.randint(0, 1000)
y = random.randint(0, 1000)
self.citys.append((x, y))
"""
#中国34城市经纬度
self.citys.append((116.46, 39.92))
self.citys.append((117.2,39.13))
self.citys.append((121.48, 31.22))
self.citys.append((106.54, 29.59))
self.citys.append((91.11, 29.97))
self.citys.append((87.68, 43.77))
self.citys.append((106.27, 38.47))
self.citys.append((111.65, 40.82))
self.citys.append((108.33, 22.84))
self.citys.append((126.63, 45.75))
self.citys.append((125.35, 43.88))
self.citys.append((123.38, 41.8))
self.citys.append((114.48, 38.03))
self.citys.append((112.53, 37.87))
self.citys.append((101.74, 36.56))
self.citys.append((117,36.65))
self.citys.append((113.6,34.76))
self.citys.append((118.78, 32.04))
self.citys.append((117.27, 31.86))
self.citys.append((120.19, 30.26))
self.citys.append((119.3, 26.08))
self.citys.append((115.89, 28.68))
self.citys.append((113, 28.21))
self.citys.append((114.31, 30.52))
self.citys.append((113.23, 23.16))
self.citys.append((121.5, 25.05))
self.citys.append((110.35, 20.02))
self.citys.append((103.73, 36.03))
self.citys.append((108.95, 34.27))
self.citys.append((104.06, 30.67))
self.citys.append((106.71, 26.57))
self.citys.append((102.73, 25.04))
self.citys.append((114.1, 22.2))
self.citys.append((113.33, 22.13))
def distance(self, order):
distance = 0.0
for i in range(-1, len(self.citys) - 1):
index1, index2 = order[i], order[i + 1]
city1, city2 = self.citys[index1], self.citys[index2]
distance += math.sqrt((city1[0] - city2[0]) ** 2 + (city1[1] - city2[1]) ** 2)
"""
R = 6371.004
Pi = math.pi
LatA = city1[1]
LatB = city2[1]
MLonA = city1[0]
MLonB = city2[0]
C = math.sin(LatA*Pi / 180) * math.sin(LatB * Pi / 180) + math.cos(LatA * Pi / 180) * math.cos(LatB * Pi / 180) * math.cos((MLonA - MLonB) * Pi / 180)
D = R * math.acos(C) * Pi / 100
distance += D
"""
return distance
def matchFun(self):
return lambda life: 1.0 / self.distance(life.gene)
def run(self, n = 0):
while n > 0:
self.ga.next()
distance = self.distance(self.ga.best.gene)
print (("%d : %f") % (self.ga.generation, distance))
n -= 1
class TSP_WIN(object):
def __init__(self, aRoot, aLifeCount = 1500, aWidth = 1000, aHeight = 600):
self.root = aRoot
self.lifeCount = aLifeCount
self.width = aWidth
self.height = aHeight
self.canvas = Tkinter.Canvas(
self.root,
width = self.width,
height = self.height,
)
self.canvas.pack(expand = Tkinter.YES, fill = Tkinter.BOTH)
self.bindEvents()
self.initCitys()
self.new()
self.title("TSP")
def initCitys(self):
self.citys = []
global tuple
txtpath=r"/home/wlw/TSP/st70.txt"
fp=open(txtpath)
arr=[]
for lines in fp.readlines():
lines=lines.replace("\n","").split(" ")
del lines[0]
lines = [float(i) for i in lines]
#print lines
lines=tuple(lines)
arr.append(lines)
fp.close()
tuple=tuple(arr)
self.citys = tuple
#坐标变换
minX, minY = self.citys[0][0], self.citys[0][1]
maxX, maxY = minX, minY
for city in self.citys[1:]:
if minX > city[0]:
minX = city[0]
if minY > city[1]:
minY = city[1]
if maxX < city[0]:
maxX = city[0]
if maxY < city[1]:
maxY = city[1]
w = maxX - minX
h = maxY - minY
xoffset = 30
yoffset = 30
ww = self.width - 2 * xoffset
hh = self.height - 2 * yoffset
xx = ww / float(w)
yy = hh / float(h)
r = 5
self.nodes = []
self.nodes2 = []
for city in self.citys:
x = (city[0] - minX ) * xx + xoffset
y = hh - (city[1] - minY) * yy + yoffset
self.nodes.append((x, y))
node = self.canvas.create_oval(x - r, y -r, x + r, y + r,
fill = "#ff0000",
outline = "#000000",
tags = "node",)
self.nodes2.append(node)
def distance(self, order):
distance = 0.0
for i in range(-1, len(self.citys) - 1):
index1, index2 = order[i], order[i + 1]
city1, city2 = self.citys[index1], self.citys[index2]
distance += math.sqrt((city1[0] - city2[0]) ** 2 + (city1[1] - city2[1]) ** 2)
return distance
def matchFun(self):
return lambda life: 1.0 / self.distance(life.gene)
def title(self, text):
self.root.title(text)
def line(self, order):
self.canvas.delete("line")
for i in range(-1, len(order) -1):
p1 = self.nodes[order[i]]
p2 = self.nodes[order[i + 1]]
self.canvas.create_line(p1, p2, fill = "#000000", tags = "line")
def bindEvents(self):
self.root.bind("n", self.new)
self.root.bind("g", self.start)
self.root.bind("s", self.stop)
def new(self, evt = None):
self.isRunning = False
order = range(len(self.citys))
self.line(order)
self.ga = GA(aCrossRate = 0.7,
aMutationRagemax = 0.05,
aMutationRagemin = 0.001,
aLifeCount = self.lifeCount,
aGeneLenght = len(self.citys),
aMatchFun = self.matchFun())
def start(self, evt = None):
self.isRunning = True
while self.isRunning:
self.ga.next()
distance = self.distance(self.ga.best.gene)
print self.ga.best.gene
self.line(self.ga.best.gene)
self.title("TSP-gen: %d" % self.ga.generation)
print (("%d : %f") % (self.ga.generation, distance))
self.canvas.update()
def stop(self, evt = None):
self.isRunning = False
def mainloop(self):
self.root.mainloop()
class MyTSP(object):
"TSP"
def __init__(self, root, width=800, height=600, n=32):
self.root = root
self.width = width
self.height = height
self.n = n
self.canvas = Tkinter.Canvas(
root,
width=self.width,
height=self.height,
bg="#ffffff",
xscrollincrement=1,
yscrollincrement=1
)
self.canvas.pack(expand=Tkinter.YES, fill=Tkinter.BOTH)
self.title("TSP")
self.__r = 5
self.__t = None
self.__lock = threading.RLock()
self.__bindEvents()
self.new()
def __bindEvents(self):
self.root.bind("q", self.quite)
self.root.bind("n", self.new)
self.root.bind("e", self.evolve)
self.root.bind("s", self.stop)
def title(self, s):
self.root.title(s)
def new(self, evt=None):
self.__lock.acquire()
self.__running = False
self.__lock.release()
self.clear()
self.nodes = [] # 节点坐标
self.nodes2 = [] # 节点图片对象
for i in range(self.n):
x = random.random() * (self.width - 60) + 30
y = random.random() * (self.height - 60) + 30
self.nodes.append((x, y))
node = self.canvas.create_oval(x - self.__r,
y - self.__r, x + self.__r, y + self.__r,
fill="#ff0000",
outline="#000000",
tags="node",
)
self.nodes2.append(node)
self.ga = GA(
lifeCount=50,
mutationRate=0.05,
judge=self.judge(),
mkLife=self.mkLife(),
xFunc=self.xFunc(),
mFunc=self.mFunc(),
save=self.save()
)
self.order = range(self.n)
self.line(self.order)
def distance(self, order):
"得到当前顺序下连线总长度"
distance = 0
for i in range(-1, self.n - 1):
i1, i2 = order[i], order[i + 1]
p1, p2 = self.nodes[i1], self.nodes[i2]
distance += math.sqrt((p1[0] - p2[0]) ** 2 + (p1[1] - p2[1]) ** 2)
return distance
def mkLife(self):
def f():
lst = range(self.n)
random.shuffle(lst)
return lst
return f
def judge(self):
"评估函数"
return lambda lf, av=100: 1.0 / self.distance(lf.gene)
def xFunc(self):
"交叉函数"
def f(lf1, lf2):
p1 = random.randint(0, self.n - 1)
p2 = random.randint(self.n - 1, self.n)
g1 = lf2.gene[p1:p2] + lf1.gene
# g2 = lf1.gene[p1:p2] + lf2.gene
g11 = []
for i in g1:
if i not in g11:
g11.append(i)
return g11
return f
def mFunc(self):
"变异函数"
def f(gene):
p1 = random.randint(0, self.n - 2)
p2 = random.randint(self.n - 2, self.n - 1)
gene[p1], gene[p2] = gene[p2], gene[p1]
return gene
return f
def save(self):
def f(lf, gen):
pass
return f
def evolve(self, evt=None):
self.__lock.acquire()
self.__running = True
self.__lock.release()
self.__start_time = time.time()
while self.__running:
self.ga.next()
self.line(self.ga.best.gene)
self.title("TSP - gen: %d, time: %d" % (self.ga.generation, time.time() - self.__start_time))
self.canvas.update()
self.__t = None
def line(self, order):
"将节点按 order 顺序连线"
self.canvas.delete("line")
def line2(i1, i2):
p1, p2 = self.nodes[i1], self.nodes[i2]
self.canvas.create_line(p1, p2, fill="#000000", tags="line")
return i2
reduce(line2, order, order[-1])
def clear(self):
for item in self.canvas.find_all():
self.canvas.delete(item)
def quite(self, evt):
self.__lock.acquire()
self.__running = False
self.__lock.release()
sys.exit()
def stop(self, evt):
self.__lock.acquire()
self.__running = False
self.__lock.release()
def mainloop(self):
self.root.mainloop()
class MyVRP(object):
"TSP"
def __init__(self, root, width=800, height=600, n=31):
self.root = root
self.width = width
self.height = height
self.n = n
self.condition = 2000
self.distance_dict = {}
self.canvas = Tkinter.Canvas(
root,
width=self.width,
height=self.height,
bg="#ffffff",
xscrollincrement=1,
yscrollincrement=1
)
self.canvas.pack(expand=Tkinter.YES, fill=Tkinter.BOTH)
self.title("TSP")
self.__r = 5
self.__t = None
self.__lock = threading.RLock()
self.__bindEvents()
self.new()
def __bindEvents(self):
self.root.bind("q", self.quite)
self.root.bind("n", self.new)
self.root.bind("e", self.evolve)
self.root.bind("s", self.stop)
def title(self, s):
self.root.title(s)
def new(self, evt=None):
self.__lock.acquire()
self.__running = False
self.__lock.release()
self.clear()
self.nodes = [] # 节点坐标
self.nodes2 = [] # 节点图片对象
x, y = self.width, self.height
self.start = (x, y)
self.canvas.create_oval(x - self.__r,
y - self.__r, x + self.__r, y + self.__r,
fill="#00ff00",
outline="#000000",
tags="O",
)
for i in range(self.n):
x = random.random() * (self.width - 60) + 30
y = random.random() * (self.height - 60) + 30
self.nodes.append((x, y))
node = self.canvas.create_oval(x - self.__r,
y - self.__r, x + self.__r, y + self.__r,
fill="#ff0000",
outline="#000000",
tags="node",
)
self.nodes2.append(node)
self.ga = GA(
lifeCount=50,
mutationRate=0.05,
judge=self.judge(),
mkLife=self.mkLife(),
xFunc=self.xFunc(),
mFunc=self.mFunc(),
save=self.save()
)
self.order = range(self.n)
init_life = Life(self, self.order)
jg = self.judge()
jg(init_life)
self.line(init_life)
def distance(self, order):
"得到当前顺序下连线总长度"
distance = 0
for i in range(-1, self.n - 1):
i1, i2 = order[i], order[i + 1]
p1, p2 = self.nodes[i1], self.nodes[i2]
distance += math.sqrt((p1[0] - p2[0]) ** 2 + (p1[1] - p2[1]) ** 2)
return distance
def mkLife(self):
def f():
lst = range(self.n)
random.shuffle(lst)
return lst
return f
def judge(self):
"评估函数"
def f(lf, av=100):
lf.separate_indexs = []
path = lf.gene
path_len = len(lf.gene) # 路径长度，不包括起点
i = 0 # 路径中 node 的指针
p1 = self.start
total_distance = 0
one_distance = 0
while i < path_len:
p2 = self.nodes[path[i]]
# if (p1, p2) not in self.distance_dict:
# self.distance_dict[(p1, p2)] = math.sqrt((p1[0] - p2[0]) ** 2 + (p1[1] - p2[1]) ** 2)
# distance = self.distance_dict[(p1, p2)]
distance = math.sqrt((p1[0] - p2[0]) ** 2 + (p1[1] - p2[1]) ** 2)
if one_distance + distance > self.condition:
# 重置迭代变量
if p1 == self.start:
raise RuntimeError("point{}far from{}".format(p2, p1))
one_distance = 0
p1 = self.start
lf.separate_indexs.append(i)
else:
p1 = p2
one_distance += distance
total_distance += distance
i += 1
lf.set_distance(total_distance)
lf.separate_indexs.append(i)
return 1 / (len(lf.separate_indexs) * 0 + total_distance)
# return lambda lf, av=100: 1.0 / self.distance(lf.gene)
return f
def xFunc(self):
"交叉函数"
def f(lf1, lf2):
p1 = random.randint(0, self.n - 1)
p2 = random.randint(self.n - 1, self.n)
g1 = lf2.gene[p1:p2] + lf1.gene
# g2 = lf1.gene[p1:p2] + lf2.gene
g11 = []
for i in g1:
if i not in g11:
g11.append(i)
return g11
return f
def mFunc(self):
"变异函数"
def f(gene):
p1 = random.randint(0, self.n - 2)
p2 = random.randint(self.n - 2, self.n - 1)
gene[p1], gene[p2] = gene[p2], gene[p1]
return gene
return f
def save(self):
def f(lf, gen):
pass
return f
def evolve(self, evt=None):
self.__lock.acquire()
self.__running = True
self.__lock.release()
self.__start_time = time.time()
while self.__running:
self.ga.next()
self.line(self.ga.best)
self.title("TSP - gen: %d, time: %d" % (self.ga.generation, time.time() - self.__start_time))
self.canvas.update()
self.__t = None
def line(self, life):
order = life.gene
"将节点按 order 顺序连线 以life.separete_indexs 分割"
self.canvas.delete("line")
def line2(i1, i2):
p1 = self.start if i1 == -1 else self.nodes[i1]
p2 = self.nodes[i2]
self.canvas.create_line(p1, p2, fill="#000000", tags="line")
return i2
start_number = 0
for i in life.separate_indexs:
reduce(line2, order[start_number:i], -1)
start_number = i
def clear(self):
for item in self.canvas.find_all():
self.canvas.delete(item)
def quite(self, evt):
self.__lock.acquire()
self.__running = False
self.__lock.release()
sys.exit()
def stop(self, evt):
self.__lock.acquire()
self.__running = False
self.__lock.release()
def mainloop(self):
self.root.mainloop()
class TSP(object):
def __init__(self, aLifeCount = 1500,):
self.initCitys()
self.lifeCount = aLifeCount
self.ga = GA(aCrossRate = 0.8,
aMutationRagemax = 0.5,
aMutationRagemin = 0.08,
aLifeCount = self.lifeCount,
aGeneLenght = len(self.citys),
aMatchFun = self.matchFun())
def initCitys(self):
self.citys = []
global tuple
txtpath=r"/home/wlw/TSP/st70.txt"
fp=open(txtpath)
arr=[]
for lines in fp.readlines():
lines=lines.replace("\n","").split(" ")
del lines[0]
lines = [float(i) for i in lines]
#print lines
lines=tuple(lines)
arr.append(lines)
fp.close()
tuple=tuple(arr)
self.citys = tuple
def distance(self, order):
distance = 0.0
for i in range(-1, len(self.citys) - 1):
index1, index2 = order[i], order[i + 1]
city1, city2 = self.citys[index1], self.citys[index2]
distance += math.sqrt((city1[0] - city2[0]) ** 2 + (city1[1] - city2[1]) ** 2)
"""
R = 6371.004
Pi = math.pi
LatA = city1[1]
LatB = city2[1]
MLonA = city1[0]
MLonB = city2[0]
C = math.sin(LatA*Pi / 180) * math.sin(LatB * Pi / 180) + math.cos(LatA * Pi / 180) * math.cos(LatB * Pi / 180) * math.cos((MLonA - MLonB) * Pi / 180)
D = R * math.acos(C) * Pi / 100
distance += D
"""
return distance
def matchFun(self):
return lambda life: 1.0 / self.distance(life.gene)
def run(self, n = 0):
while n > 0:
self.ga.next()
distance = self.distance(self.ga.best.gene)
print self.ga.best.gene
print (("%d : %f") % (self.ga.generation, distance))
n -= 1
def __init__(self):
GA.__init__(self)
self.prevSolution = None
self.prevAvg = -1
self.currentAvg = -1
self.make_next_gen()
print self.pop
# print self.bests
print self.best
if __name__ == "__main__":
from GA import GA
ss = []
gs = []
for i in range(10):
pop = [''.join(str(random.choice(['1','0'])) for _ in xrange(20)) for _ in xrange(20) ]
s = SA(e=True,func=k_fit,n=20,p=20,mu=0.0)
s.pop = pop
s.run(100)
g = GA(func = k_fit,n=20, p =20,e=True, mu=0.0)
g.pop = pop
g.run(100)
ss.append(s.bests_f)
gs.append(g.bests_f)
#plt.plot(s.av_f)
#plt.plot(g.av_f)
# plt.plot(s.bests_f)
# plt.plot(g.bests_f)
# plt.show()
# pass
ss = reduce(np.add,ss)
gs = reduce(np.add,gs)
plt.plot(map(lambda x: x/10., ss))
plt.plot(map(lambda x: x/10., gs))
def doubleGA(populationCount, crossRate1, murationRate1, crossRate2, murationRate2, iteraNum, filename):
cvrp = CVRP()
name, dimension, capacity, CustomerDistance, Requirement = LoadData(filename)
ga1 = GA(GeneLenght=(dimension-1), PopulationCount=populationCount, CrossRate=crossRate1, MurationRate=murationRate1, DistanceMat=CustomerDistance, Requirement=Requirement, Capacity=capacity)
ga2 = GA(GeneLenght=(dimension-1), PopulationCount=populationCount, CrossRate=crossRate2, MurationRate=murationRate2, DistanceMat=CustomerDistance, Requirement=Requirement, Capacity=capacity)
ga1.initPopulation()
ga2.initPopulation()
population1 = copy.copy(ga1.population)
population2 = copy.copy(ga2.population)
bestGene = []
minDistance = 100000
minItera = 0
for itera in range(0,iteraNum):
newPopulation1 = []
newPopulation2 = []
while True:
#选择两个父亲，生成两个子代后变异放入新种群
selectNum1, selectNum2, bestNum1, distance1, bestPath1, bestFit1 = ga1.selectGene(population1)
child1, child2 = ga1.cross(selectNum1, selectNum2)
newPopulation1.extend(ga1.muration([child1, child2]))
selectNum1, selectNum2, bestNum2, distance2, bestPath2, bestFit2 = ga2.selectGene(population2)
child1, child2 = ga2.cross(selectNum1, selectNum2)
newPopulation2.extend(ga2.muration([child1, child2]))
#当数量超过设定值，交换两个平行种群的解
if len(newPopulation1) > populationCount:
selectNum1, selectNum2, bestNum1, distance1, bestPath1, bestFit1 = ga1.selectGene(newPopulation1)
selectNum1, selectNum2, bestNum2, distance2, bestPath2, bestFit2 = ga2.selectGene(newPopulation2)
exPopulation1 = []
exPopulation2 = []
exNum1 = range(len(newPopulation1)-1)
exNum2 = range(len(newPopulation2)-1)
random.shuffle(exNum1)
random.shuffle(exNum2)
exPopulation1.append(newPopulation2[bestNum2])
exPopulation2.append(newPopulation1[bestNum1])
num = random.randint(5,len(newPopulation1)-5)
count = 0
for i in range(len(newPopulation1)):
if i != bestNum1:
if i in exNum1:
if count < num:
exPopulation2.append(newPopulation1[i])
else:
exPopulation1.append(newPopulation1[i])
else:
exPopulation1.append(newPopulation1[i])
count = count + 1
if newPopulation1[bestNum1] in exPopulation1:
exPopulation1.remove(newPopulation1[bestNum1])
count = 0
for i in range(len(newPopulation2)):
if i != bestNum2:
if i in exNum2:
if count < num:
exPopulation1.append(newPopulation2[i])
else:
exPopulation2.append(newPopulation2[i])
else:
exPopulation2.append(newPopulation2[i])
count = count + 1
if newPopulation2[bestNum2] in exPopulation2:
exPopulation2.remove(newPopulation2[bestNum2])
if distance1 < minDistance:
minItera = itera
minDistance = distance1
bestFit = bestFit1
bestPath =copy.copy(bestPath1)
if distance2 < minDistance:
minItera = itera
minDistance = distance2
bestFit = bestFit2
bestPath =copy.copy(bestPath2)
Population1 = copy.copy(exPopulation1)
Population2 = copy.copy(exPopulation2)
break
print minItera, bestPath, minDistance, bestFit
return minItera, bestPath, minDistance, bestFit
mutation = 0.3
copyFraction = 0.4
dicHour = {key : 0 for key in xrange(8,20)}
dicDepart = {key[0]: 0 for key in graph.keys()}
dicArriv = {key[0]: 0 for key in graph.keys()}
dicPassagenrs = {key : 0 for key in xrange(1,9)}
for r in requests:
dicHour[r.eStart/60] += 1
dicDepart[r.startLocation] += 1
dicPassagenrs[r.passengers] += 1
dicArriv[r.endLocation] += 1
#run GA
test = GA(nReq, population, breeds, variability, mutation, copyFraction, objFunction)
best = test.run()
#best = (0,[6, 6, 1, 2, 17, 7, 5, 5, 16, 14, 18, 5, 19, 10, 5, 20, 16, 10, 1, 5, 14, 16, 16, 1, 16, 4, 14, 18, 7, 9, 13, 15, 11, 18, 3, 20, 11, 7, 2, 6, 16, 15, 17, 11, 1, 5, 7, 19, 13, 10])
#Outputs
#Benchmark distribution
print("\n>>>> HOURS <<<<")
for k in dicHour.keys():
print ("%d -> %d" % (k, dicHour[k]))
print("\n>>>> DEPARTURE <<<<")
for k in dicDepart.keys():
print ("%s -> %d" % (k, dicDepart[k]))
print("\n>>>> ARRIVED <<<<")
class TSP_WIN(object):
def __init__(self, aRoot, aLifeCount = 100, aWidth = 560, aHeight = 330):
self.root = aRoot
self.lifeCount = aLifeCount
self.width = aWidth
self.height = aHeight
self.canvas = Tkinter.Canvas(
self.root,
width = self.width,
height = self.height,
)
self.canvas.pack(expand = Tkinter.YES, fill = Tkinter.BOTH)
self.bindEvents()
self.initCitys()
self.new()
self.title("TSP")
def initCitys(self):
self.citys = []
#中国34城市经纬度
self.citys.append((116.46, 39.92))
self.citys.append((117.2,39.13))
self.citys.append((121.48, 31.22))
self.citys.append((106.54, 29.59))
self.citys.append((91.11, 29.97))
self.citys.append((87.68, 43.77))
self.citys.append((106.27, 38.47))
self.citys.append((111.65, 40.82))
self.citys.append((108.33, 22.84))
self.citys.append((126.63, 45.75))
self.citys.append((125.35, 43.88))
self.citys.append((123.38, 41.8))
self.citys.append((114.48, 38.03))
self.citys.append((112.53, 37.87))
self.citys.append((101.74, 36.56))
self.citys.append((117,36.65))
self.citys.append((113.6,34.76))
self.citys.append((118.78, 32.04))
self.citys.append((117.27, 31.86))
self.citys.append((120.19, 30.26))
self.citys.append((119.3, 26.08))
self.citys.append((115.89, 28.68))
self.citys.append((113, 28.21))
self.citys.append((114.31, 30.52))
self.citys.append((113.23, 23.16))
self.citys.append((121.5, 25.05))
self.citys.append((110.35, 20.02))
self.citys.append((103.73, 36.03))
self.citys.append((108.95, 34.27))
self.citys.append((104.06, 30.67))
self.citys.append((106.71, 26.57))
self.citys.append((102.73, 25.04))
self.citys.append((114.1, 22.2))
self.citys.append((113.33, 22.13))
#坐标变换
minX, minY = self.citys[0][0], self.citys[0][1]
maxX, maxY = minX, minY
for city in self.citys[1:]:
if minX > city[0]:
minX = city[0]
if minY > city[1]:
minY = city[1]
if maxX < city[0]:
maxX = city[0]
if maxY < city[1]:
maxY = city[1]
w = maxX - minX
h = maxY - minY
xoffset = 30
yoffset = 30
ww = self.width - 2 * xoffset
hh = self.height - 2 * yoffset
xx = ww / float(w)
yy = hh / float(h)
r = 5
self.nodes = []
self.nodes2 = []
for city in self.citys:
x = (city[0] - minX ) * xx + xoffset
y = hh - (city[1] - minY) * yy + yoffset
self.nodes.append((x, y))
node = self.canvas.create_oval(x - r, y -r, x + r, y + r,
fill = "#ff0000",
outline = "#000000",
tags = "node",)
self.nodes2.append(node)
def distance(self, order):
distance = 0.0
for i in range(-1, len(self.citys) - 1):
index1, index2 = order[i], order[i + 1]
city1, city2 = self.citys[index1], self.citys[index2]
distance += math.sqrt((city1[0] - city2[0]) ** 2 + (city1[1] - city2[1]) ** 2)
return distance
def matchFun(self):
return lambda life: 1.0 / self.distance(life.gene)
def title(self, text):
self.root.title(text)
def line(self, order):
self.canvas.delete("line")
for i in range(-1, len(order) -1):
p1 = self.nodes[order[i]]
p2 = self.nodes[order[i + 1]]
self.canvas.create_line(p1, p2, fill = "#000000", tags = "line")
def bindEvents(self):
self.root.bind("n", self.new)
self.root.bind("g", self.start)
self.root.bind("s", self.stop)
def new(self, evt = None):
self.isRunning = False
order = range(len(self.citys))
self.line(order)
self.ga = GA(aCrossRate = 0.7,
aMutationRage = 0.02,
aLifeCount = self.lifeCount,
aGeneLenght = len(self.citys),
aMatchFun = self.matchFun())
def start(self, evt = None):
self.isRunning = True
while self.isRunning:
self.ga.next()
distance = self.distance(self.ga.best.gene)
self.line(self.ga.best.gene)
self.title("TSP-gen: %d" % self.ga.generation)
self.canvas.update()
def stop(self, evt = None):
self.isRunning = False
def mainloop(self):
self.root.mainloop()
