示例#1
0
def selection(gs: list, k: int):
    gs1 = []
    s = 0
    for i in gs:
        fitness = fitness_function(i)
        gs1.append([i, fitness])
        s += fitness
    gs1.sort(key=lambda x: -x[1])
    for i in gs1:
        i[1] = (i[1] * 100) / s
    g = []
    #since, k= 8
    for i in range(k // 2):
        x = np.random.randint(0, 50)
        #selecting first one in pair
        for j in gs1:
            if x - j[1] < 0:
                g.append(j[0])
                break
            x -= j[1]
        #selecting second one in pair
        r = g[-1]
        while g[-1] == r:
            x = np.random.randint(0, 50)
            for j in gs1:
                if x - j[1] < 0:
                    r = j[0]
                    break
                x -= j[1]
        g.append(r)
    return g
	def reduction(self):
		Fit = fitness_function()

		for x in xrange(0,len(self.descendants)):
			if self.descendants[x]['value'] > Fit.min and self.descendants[x]['value'] <= Fit.max:
				self.population.append(self.descendants[x])

		self.population.sort(reverse=True)
		self.population = self.population[:self.pop_size]
示例#3
0
    def reduction(self):
        Fit = fitness_function()

        for x in xrange(0, len(self.descendants)):
            if self.descendants[x]['value'] > Fit.min and self.descendants[x][
                    'value'] <= Fit.max:
                self.population.append(self.descendants[x])

        self.population.sort(reverse=True)
        self.population = self.population[:self.pop_size]
	def pop_max(self):
		Fit = fitness_function()
		print '####################################################'
		print 'Макс. значение популяции в точке x=',
		print self.population[0]['value']
		print 'f(x)=',
		print self.population[0]['fitness'],' / ',Fit.optium
		print '[ min / max ] [',
		print self.population[-1]['value'],';',self.population[0]['value'],']'
		print '####################################################'
		print
		print
示例#5
0
 def pop_max(self):
     Fit = fitness_function()
     print '####################################################'
     print 'Макс. значение популяции в точке x=',
     print self.population[0]['value']
     print 'f(x)=',
     print self.population[0]['fitness'], ' / ', Fit.optium
     print '[ min / max ] [',
     print self.population[-1]['value'], ';', self.population[0][
         'value'], ']'
     print '####################################################'
     print
     print
	def mutation(self):
		Fit = fitness_function()

		for x in xrange(0,len(self.descendants)):
			chromosome = float_to_binary( self.descendants[x]['value'])
			gen = random.randint(0,63)

			if chromosome[gen] == '0':
				chromosome = chromosome[:gen] + '1' + chromosome[gen+1:]
			else:
				chromosome = chromosome[:gen] + '0' + chromosome[gen+1:]

			self.descendants[x]['value'] = binary_to_float(chromosome)
			self.descendants[x]['fitness'] = Fit.f(self.descendants[x]['value'])
示例#7
0
def genetic_algorithm():
    gs = []
    k = 30
    for i in range(k):
        gs.append(random_generation())
    for _ in range(1000):
        gs1 = selection(gs, k)
        for i in range(0, len(gs1), 2):
            gs1[i], gs1[i + 1] = crossover(gs1[i], gs1[i + 1])
        for i in range(len(gs1)):
            gs1[i] = mutation(gs1[i])
        gs = gs1[:]
        gs.sort(key=lambda x: -fitness_function(x))
        m = fitness_function(gs[0])
        s = gs[0]
        if m == 243:
            print(
                "5 Best solution along with their fitnesses of the final population"
            )
            print("Sudoku 1: Solution Found!!")
            printSudoku(s)
            print("Fitness Value: {}".format(fitness_function(gs[0])))
            for j in range(1, 5):
                print("Sudoku {}:".format(j + 1))
                printSudoku(gs[i])
                print("Fitness Value: {}".format(fitness_function(gs[i])))
            break
    else:
        print(
            "5 Best solution along with their fitnesses of the final population"
        )
        for i in range(5):
            print("Sudoku {}:".format(i + 1))
            printSudoku(gs[i])
            print("Fitness Value: {}".format(fitness_function(gs[i])))
            print('')
示例#8
0
    def mutation(self):
        Fit = fitness_function()

        for x in xrange(0, len(self.descendants)):
            chromosome = float_to_binary(self.descendants[x]['value'])
            gen = random.randint(0, 63)

            if chromosome[gen] == '0':
                chromosome = chromosome[:gen] + '1' + chromosome[gen + 1:]
            else:
                chromosome = chromosome[:gen] + '0' + chromosome[gen + 1:]

            self.descendants[x]['value'] = binary_to_float(chromosome)
            self.descendants[x]['fitness'] = Fit.f(
                self.descendants[x]['value'])
示例#9
0
    def __init__(self, size, parents_n):
        self.pop_size = size

        if parents_n > 100:
            parents_n = 100

        self.parents_num = parents_n
        while size > 0:
            Fit = fitness_function()
            person = {}
            person['value'] = Fit.min + random.random() * (Fit.max - Fit.min)
            person['fitness'] = Fit.f(person['value'])
            size -= 1
            self.population.append(person)
            self.population.sort(reverse=True)
	def __init__(self,size,parents_n): 
		self.pop_size = size

		if parents_n > 100:
			parents_n = 100

		self.parents_num = parents_n
		while size > 0:
			Fit = fitness_function() 
			person = {}
			person['value'] = Fit.min + random.random() * (Fit.max-Fit.min)
			person['fitness'] = Fit.f(person['value'])
			size -= 1
			self.population.append(person)
			self.population.sort(reverse=True)
示例#11
0
def vrp_ga(m=0.2, gen=500, N=100, best_N=5, setup=1, plot_folder="plots/"):
    """
    Complete function, optimizing the vehicle routing problem using genetic
    algorithms and a custom crossover/mutation part.

    Args
        m                   mutation probability
        gen                 number of generation (iterations)
        N                   population size (must be divisable by 4)
        best_N              plotting the N best individuals each generation
        setup               number of setup (currently 1 and 2)
        plot_folder         path to save plots
    """
    if N % 4 != 0:
        raise ValueError(
            "[!] 'N' (population size) has to be dividedable by 4!")

    history = np.zeros((gen, best_N))

    # create one test member, to load task
    # cap = capacity of trucks in list
    # demands = demands of cities
    # dist = distance matrix
    # tc = transportation costs of trucks
    _, cap, demands, dist, tc = complete_init(task_nr=setup)

    ##### initialization
    # create a list for our population with N elements, with multiple
    # possible setups as numpy arrays
    # [instead of doing a list of 2d arrays, we do one 3d array, where the
    # first dimension stands for the members]
    # population has 3 dimensions: members x trucks x cities
    population = np.zeros((N, len(cap), len(demands)))
    # fill the population array
    for i in range(N):
        population[i] = complete_init(task_nr=setup)[0]

    for gen_idx in tqdm(range(gen)):
        ##### fitness
        permutations = np.array(
            [permute_way(member, dist, demands, cap) for member in population])
        fitness_scores = np.array([
            fitness_function(dist, permutation, member, tc)
            for permutation, member in zip(permutations, population)
        ])
        history[gen_idx] = sorted(fitness_scores)[-best_N:]

        ##### selection
        selected_indx = roulette_wheel_selection(fitness_scores, int(N / 2))
        selected_members = population[selected_indx]
        np.random.shuffle(selected_members)

        ##### crossover
        children = vrp_crossover(selected_members, cap, demands)

        ##### mutation
        for i, child in enumerate(children):
            if random.uniform(0, 1) < m:
                children[i] = mutate(child, cap)

        ##### replacement
        population = replacement(population,
                                 children,
                                 mode="delete-all",
                                 n=len(children),
                                 based_on_fitness=True,
                                 fitness_old=fitness_scores)

    ##### plotting
    plt.figure()
    plt.plot(history)
    plt.xlabel("Generations")
    plt.savefig(plot_folder + "history" +
                strftime("%Y-%m-%d %H:%M:%S", gmtime()) + ".png")
    plt.show()