import numpy as np, random, operator, pandas as pd, matplotlib.pyplot as plt from path_search_algorthms import a_star from decision_tree import decisionTree # klasa tworząca miasta czy też śmietniki class City: def __init__(self, x, y): self.x = x self.y = y # self.dist = distance def distance(self, city): xDis = abs(self.x - city.x) yDis = abs(self.y - city.y) distance = np.sqrt((xDis ** 2) + (yDis ** 2)) return distance def __repr__(self): return "(" + str(self.x) + "," + str(self.y) + ")" # fitness function, # inverse of route distance # we want to minimize distance so the larger the fitness the better class Fitness: def __init__(self, route): self.route = route self.distance = 0 self.fitness= 0.0 def routeDistance(self): if self.distance ==0: pathDistance = 0 for i in range(0, len(self.route)): fromCity = self.route[i] toCity = None if i + 1 < len(self.route): # for returning to point 0? toCity = self.route[i + 1] else: toCity = self.route[0] pathDistance += fromCity.distance(toCity) self.distance = pathDistance return self.distance def routeFitness(self): if self.fitness == 0: self.fitness = 1 / float(self.routeDistance()) return self.fitness # creating one individual - single route from city to city (trash to trash) def createRoute(cityList): route = random.sample(cityList, len(cityList)) return route # creating initial population of given size def initialPopulation(popSize, cityList): population = [] for i in range(0, popSize): population.append(createRoute(cityList)) return population # ranking fitness of given route, output is ordered list with route id and its fitness score def rankRoutes(population): fitnessResults = {} for i in range(0,len(population)): fitnessResults[i] = Fitness(population[i]).routeFitness() return sorted(fitnessResults.items(), key = operator.itemgetter(1), reverse = True) # selecting "mating pool" # we are using here "Firness proportionate selection", its fitness-weighted probability of being selected # moreover we are using elitism to ensure that the best of the best will preserve def selection(popRanked, eliteSize): selectionResults = [] # roulette wheel df = pd.DataFrame(np.array(popRanked), columns=["Index","Fitness"]) df['cum_sum'] = df.Fitness.cumsum() df['cum_perc'] = 100*df.cum_sum/df.Fitness.sum() for i in range(0, eliteSize): # elitism selectionResults.append(popRanked[i][0]) for i in range(0, len(popRanked) - eliteSize): # comparing randomly drawn number to weights for selection for mating pool pick = 100*random.random() for i in range(0, len(popRanked)): if pick <= df.iat[i,3]: selectionResults.append(popRanked[i][0]) break return selectionResults # returns list of route IDs # creating mating pool from list of routes IDs from "selection" def matingPool(population, selectionResults): matingpool = [] for i in range(0, len(selectionResults)): index = selectionResults[i] matingpool.append(population[index]) return matingpool # creating new generation # ordered crossover bc we need to include all locations exactly one time # randomly selecting a subset of the first parent string and then filling the remainder of route # with genes from the second parent in the order in which they appear, without duplicating any genes from the first parent def breed(parent1, parent2): child = [] childP1 = [] childP2 = [] geneA = int(random.random() * len(parent1)) geneB = int(random.random() * len(parent1)) startGene = min(geneA, geneB) endGene = max(geneA, geneB) for i in range(startGene, endGene): # ordered crossover childP1.append(parent1[i]) childP2 = [item for item in parent2 if item not in childP1] child = childP1 + childP2 return child # creating whole offspring population def breedPopulation(matingpool, eliteSize): children = [] length = len(matingpool) - eliteSize pool = random.sample(matingpool, len(matingpool)) # using elitism to retain best genes (routes) for i in range(0,eliteSize): children.append(matingpool[i]) # filling rest generation for i in range(0, length): child = breed(pool[i], pool[len(matingpool)-i-1]) children.append(child) return children # using swap mutation # with specified low prob we swap two cities in route def mutate(individual, mutationRate): for swapped in range(len(individual)): if(random.random() < mutationRate): swapWith = int(random.random() * len(individual)) city1 = individual[swapped] city2 = individual[swapWith] individual[swapped] = city2 individual[swapWith] = city1 return individual # extending mutate function to run through new pop def mutatePopulation(population, mutationRate): mutatedPop = [] for ind in range(0, len(population)): mutatedInd = mutate(population[ind], mutationRate) mutatedPop.append(mutatedInd) return mutatedPop # creating new generation def nextGeneration(currentGen, eliteSize, mutationRate): popRanked = rankRoutes(currentGen) # rank routes in current gen selectionResults = selection(popRanked, eliteSize) # determining potential parents matingpool = matingPool(currentGen, selectionResults) # creating mating pool children = breedPopulation(matingpool, eliteSize) # creating new gen nextGeneration = mutatePopulation(children, mutationRate) # applying mutation to new gen return nextGeneration def geneticAlgorithm(population, popSize, eliteSize, mutationRate, generations): pop = initialPopulation(popSize, population) print("Initial distance: " + str(1 / rankRoutes(pop)[0][1])) for i in range(0, generations): pop = nextGeneration(pop, eliteSize, mutationRate) print("Final distance: " + str(1 / rankRoutes(pop)[0][1])) bestRouteIndex = rankRoutes(pop)[0][0] bestRoute = pop[bestRouteIndex] return bestRoute # tutaj ma być lista kordów potencjalnych śmietników z drzewa decyzyjnego cityList = [] # for i in range(0,25): # cityList.append(City(x=int(random.random() * 200), y=int(random.random() * 200))) # geneticAlgorithm(population=cityList, popSize=100, eliteSize=20, mutationRate=0.01, generations=1000) # plotting the progress def geneticAlgorithmPlot(population, popSize, eliteSize, mutationRate, generations): pop = initialPopulation(popSize, population) progress = [] progress.append(1 / rankRoutes(pop)[0][1]) print("Initial distance: " + str(1 / rankRoutes(pop)[0][1])) for i in range(0, generations): pop = nextGeneration(pop, eliteSize, mutationRate) progress.append(1 / rankRoutes(pop)[0][1]) print("Final distance: " + str(1 / rankRoutes(pop)[0][1])) bestRouteIndex = rankRoutes(pop)[0][0] bestRoute = pop[bestRouteIndex] plt.plot(progress) plt.ylabel('Distance') plt.xlabel('Generation') plt.show() return bestRoute # geneticAlgorithmPlot(population=cityList, popSize=100, eliteSize=20, mutationRate=0.01, generations=1000)