예제 #1
0
    def main(self, checkpoint=None):
        state = GenState(checkpoint=checkpoint,
                         sheep=self.s_toolbox.population(n=self.SHEEP_COUNT),
                         wolfs=self.w_toolbox.population(n=self.WOLFS_COUNT))

        self.evaluate_population(state.sheep, state.wolfs)
        state.log_population(0, self.v)
        state.checkpoint(0)

        for g in range(1, self.MAX_GEN):
            state.sheep = self.s_toolbox.select(state.sheep, len(state.sheep))
            state.wolfs = self.w_toolbox.select(state.wolfs, len(state.wolfs))

            state.sheep = algorithms.varAnd(
                state.sheep, self.common_tbx, self.S_CXPB,
                0 if self.SHEEP_LAMARCK else self.S_MUTPB)
            state.wolfs = algorithms.varAnd(
                state.wolfs, self.common_tbx, self.W_CXPB,
                0 if self.WOLFS_LAMARCK else self.W_MUTPB)

            self.evaluate_population(state.sheep, state.wolfs)

            state.log_population(g, self.v)
            state.checkpoint(g)

        if self.v:
            print(state.s_hof)
            print(state.w_hof)

        return state
예제 #2
0
def gen_opt():
    creator.create("FitnessMax", base.Fitness, weights=(1.0, ))
    creator.create("Individual", list, fitness=creator.FitnessMax)
    toolbox = base.Toolbox()
    toolbox.register("population_guess", initPopulation, list,
                     creator.Individual)

    # toolbox.register("evaluate", async_score)
    toolbox.register("mate", tools.cxTwoPoint)
    toolbox.register("mutate", tools.mutGaussian, mu=0, sigma=0.05, indpb=0.1)
    toolbox.decorate("mate", checkBounds(0, 1))
    toolbox.decorate("mutate", checkBounds(0, 1))
    # toolbox.register("select", tools.selTournament, tournsize=3)

    population = toolbox.population_guess()

    update_id("experiment")
    for gen in range(NGEN):
        update_id("session")
        print("New Generation: {}/{}".format(gen, NGEN))
        offspring1 = algorithms.varAnd(random.sample(population, k=MU),
                                       toolbox,
                                       cxpb=CXPB,
                                       mutpb=MUTPB)
        offspring2 = algorithms.varAnd(population,
                                       toolbox,
                                       cxpb=CXPB,
                                       mutpb=MUTPB)
        population += offspring1 + offspring2
        # 1st Turn
        best = tournament(population, T1_POOL, T1_WIN)
        # 2nd Turn
        population = tournament(best, T2_POOL, T2_WIN, boss=True)
예제 #3
0
파일: coev_hillis.py 프로젝트: nwrush/GCA
def main():
    random.seed(64)
    
    hosts = htoolbox.population(n=300)
    parasites = ptoolbox.population(n=300)
    hof = tools.HallOfFame(1)
    hstats = tools.Statistics(lambda ind: ind.fitness.values)
    hstats.register("avg", tools.mean)
    hstats.register("std", tools.std)
    hstats.register("min", min)
    hstats.register("max", max)
    
    column_names = ["gen", "evals"]
    column_names.extend(hstats.functions.keys())
    logger = tools.EvolutionLogger(column_names)
    logger.logHeader()
    
    MAXGEN = 50
    H_CXPB, H_MUTPB = 0.5, 0.3
    P_CXPB, P_MUTPB = 0.5, 0.3
    
    fits = htoolbox.map(htoolbox.evaluate, hosts, parasites)
    for host, parasite, fit in zip(hosts, parasites, fits):
        host.fitness.values = parasite.fitness.values = fit
    
    hof.update(hosts)
    hstats.update(hosts)
    
    logger.logGeneration(gen=0, evals=len(hosts), stats=hstats)
    
    for g in range(1, MAXGEN):
        
        hosts = htoolbox.select(hosts, len(hosts))
        parasites = ptoolbox.select(parasites, len(parasites))
        
        hosts = algorithms.varAnd(hosts, htoolbox, H_CXPB, H_MUTPB)
        parasites = algorithms.varAnd(parasites, ptoolbox, P_CXPB, P_MUTPB)
        
        fits = htoolbox.map(htoolbox.evaluate, hosts, parasites)
        for host, parasite, fit in zip(hosts, parasites, fits):
            host.fitness.values = parasite.fitness.values = fit
        
        hof.update(hosts)
        hstats.update(hosts)
        logger.logGeneration(gen=g, evals=len(hosts), stats=hstats)
    
    best_network = sn.SortingNetwork(INPUTS, hof[0])
    print(best_network)
    print(best_network.draw())
    print("%i errors" % best_network.assess())

    return hosts, hstats, hof
예제 #4
0
def main():
    random.seed(64)

    hosts = htoolbox.population(n=300)
    parasites = ptoolbox.population(n=300)
    hof = tools.HallOfFame(1)

    hstats = tools.Statistics(lambda ind: ind.fitness.values)
    hstats.register("avg", numpy.mean)
    hstats.register("std", numpy.std)
    hstats.register("min", numpy.min)
    hstats.register("max", numpy.max)

    logbook = tools.Logbook()
    logbook.header = "gen", "evals", "std", "min", "avg", "max"

    MAXGEN = 50
    H_CXPB, H_MUTPB = 0.5, 0.3
    P_CXPB, P_MUTPB = 0.5, 0.3

    fits = htoolbox.map(htoolbox.evaluate, hosts, parasites)
    for host, parasite, fit in zip(hosts, parasites, fits):
        host.fitness.values = parasite.fitness.values = fit

    hof.update(hosts)
    record = hstats.compile(hosts)
    logbook.record(gen=0, evals=len(hosts), **record)
    print(logbook.stream)

    for g in range(1, MAXGEN):

        hosts = htoolbox.select(hosts, len(hosts))
        parasites = ptoolbox.select(parasites, len(parasites))

        hosts = algorithms.varAnd(hosts, htoolbox, H_CXPB, H_MUTPB)
        parasites = algorithms.varAnd(parasites, ptoolbox, P_CXPB, P_MUTPB)

        fits = htoolbox.map(htoolbox.evaluate, hosts, parasites)
        for host, parasite, fit in zip(hosts, parasites, fits):
            host.fitness.values = parasite.fitness.values = fit

        hof.update(hosts)
        record = hstats.compile(hosts)
        logbook.record(gen=g, evals=len(hosts), **record)
        print(logbook.stream)

    best_network = sn.SortingNetwork(INPUTS, hof[0])
    print(best_network)
    print(best_network.draw())
    print("%i errors" % best_network.assess())

    return hosts, logbook, hof
예제 #5
0
def main():
    random.seed(64)

    hosts = htoolbox.population(n=300)
    parasites = ptoolbox.population(n=300)
    hof = tools.HallOfFame(1)

    hstats = tools.Statistics(lambda ind: ind.fitness.values)
    hstats.register("avg", numpy.mean)
    hstats.register("std", numpy.std)
    hstats.register("min", numpy.min)
    hstats.register("max", numpy.max)

    logbook = tools.Logbook()
    logbook.header = "gen", "evals", "std", "min", "avg", "max"

    MAXGEN = 50
    H_CXPB, H_MUTPB = 0.5, 0.3
    P_CXPB, P_MUTPB = 0.5, 0.3

    fits = htoolbox.map(htoolbox.evaluate, hosts, parasites)
    for host, parasite, fit in zip(hosts, parasites, fits):
        host.fitness.values = parasite.fitness.values = fit

    hof.update(hosts)
    record = hstats.compile(hosts)
    logbook.record(gen=0, evals=len(hosts), **record)
    print(logbook.stream)

    for g in range(1, MAXGEN):

        hosts = htoolbox.select(hosts, len(hosts))
        parasites = ptoolbox.select(parasites, len(parasites))

        hosts = algorithms.varAnd(hosts, htoolbox, H_CXPB, H_MUTPB)
        parasites = algorithms.varAnd(parasites, ptoolbox, P_CXPB, P_MUTPB)

        fits = htoolbox.map(htoolbox.evaluate, hosts, parasites)
        for host, parasite, fit in zip(hosts, parasites, fits):
            host.fitness.values = parasite.fitness.values = fit

        hof.update(hosts)
        record = hstats.compile(hosts)
        logbook.record(gen=g, evals=len(hosts), **record)
        print(logbook.stream)

    best_network = sn.SortingNetwork(INPUTS, hof[0])
    print(best_network)
    print(best_network.draw())
    print("%i errors" % best_network.assess())

    return hosts, logbook, hof
예제 #6
0
def run_algorithm(pop, cxpb, mutpb, ngen, stats):
    for g in range(ngen):
        state.generation = g
        settings.output_statistics.write('\nGeneration {}\n\n'.format(g))
        offspring = map(toolbox.clone, toolbox.select(pop, len(pop)))
        offspring = algorithms.varAnd(offspring, toolbox, cxpb, mutpb)
        invalid_ind = [ind for ind in offspring if not ind.fitness.valid]
 
        fitnesses = []
        for i, ind in enumerate(invalid_ind):
            state.individual = i
            fitness = toolbox.evaluate(ind)
            fitnesses.append(fitness)
            settings.output_statistics.write(
                'Individiaul {} Fitness {} Price {} Edge {} Offset {}\n'.format(
                    i, fitness, ind[0], state.edges_list[int(ind[1]) % len(state.edges)], ind[2]))
            settings.output_statistics.flush()
        for ind, fit in zip(invalid_ind, fitnesses):
            ind.fitness.values = fit

        pop[:] = offspring
        nevals = len(fitness)
        record = stats.compile(pop)
        logbook.record(gen=g, evals=nevals, **record)
        settings.output_statistics.write('\n\n' + str(logbook) + '\n\n')
        settings.output_statistics.flush()
예제 #7
0
파일: game.py 프로젝트: codecofee19/FRIMT1
def modifiedGA(population, toolbox, hallOfFame, n_neurons, trialAverage,
               trialBest, cxpb, mutpb, ngen, game):

    # Begin the generational process
    for gen in range(1, ngen + 1):
        # Select the next generation individuals
        offspring = toolbox.select(population, len(population) - 1)
        offspring.append(hallOfFame[0])

        # Vary the pool of individuals
        offspring = algorithms.varAnd(offspring, toolbox, cxpb, mutpb)

        # Replace the current population by the offspring
        population[:] = offspring

        # MODIFIED BLOCK: Adds new agents based on the new offspring and goes through a game loop to set 		fitness values
        game.reset()
        for i in range(len(population)):
            game.add_agent(Brain(population[i], n_neurons))
        game.game_loop(display=False)

        totalFitness = 0
        largest = 0
        for i in range(c.game['n_agents']):
            totalFitness += g.agents[i].fitness
            if g.agents[i].fitness > largest:
                largest = g.agents[i].fitness
        averageFitness = totalFitness / c.game['n_agents']
        trialAverage.append(averageFitness)
        trialBest.append(largest)

        game.generation += 1

    return population
예제 #8
0
def propagate(gens, ind, toolbox, pool, pop_size, cxpb, mutpb):
    working_gen = gens[ind.gen]
    asp_idx = [i for i, (a1, a2) in enumerate(working_gen.tournament_aspirants) if a1 == ind.pop_idx or a2 == ind.pop_idx]
    for a in asp_idx:
        a1, a2 = working_gen.tournament_aspirants[a]
        if working_gen.pop[a1] and working_gen.pop[a2] and working_gen.pop[a1].fitness.valid and working_gen.pop[a2].fitness.valid:
            working_gen.selected[a] = max(working_gen.pop[a1], working_gen.pop[a2], key=attrgetter('fitness'))
            if a % 2 == 0:
                start, stop = a, a + 2
            else:
                start, stop = a - 1, a + 1
            if working_gen.selected[start] is not None and working_gen.selected[stop - 1] is not None and working_gen.offspring[start] is None and working_gen.offspring[stop - 1] is None:
                working_gen.offspring[start:stop] = map(toolbox.clone, working_gen.selected[start:stop])
                working_gen.offspring[start:stop] = algorithms.varAnd(working_gen.offspring[start:stop], toolbox, cxpb, mutpb)
                if len(gens) <= ind.gen + 1:
                    gens.append(Generation(pop_size, tournament_aspirants=utils.generate_aspirant_pairs(pop_size), pop=[None] * pop_size))
                gens[ind.gen + 1].pop[start:stop] = working_gen.offspring[start:stop]  # comma selection
                for idx, i in enumerate(gens[ind.gen + 1].pop[start:stop]):
                    i.pop_idx = start + idx
                    i.gen = ind.gen + 1
                    if not i.fitness.valid and i.pop_idx in gens[i.gen].aspirants:
                        pool.submit(i, order=(i.gen, gens[i.gen].aspirant_order[i.pop_idx]))
                        gens[i.gen].waiting.add(i.pop_idx)
                    else:
                        propagate(gens, i, toolbox, pool, pop_size, cxpb, mutpb)
예제 #9
0
def GA(toolbox, cxpb=0.5, mutpb=0.2, ngen=40, mu=2000, *args, **kwargs):
    '''
    '''
    stats, logbook, record, pop, hof = initMisc(toolbox, npop=mu, nhof=100, similar=np.array_equal)
    # Begin the generational process
    for gen in range(1, ngen + 1):
        # Select the next generation individuals
        offspring = toolbox.select(pop, len(pop))
        # Vary the pool of individuals
        offspring = varAnd(offspring, toolbox, cxpb, mutpb)
        # Evaluate the individuals with an invalid fitness
        invalid_ind = [ind for ind in offspring if not ind.fitness.valid]
        fitnesses = toolbox.map(toolbox.evaluate, invalid_ind)
        for ind, fit in zip(invalid_ind, fitnesses):
            ind.fitness.values = fit
        # Update the hall of fame with the generated individuals
        hof.update(offspring)
        if kwargs.has_key('callback'):
            kwargs['callback'](1, p=hof[0])
        # Replace the current population by the offspring
        pop[:] = offspring
        # Append the current generation statistics to the logbook
        record = stats.compile(pop) if stats else {}
        logbook.record(gen=gen, nevals=len(invalid_ind), **record)
        print logbook.stream

    print "Best individual is ", hof[0].fitness.values[0]
    if len(hof[0]) < 20:
        print hof[0]

    return {'x':hof[0],
            'population':pop,
            'stats':stats,
            'hof':hof,
            }
예제 #10
0
def eaSimplePlusElitism(population,
                        toolbox,
                        cxpb,
                        mutpb,
                        eprop,
                        ngen,
                        stats=None,
                        halloffame=None,
                        verbose=__debug__):
    """
    Variante de `deap.algorithms.eaSimple` con una proporción de elitismo.
    """
    logbook = tools.Logbook()
    logbook.header = ['gen', 'nevals'] + (stats.fields if stats else [])

    # Evalua los individuos con aptitud inválida.
    invalid_ind = [ind for ind in population if not ind.fitness.valid]
    fitnesses = toolbox.map(toolbox.evaluate, invalid_ind)
    for ind, fit in zip(invalid_ind, fitnesses):
        ind.fitness.values = fit

    if halloffame is not None:
        halloffame.update(population)

    record = stats.compile(population) if stats else {}
    logbook.record(gen=0, nevals=len(invalid_ind), **record)
    if verbose:
        print(logbook.stream)

    # Comienza el proceso evolutivo.
    for gen in range(1, ngen + 1):
        # Seleccina la próxima generación de individuos.
        offspring = toolbox.select(population, len(population))

        # Varia el pool de individuos, aplicando cruza y mutación.
        offspring = algorithms.varAnd(offspring, toolbox, cxpb, mutpb)

        # Evalua los individuos con aptitud inválida.
        invalid_ind = [ind for ind in offspring if not ind.fitness.valid]
        fitnesses = toolbox.map(toolbox.evaluate, invalid_ind)
        for ind, fit in zip(invalid_ind, fitnesses):
            ind.fitness.values = fit

        # Actualiza el grupo de mejores individuos.
        if halloffame is not None:
            halloffame.update(offspring)

        # Reemplaza la población actual con los mejores del conjunto
        # compuesta por su descendencia y la elite.
        elite_count = int(len(population) * eprop)
        elite = tools.selBest(population, elite_count)
        population[:] = tools.selBest(offspring + elite, len(population))

        # Toma nota de las estadísticas de la generación actual.
        record = stats.compile(population) if stats else {}
        logbook.record(gen=gen, nevals=len(invalid_ind), **record)
        if verbose:
            print(logbook.stream)

    return population, logbook
예제 #11
0
	def DoSingleIterGA_SHGMaximize (self, remeasure=True) :
		"""
		Perform a single iteration of GA to find phase of laser pulse 
		that coherently suppresses single sample fluorescence
		"""
		wx.Yield()
		# abort, if requested 
		if self.need_abort : return
		
			
		if remeasure :		
			# Record spectrum
			self.optimization_pop = self.MeasureSpectra(self.optimization_pop)
			
			wx.Yield()
			# abort, if requested 
			if self.need_abort : return
			
			# Calculate the fitness the population
			for ind in self.optimization_pop :
				ind.fitness.values = (ind.spectra.sum(),)
			
			self.optimization_pop[:] = self.optimization_toolbox.select(
										self.optimization_pop, self.population_size
				)
		else :
			# Generate offspring
			offspring = algorithms.varAnd(self.optimization_pop, self.optimization_toolbox, self.cxpb, self.mutpb)
			
			# Measure spectra for offspring only
			offspring = self.MeasureSpectra(offspring)
			
			wx.Yield()
			# abort, if requested 
			if self.need_abort : return
			
			# Calculate the fitness  of offspring
			for ind in offspring :
				ind.fitness.values = (ind.spectra.sum(),)
				
			self.optimization_pop[:] = self.optimization_toolbox.select( 
				self.optimization_pop + offspring, int(1.2*self.population_size)
				)
				
		wx.Yield()
		# abort, if requested 
		if self.need_abort : return
		
		# Saving statistics for plotting purposes
		for key, value in self.optimization_stats.compile(self.optimization_pop).items() :
			try : 
				self.optimization_log[key].append(value)
			except KeyError : 
				self.optimization_log[key] = [value]
		
		self.SaveOptimization()
		self.DisplayOptimization() 
	
		# Going to the next iteration
		wx.CallAfter (self.DoSingleIterGA_SHGMaximize,  remeasure=(not remeasure)) 
예제 #12
0
def generate_word(word, letters, population_size):
    creator.create("Fitness", base.Fitness, weights=(-1.0,))
    creator.create("Individual", list, fitness=creator.Fitness)

    toolbox = base.Toolbox()

    toolbox.register("attr_bool", generate_letter, letters=letters)
    toolbox.register("individual", tools.initRepeat, creator.Individual, toolbox.attr_bool, n=len(word))
    toolbox.register("population", tools.initRepeat, list, toolbox.individual)

    toolbox.register("evaluate", evaluate_alphabet_distance, word=word, alphabet=letters)
    toolbox.register("mate", tools.cxTwoPoint)
    toolbox.register("mutate", mutInAlphabet, letters=letters, max_step=3, indpb=0.05)
    toolbox.register("select", tools.selTournament, tournsize=3)

    population = toolbox.population(n=population_size)

    generation = 0
    while have_not_found_yet(population, generation, word):
        offspring = algorithms.varAnd(population, toolbox, cxpb=0.5, mutpb=0.1)
        fits = toolbox.map(toolbox.evaluate, offspring)
        for fit, ind in zip(fits, offspring):
            ind.fitness.values = fit
        population = toolbox.select(offspring, k=len(population))
        generation += 1
        if generation % 100 == 0:
            print(generation)

    print(generation)
    print(tools.selBest(population, k=1)[0])
예제 #13
0
    def _do_generation(self, pop, gen_num, logbook):
        """Implement a generation of the search process.

        :param pop: The population
        :type pop: Any iterable type
        :param gen_num: The generation number
        :type gen_num: :py:class:`int`
        :param logbook: Logbook for the stats
        :type logbook: :py:class:`~deap.tools.Logbook`
        """
        # Select the next generation individuals
        offspring = self._toolbox.select(pop, self.pop_size)

        # Vary the pool of individuals
        offspring = varAnd(offspring, self._toolbox, self.xover_pb,
                           self.mut_pb)

        # Evaluate the individuals with an invalid fitness
        num_evals = self._eval(offspring)

        # Replace the current population by the offspring
        pop[:] = offspring

        # Append the current generation statistics to the logbook
        self._do_stats(pop, gen_num, num_evals, logbook)
예제 #14
0
    def _execute(self) -> list:
        """
        Запуск алгоритма.

        Потомок offspring - с вероятностью cxpb 2 подряд идущих в списке индивида скрещиваются
        и их дети заменяют родителей, а с вероятностью mutpb после процесса скрещивания каждый индивид мутирует.

        Далее рассчитывается ценность каждого потомка и рассчитанные ценности
        заполняют поля ценности (values) в соответствующих индивидах.

        Затем отбор нового поколения.
        В конце - выбор лучшего
        :return:
        """
        population = self._toolbox.population(n=self.START_POPULATION_SIZE)
        for gen in range(self.GENERATION_COUNT):
            offspring = algorithms.varAnd(population,
                                          self._toolbox,
                                          cxpb=self.CROSSOVER_CHANCE,
                                          mutpb=self.MUTATE_CHANCE)
            fits = self._toolbox.map(self._toolbox.evaluate, offspring)
            for fit, ind in zip(fits, offspring):
                ind.fitness.values = fit
            population = self._toolbox.select(offspring, k=len(population))
        top1 = tools.selBest(population, k=1)
        return top1[0]
예제 #15
0
    def _run_evolution(self):
        creator.create("FitnessMax", base.Fitness, weights=(1.0, ))
        creator.create("Individual", list, fitness=creator.FitnessMax)

        toolbox = base.Toolbox()

        toolbox.register("attr_bool", random.randint, 0, 1)
        toolbox.register("individual",
                         tools.initRepeat,
                         creator.Individual,
                         toolbox.attr_bool,
                         n=100)
        toolbox.register("population", tools.initRepeat, list,
                         toolbox.individual)

        toolbox.register("evaluate", self._eval_evolution_by_loss)
        toolbox.register("mate", tools.cxTwoPoint)
        toolbox.register("mutate", tools.mutFlipBit, indpb=0.05)
        toolbox.register("select", tools.selTournament, tournsize=3)

        population = toolbox.population(n=300)

        NGEN = 40
        for gen in range(NGEN):
            offspring = algorithms.varAnd(population,
                                          toolbox,
                                          cxpb=0.5,
                                          mutpb=0.1)
            fits = toolbox.map(toolbox.evaluate, offspring)
            for fit, ind in zip(fits, offspring):
                ind.fitness.values = fit
            population = toolbox.select(offspring, k=len(population))
        top10 = tools.selBest(population, k=10)
        return top10
예제 #16
0
def approximate(func, base_range, bounds, population_size, generations):
    def evaluation_func(individual):
        score = 0.0
        for idx, x in enumerate(base_range):
            score += abs(func(x) - individual[idx])
        return score,

    creator.create("Fitness", base.Fitness, weights=(-1.0,))
    creator.create("Individual", list, fitness=creator.Fitness)

    toolbox = base.Toolbox()

    toolbox.register("attr_bool", float_between, *bounds)
    toolbox.register("individual", tools.initRepeat, creator.Individual, toolbox.attr_bool, n=len(base_range))
    toolbox.register("population", tools.initRepeat, list, toolbox.individual)

    toolbox.register("evaluate", evaluation_func)
    toolbox.register("mate", tools.cxTwoPoint)
    toolbox.register("mutate", tools.mutFlipBit, indpb=0.05)
    toolbox.register("select", tools.selTournament, tournsize=3)

    population = toolbox.population(n=population_size)

    for gen in range(generations):
        offspring = algorithms.varAnd(population, toolbox, cxpb=0.5, mutpb=0.1)
        fits = toolbox.map(toolbox.evaluate, offspring)
        for fit, ind in zip(fits, offspring):
            ind.fitness.values = fit
        population = toolbox.select(offspring, k=len(population))

    show_best_individual(base_range, func, population)
예제 #17
0
def run_evolution(generations=10):
    toolbox.register("evaluate", eval_diff_fitness)
    toolbox.register("mate", tools.cxTwoPoint)
    toolbox.register("mutate", tools.mutFlipBit, indpb=0.05)
    toolbox.register("select", tools.selTournament, tournsize=3)

    population = toolbox.population(n=20)

    fit_history = []
    for gen in range(generations):
        print(f'gen # {gen}')
        offspring = algorithms.varAnd(population, toolbox, cxpb=0.5, mutpb=0.1)
        fits = toolbox.map(toolbox.evaluate, offspring)
        for fit, ind in zip(fits, offspring):
            ind.fitness.values = fit
        population = toolbox.select(offspring, k=len(population))

        fit_values = []
        for ind in population:
            fitness = ind.fitness.values
            fit_values.append(fitness)
        fit_history.append(np.average(fit_values))

    top10 = tools.selBest(population, k=10)

    return top10, fit_history
예제 #18
0
    def learn(self):
        """ Runs genetic algorithms.

        By using DEAP, generates an initial population and runs for n generations.

        Returns:
            A dict with the features weight and others params.
        """
        solution = {}

        # Generate Population
        population = self.deap_toolbox.population(n=self.population)

        # Evolve
        for gen in range(self.generations):
            offspring = algorithms.varAnd(population, self.deap_toolbox, cxpb=0.5, mutpb=0.1)
            fits = self.deap_toolbox.map(self.deap_toolbox.evaluate, offspring)
            for fit, ind in zip(fits, offspring):
                ind.fitness.values = fit
            population = self.deap_toolbox.select(offspring, k=len(population))

        # Select best
        best = tools.selBest(population, k=1)[0]
        best_fitness, = self.fitness_wrapper(best)
        revisions_weight, fixes_weight, authors_weight = self.decode_individual(best)

        solution["revisions"] = revisions_weight
        solution["fixes"] = fixes_weight
        solution["authors"] = authors_weight
        solution["fitness"] = best_fitness
        solution["bits"] = self.bits
        solution["generations"] = self.generations

        return solution
예제 #19
0
    def run(self):
        breakEarly = False
        for gen in range(1, self.NGEN + 1):
            try:
                if breakEarly:
                    print("Stopped by user!")
                    break
                offsprings = algorithms.varAnd(self.population,
                                               self.toolbox,
                                               cxpb=MathFunGA.CXPB,
                                               mutpb=MathFunGA.MUTPB)
                fitnesses = self.toolbox.map(self.toolbox.evaluate, offsprings)
                for fit, ind in zip(fitnesses, offsprings):
                    ind.fitness.values = fit
                self.population = self.toolbox.select(offsprings,
                                                      k=len(self.population))

                theBestThisPop = tools.selBest(self.population, k=1)[0]
                theBestFitness = theBestThisPop.fitness.getValues()[0]
                print((str(gen) + ":").ljust(5) + str(theBestFitness))
                if theBestFitness < MathFunGA.FITNESS_TARGET:
                    print("Satisfying fitness reached!")
                    break
            except KeyboardInterrupt:
                breakEarly = True
        else:
            print("Maximum number of iterations reached!")

        self.showResults()
예제 #20
0
def seqSelectionRound(sess, population, toolbox, args):
	offspring = algorithms.varAnd(population, toolbox, cxpb=args['cspb'], mutpb=args['mutpb'])
	fits = evaluateThese(sess, offspring,args);
	for fit, ind in zip(fits, offspring):
		ind.fitness.values = fit
	population = toolbox.select(offspring, k=len(population))
	return (population);
예제 #21
0
파일: genetic.py 프로젝트: sazl/SumoSimTest
def run_algorithm(pop, cxpb, mutpb, ngen, stats):
    for g in range(ngen):
        state.generation = g
        settings.output_statistics.write('\nGeneration {}\n\n'.format(g))
        offspring = map(toolbox.clone, toolbox.select(pop, len(pop)))
        offspring = algorithms.varAnd(offspring, toolbox, cxpb, mutpb)
        invalid_ind = [ind for ind in offspring if not ind.fitness.valid]

        fitnesses = []
        for i, ind in enumerate(invalid_ind):
            state.individual = i
            fitness = toolbox.evaluate(ind)
            fitnesses.append(fitness)
            settings.output_statistics.write(
                'Individiaul {} Fitness {} Price {} Edge {} Offset {}\n'.
                format(i, fitness, ind[0],
                       state.edges_list[int(ind[1]) % len(state.edges)],
                       ind[2]))
            settings.output_statistics.flush()
        for ind, fit in zip(invalid_ind, fitnesses):
            ind.fitness.values = fit

        pop[:] = offspring
        nevals = len(fitness)
        record = stats.compile(pop)
        logbook.record(gen=g, evals=nevals, **record)
        settings.output_statistics.write('\n\n' + str(logbook) + '\n\n')
        settings.output_statistics.flush()
예제 #22
0
    def update(self, *args):
        self.canvas.clear()
        self.epoch += 1

        top10 = tools.selBest(self.population, k=1)
        elite = top10[0]

        offspring = algorithms.varAnd(self.population,
                                      toolbox,
                                      cxpb=1.0,
                                      mutpb=0.7)
        fits = list(toolbox.map(toolbox.evaluator, offspring))
        for fit, ind in zip(fits, offspring):
            ind.fitness.values = [fit]
        self.population = toolbox.select(offspring, k=self.pops)
        self.population[0] = elite

        top10 = tools.selBest(self.population, k=1)
        top_v, top = eval_f(top10[0], True)
        with self.canvas:
            Color(rgba=(1, 0.8, 0.1, 0.7))
            for x, y in zip(top[0], top[1]):
                Ellipse(pos=(x, y), size=(5, 5))
            self.label = Label(text="{:.2f} : {}".format(
                float(top_v), self.epoch),
                               halign="right")
예제 #23
0
파일: ec.py 프로젝트: radaniba/jcvi
def eaSimpleConverge(population, toolbox, cxpb, mutpb, ngen, stats=None,
             halloffame=None, verbose=True):
    """This algorithm reproduce the simplest evolutionary algorithm as
    presented in chapter 7 of [Back2000]_.

    Modified to allow checking if there is no change for ngen, as a simple
    rule for convergence. Interface is similar to eaSimple(). However, in
    eaSimple, ngen is total number of iterations; in eaSimpleConverge, we
    terminate only when the best is NOT updated for ngen iterations.
    """
    # Evaluate the individuals with an invalid fitness
    invalid_ind = [ind for ind in population if not ind.fitness.valid]
    fitnesses = toolbox.map(toolbox.evaluate, invalid_ind)
    for ind, fit in zip(invalid_ind, fitnesses):
        ind.fitness.values = fit

    if halloffame is not None:
        halloffame.update(population)

    record = stats.compile(population) if stats else {}

    # Begin the generational process
    gen = 1
    best = 0
    while True:
        # Select the next generation individuals
        offspring = toolbox.select(population, len(population))

        # Vary the pool of individuals
        offspring = varAnd(offspring, toolbox, cxpb, mutpb)

        # Evaluate the individuals with an invalid fitness
        invalid_ind = [ind for ind in offspring if not ind.fitness.valid]
        fitnesses = toolbox.map(toolbox.evaluate, invalid_ind)
        for ind, fit in zip(invalid_ind, fitnesses):
            ind.fitness.values = fit

        # Update the hall of fame with the generated individuals
        if halloffame is not None:
            halloffame.update(offspring)

        # Replace the current population by the offspring
        population[:] = offspring

        # Append the current generation statistics to the logbook
        record = stats.compile(population) if stats else {}
        current_best = record['max']
        if gen % 20 == 0 and verbose:
            print >> sys.stderr, "Current iteration {0}: max_score={1}".\
                            format(gen, current_best)

        if current_best != best:
            best = current_best
            updated = gen

        gen += 1
        if gen - updated > ngen:
            break

    return population
예제 #24
0
    def test_pheromone_mode(self):
        toolbox = self.toolbox
        toolbox.register("select",
                         tigerMosquitoSelection,
                         tournsize=3,
                         useFitness=False)
        population = toolbox.population(n=3)
        # population size = 3
        offspring = algorithms.varAnd(population, toolbox, cxpb=0., mutpb=0.)
        # set pheromone each individual
        pheromones = [50, 100, 75]

        # evaluation
        fits = toolbox.map(toolbox.evaluate, offspring)

        max_p = -1
        for i, fit_ind in enumerate(zip(fits, offspring)):
            fit, ind = fit_ind
            ind.fitness.values = fit
            ind.pheromone.values = (pheromones[i], )
            if max_p <= pheromones[i]:
                max_p = pheromones[i]
                max_sample = ind

        random.seed(20180719)
        selected_ind = toolbox.select(offspring, k=1)
        self.assertEqual([[1, 1, 0]], selected_ind)
예제 #25
0
파일: ga.py 프로젝트: Piggelinus/Project
def compose(toolbox, window, tonic):
    global chords_in_vector

    population = toolbox.population(n=pop_size)

    NGEN = num_gens

    for gen in range(NGEN):
        offspring = algorithms.varAnd(population, toolbox, cxpb=cx_pb, mutpb=mut_pb)
        fits = toolbox.map(toolbox.evaluate, offspring)

        total_fitness = 0

        for fit, ind in zip(fits, offspring):
            ind.fitness.values = fit
            total_fitness += fit

        population = toolbox.select(offspring, k=len(population))

        #print("Total fitness in gen %s : %s" % (gen, total_fitness))
        #print("Best : %s" % evaluate(tools.selBest(population, k=1)[0]))

    top = tools.selBest(population, k=1)[0]

    np.set_printoptions(threshold=np.nan)
    #pprint("%s, %s" % (window, top))
    #pprint(evaluate(top))

    return top, evaluate(top)
예제 #26
0
def eaSimpleWithElitism(population,
                        toolbox,
                        cxpb,
                        mutpb,
                        ngen,
                        stats=None,
                        halloffame=None,
                        verbose=__debug__):

    #подготовка исходных данных для генерации
    logbook = tools.Logbook()
    logbook.header = ['gen', 'nevals'] + (stats.fields if stats else [])
    # сравнение единиц с не валидным фитнес значением
    invalid_ind = [ind for ind in population if not ind.fitness.valid]
    fitnesses = toolbox.map(toolbox.evaluate, invalid_ind)
    for ind, fit in zip(invalid_ind, fitnesses):
        ind.fitness.values = fit

    if halloffame is None:
        raise ValueError("halloffame parameter must not be empty!")

    halloffame.update(population)
    hof_size = len(halloffame.items) if halloffame.items else 0

    record = stats.compile(population) if stats else {}
    logbook.record(gen=0, nevals=len(invalid_ind), **record)
    if verbose:
        print(logbook.stream)

    # Начало процесса генерации
    for gen in range(1, ngen + 1):

        # выборка следующего поколения единиц
        offspring = toolbox.select(population, len(population) - hof_size)

        #отклонение поколения
        offspring = algorithms.varAnd(offspring, toolbox, cxpb, mutpb)

        # сравнение единиц с не валидным фитнес значением
        invalid_ind = [ind for ind in offspring if not ind.fitness.valid]
        fitnesses = toolbox.map(toolbox.evaluate, invalid_ind)
        for ind, fit in zip(invalid_ind, fitnesses):
            ind.fitness.values = fit

        # возвращение лучшего значения популяции
        offspring.extend(halloffame.items)

        # дополненией результата новым поколением
        halloffame.update(offspring)

        #замещение старой популяции новой
        population[:] = offspring

        # обновление и вывод статистики
        record = stats.compile(population) if stats else {}
        logbook.record(gen=gen, nevals=len(invalid_ind), **record)
        if verbose:
            print(logbook.stream)

    return population, logbook
예제 #27
0
def nsga(population, start_gen, toolbox, cxpb, mutpb, ngen,
         stats, halloffame, logbook, verbose, exp_id=None):

    eval_invalid_inds = ( 
        eval_invalid_inds_single_gpu 
        if Config.GPU 
        else eval_invalid_inds_cpu_parallel
    )

    popsize = len(population)
    total_time = datetime.timedelta(seconds=0)

    eval_invalid_inds(population, toolbox)

    for gen in range(start_gen, ngen):
        start_time = datetime.datetime.now()

        offspring = algorithms.varAnd(population, toolbox, cxpb=cxpb,
                                      mutpb=mutpb)

        evals = eval_invalid_inds(offspring, toolbox)

        population = toolbox.select(population+offspring, k=popsize)

        halloffame.update(offspring)  # updates pareto front
        # update statics
        record = stats.compile(population)
        logbook.record(gen=gen, evals=evals, **record)
        if verbose:
            print(logbook.stream, flush=True)

        # save checkpoint
        if gen % 1 == 0:
            # Fill the dictionary using the dict(key=value[, ...]) constructor
            cp = dict(
                population=population,
                generation=gen,
                halloffame=halloffame,
                logbook=logbook,
                rndstate=random.getstate(),
                config=Config,
            )
            if exp_id is None:
                cp_name = "checkpoint_nsga.pkl"
            else:
                cp_name = "checkpoint_nsga_{}.pkl".format(exp_id)
            pickle.dump(cp, open(cp_name, "wb"))

        # check hard time limit
        gen_time = datetime.datetime.now() - start_time
        total_time = total_time + gen_time
        print("Time ", total_time)

        # hard time limit was necessary at metacentrum
        #
        # if total_time > datetime.timedelta(hours=4*24):
        #     print("Time limit exceeded.")
        #     break

    return population, logbook
예제 #28
0
def runExample():
	args  = {'sequence_length' : 110 , 'nucleotide_frequency' : [0.25,0.25,0.25,0.25], 'mutation_frequency' : 0.05 } 
	np.random.seed(1239571243);
	randomizer=np.random
	creator.create("FitnessMax", base.Fitness, weights=(1.0,))
	creator.create("Individual", list , fitness=creator.FitnessMax)

	toolbox = base.Toolbox()
	toolbox.register("base", getRandomBase, randomizer, args)
	toolbox.register("individual", tools.initRepeat, creator.Individual, toolbox.base, n=args['sequence_length'])
	toolbox.register("population", tools.initRepeat, list, toolbox.individual)
	toolbox.register("evaluate", fitness, "ATGC")
	#toolbox.register("evaluate", fitness)
	toolbox.register("mate", tools.cxTwoPoint)
	toolbox.register("mutate", mutateSequence, randomizer, args)
	#toolbox.register("mutate", mutateSequence, args['mutation_frequency'])
	toolbox.register("select", tools.selTournament, tournsize=3)

	population = toolbox.population(n=300)
	NGEN=1000
	for gen in range(NGEN):
		offspring = algorithms.varAnd(population, toolbox, cxpb=0.1, mutpb=0.1)
		#offspring = algorithms.varAnd(population, toolbox, cxpb=0.1)
		fits = toolbox.map(toolbox.evaluate, offspring)
		print(type(fits))
		for fit, ind in zip(fits, offspring):
			ind.fitness.values = fit
		population = toolbox.select(offspring, k=len(population))
	top10 = tools.selBest(population, k=10)
	return(top10);
    def findNominalValues(self):
        nominalVals = []

        for evalMode in self.model.modes:
            nominalValsMode = []
            self.toolbox.register("evaluate", evalMode)
            #initialize new random population
            self.popu = self.toolbox.population(self.populationSize)

            for gen in range(self.NGEN):
                print(gen)
                #generate offspprings with crossover and mutations
                offspring = algorithms.varAnd(self.popu,
                                              self.toolbox,
                                              cxpb=0.5,
                                              mutpb=0.75)
                #evaluate individuals
                fits = self.toolbox.map(self.toolbox.evaluate, offspring)
                for fit, ind in zip(fits, offspring):
                    if self.model.isViable(ind) and ind not in nominalValsMode:
                        nominalValsMode.append(ind)
                    ind.fitness.values = fit
                #roulete wheel selection
                self.popu = self.toolbox.select(offspring, k=len(self.popu))

            print("Number of viable points: " + str(len(nominalValsMode)))
            nominalVals.extend(nominalValsMode)
        return nominalVals
예제 #30
0
def geneticAlgorithmWithEvalFunctional(base_func, eval_func, search_region, population_size, generations, **args):
    creator.create("Fitness", base.Fitness, weights=(-1.0,))
    creator.create("Individual", list, fitness=creator.Fitness)

    toolbox = base.Toolbox()

    toolbox.register("attr_bool", float_between, *search_region)
    toolbox.register("individual", tools.initRepeat, creator.Individual, toolbox.attr_bool, n=1)
    toolbox.register("population", tools.initRepeat, list, toolbox.individual)

    toolbox.register("evaluate", eval_func, **args)
    toolbox.register("mate", skippingCrosover)
    (a, b) = search_region
    toolbox.register("mutate", mutInRegion, a=a, b=b, max_step=0.1, indpb=0.05)
    toolbox.register("select", tools.selTournament, tournsize=3)

    population = toolbox.population(n=population_size)

    for gen in range(generations):
        offspring = algorithms.varAnd(population, toolbox, cxpb=0.5, mutpb=0.1)
        fits = toolbox.map(toolbox.evaluate, offspring)
        for fit, ind in zip(fits, offspring):
            ind.fitness.values = fit
        population = toolbox.select(offspring, k=len(population))

    print(tools.selBest(population, k=1))

    base_range = float_range(*search_region)
    plot(base_range, [base_func(x) for x in base_range], 'r')
    show()
예제 #31
0
    def GetBetters(self):
        self.toolbox.register("evaluate", self.EvalOneMax)
        self.toolbox.register("mate", tools.cxTwoPoint)  # crossover
        self.toolbox.register("mutate", tools.mutFlipBit,
                              indpb=0.05)  # mutação

        self.toolbox.register("select", tools.selTournament, tournsize=3)

        population = self.toolbox.population(n=300)

        NGEN = 40
        for gen in range(NGEN):
            offspring = algorithms.varAnd(population,
                                          self.toolbox,
                                          cxpb=0.5,
                                          mutpb=0.1)
            fits = self.toolbox.map(self.toolbox.evaluate, offspring)
            for fit, ind in zip(fits, offspring):
                if fit['weight'] > self.limit:
                    ind.fitness.values = [0]
                else:
                    ind.fitness.values = fit['value']

            population = self.toolbox.select(offspring, k=len(population))

        betters = tools.selBest(population, k=10)[0]
        result = []
        for key, value in enumerate(betters):
            if value == 1:
                result.append(self.products[key])

        return {"products": result, "state": self.EvalOneMax(betters)}
예제 #32
0
def startalgrithm(topk):
    liststring = input("pls input the list, saperate with , :")
    for item in liststring.split(','):
        listinput.append(int(item))
    creator.create("FitnessMax", base.Fitness, weights=(1,))  #weights 
    creator.create("Individual", list, fitness=creator.FitnessMax)
    toolbox = base.Toolbox()
    toolbox.register("attr_bool", random.randint, -1, 1) # value range
    toolbox.register("individual", tools.initRepeat, creator.Individual, toolbox.attr_bool, n=len(listinput)) #number of parameters
    toolbox.register("population", tools.initRepeat, list, toolbox.individual)
    toolbox.register("evaluate", evalOneMax)
    toolbox.register("mate", tools.cxTwoPoint)
    toolbox.register("mutate", tools.mutFlipBit, indpb=0.05)
    toolbox.register("select", tools.selTournament, tournsize=3)
    population = toolbox.population(n=300)
    NGEN=40
    for gen in range(NGEN):
        offspring = algorithms.varAnd(population, toolbox, cxpb=0.5, mutpb=0.1)
        fits = toolbox.map(toolbox.evaluate, offspring)
        for fit, ind in zip(fits, offspring):
            ind.fitness.values = fit
        population = toolbox.select(offspring, k=len(population))
    topk = input("pls input the number of result:")
    top2 = tools.selBest(population, k=int(topk))  #top1
    return top2
예제 #33
0
def example_nevzpominam():
    # Creating appropriate type
    creator.create("FitnessMax", base.Fitness, weights=(1.0,))
    creator.create("Individual", list, fitness=creator.FitnessMax)

    # Initialization
    IND_SIZE = 100
    toolbox = base.Toolbox()
    toolbox.register("attr_bool", random.randint, 0, 1)
    toolbox.register("individual", tools.initRepeat, creator.Individual, toolbox.attr_bool, n=IND_SIZE)
    toolbox.register("population", tools.initRepeat, list, toolbox.individual)

    toolbox.register("evaluate", evalOneMax)
    toolbox.register("mate", tools.cxTwoPoint)
    toolbox.register("mutate", tools.mutFlipBit, indpb=0.05)
    toolbox.register("select", tools.selTournament, tournsize=3)

    population = toolbox.population(n=300)

    NGEN=40

    for gen in range(NGEN):
        offspring = algorithms.varAnd(population, toolbox, cxpb=0.5, mutpb=0.1)
        fits = toolbox.map(toolbox.evaluate, offspring)
        for fit, ind in zip(fits, offspring):
            ind.fitness.values = fit
        population = toolbox.select(offspring, k=len(population))
    top10 = tools.selBest(population, k=10)
예제 #34
0
    def genetic(self, n_epochs=40):
        creator.create("FitnessMax", base.Fitness, weights=(-1.0, ))
        creator.create("Individual", np.ndarray, fitness=creator.FitnessMax)

        toolbox = base.Toolbox()

        toolbox.register("attr_float", np.random.random)
        toolbox.register("individual",
                         tools.initRepeat,
                         creator.Individual,
                         toolbox.attr_float,
                         n=self.M)
        toolbox.register("population", tools.initRepeat, list,
                         toolbox.individual)

        def eval_def(individual):
            return self.rmse_loss(self.X_train @ individual),

        toolbox.register("evaluate", eval_def)
        toolbox.register("mate", tools.cxTwoPoint)
        toolbox.register("mutate", tools.mutFlipBit, indpb=0.05)
        toolbox.register("select", tools.selTournament, tournsize=3)

        population = toolbox.population(n=300)

        for gen in range(n_epochs):
            offspring = algorithms.varAnd(population,
                                          toolbox,
                                          cxpb=0.5,
                                          mutpb=0.1)
            fits = toolbox.map(toolbox.evaluate, offspring)
            for fit, ind in zip(fits, offspring):
                ind.fitness.values = fit
            population = toolbox.select(offspring, k=len(population))
        self.w = tools.selBest(population, k=1)[0]
예제 #35
0
def main(procid, pipein, pipeout, sync, run_num, config,vseed=None):
    #random.seed(seed)
    toolbox.register("migrate", migPipe, k=5, pipein=pipein, pipeout=pipeout,
        selection=tools.selBest, replacement=random.sample)

    MU = config["POPULATION_SIZE"]
    NGEN = 500
    CXPB = 0.5
    MUTPB = 0.2
    MIG_RATE = 5

    deme = toolbox.population(n=MU)
    hof = tools.HallOfFame(1)
    stats = tools.Statistics(lambda ind: ind.fitness.values)
    stats.register("avg", numpy.mean)
    stats.register("std", numpy.std)
    stats.register("min", numpy.min)
    stats.register("max", numpy.max)
    
    logbook = tools.Logbook()
    logbook.header = "gen", "deme", "evals", "std", "min", "avg", "max"
    
    for ind in deme:
        ind.fitness.values = toolbox.evaluate(ind)
    record = stats.compile(deme)
    logbook.record(gen=0, deme=procid, evals=len(deme), **record)
    hof.update(deme)

    # if procid == 0:
    #     # Synchronization needed to log header on top and only once
    #     print run_num, logbook.stream
    #     sync.set()
    # else:
    #     logbook.log_header = False  # Never output the header
    #     print run_num, logbook.stream
    #     sync.wait()


    for gen in range(1, NGEN):
        deme = toolbox.select(deme, len(deme))
        deme = algorithms.varAnd(deme, toolbox, cxpb=CXPB, mutpb=MUTPB)
        
        invalid_ind = [ind for ind in deme if not ind.fitness.valid]
        for ind in invalid_ind:
            ind.fitness.values = toolbox.evaluate(ind)
        
        hof.update(deme)
        record = stats.compile(deme)
        logbook.record(gen=gen, deme=procid, evals=len(deme), **record)

        r = "%d,%d,%d,%d,%d" % (run_num,procid, gen,  len(deme), record['max'])
        print r

        if record['max']>=128:
            #print run_num, "FOUND"
            return

            
        if gen % MIG_RATE == 0 and gen > 0:
            toolbox.migrate(deme)
예제 #36
0
    def evolve_stage1(self, cxpb, mutpb, n_gen=50, k_elites=1, w_ssv=None):
        """
        Perform stage 1 evolution, where only the local fitness (number of false states) matters.
        In this stage, each gene's regulation function is evolved separately and not cooperation is needed.

        :param cxpb: cross-over probability
        :param mutpb: mutation probability
        :param n_gen: number of generations
        :param k_elites: number of elites
        :param w_ssv: penalty weight of stable state violations. If None, then no penalty.
        :return:
        """
        self.stage = 1
        self.n_gen_stage1 = n_gen
        if n_gen == 0:
            return
        # normal single-objective GP
        self.toolbox.register('select', tools.selTournament, tournsize=3)
        self.toolbox.register('evaluate', self._evaluate_stage1, w_ssv=w_ssv)
        FitnessMin.weights = (-1.0, )

        for gen in range(n_gen + 1):
            self.gen = gen
            # individuals that have been changed due to mutation or crossover
            invalid_pop = [
                ind for ind in self.population if not ind.fitness.valid
            ]
            self._compile(invalid_pop)
            if self.stable_states is not None:
                self._count_stable_state_violations(invalid_pop)
            self._count_num_regulators(invalid_pop)
            # Evaluate the individuals with an invalid fitness
            fitnesses = self.toolbox.map(self.toolbox.evaluate, invalid_pop)
            for ind, fit in zip(invalid_pop, fitnesses):
                ind.fitness.values = fit

            self.hof_stage1.update(self.population)
            self.best_local_fitness = max(
                self.population, key=lambda ind: ind.fitness).fitness.values[0]
            # log
            if hasattr(self, 'logbook'):
                record = self.mstats.compile(self.population)
                self.logbook.record(index=self.index,
                                    stage=self.stage,
                                    gen=self.gen,
                                    **record)
                self._log_to_file()

            if gen == n_gen:
                break
            # selection and variation to produce the next generation
            elites = tools.selBest(self.population, k_elites)
            parents = self.toolbox.select(self.population,
                                          len(self.population) - k_elites)
            offspring = algorithms.varAnd(parents,
                                          toolbox=self.toolbox,
                                          cxpb=cxpb,
                                          mutpb=mutpb)
            self.population = elites + offspring
예제 #37
0
def main():
    if os.path.isfile(CP):
        # A file name has been given, then load the data from the file
        cp = read_checkpoint()
        population = cp["population"]
        start_gen = cp["generation"] + 1
        halloffame = cp["halloffame"]
        logbook = cp["logbook"]
        random.setstate(cp["rndstate"])
    else:
        # Start a new evolution
        random.seed()
        population = toolbox.population(n=300)
        start_gen = 0
        halloffame = tools.HallOfFame(maxsize=1)
        logbook = tools.Logbook()

    stats_fit = tools.Statistics(lambda ind: ind.fitness.values)
    stats_size = tools.Statistics(len)
    mstats = tools.MultiStatistics(fitness=stats_fit, size=stats_size)
    mstats.register("avg", numpy.mean)
    mstats.register("std", numpy.std)
    mstats.register("min", numpy.min)
    mstats.register("max", numpy.max)

    #algorithms.eaSimple(pop, toolbox, 0.5, 0.2, NGEN, mstats, halloffame=hof)
    #print(hof[0])

    begin = start_gen
    end = begin + NGEN
    print("begin: {},  end: {}".format(begin, end))
    for gen in range(begin, end):
        population = algorithms.varAnd(population,
                                       toolbox,
                                       cxpb=toolbox.mate,
                                       mutpb=toolbox.mutate)

        # Evaluate the individuals with an invalid fitness
        invalid_ind = [ind for ind in population if not ind.fitness.valid]
        fitnesses = toolbox.map(toolbox.evaluate, invalid_ind)
        for ind, fit in zip(invalid_ind, fitnesses):
            ind.fitness.values = fit

        halloffame.update(population)
        record = mstats.compile(population)
        logbook.record(gen=gen, evals=len(invalid_ind), **record)

        population = toolbox.select(population, k=len(population))

        if (gen + 1) % FREQ == 0 or gen == end - 1:
            # Fill the dictionary using the dict(key=value[, ...]) constructor
            cp = dict(population=population,
                      generation=gen,
                      halloffame=halloffame,
                      logbook=logbook,
                      rndstate=random.getstate())

            with open(CP, "wb") as cp_file:
                pickle.dump(cp, cp_file, -1)
예제 #38
0
def compose(params):
    global window, chords_in_vector

    start = time()

    pop_size = 35     # int(params[0])
    num_gens = 65     # int(params[1])
    tourn_size = int(params[0])
    ind_pb = params[1]
    cx_pb = params[2]
    mut_pb = params[3]

    creator.create("FitnessMulti", base.Fitness, weights=(-1.0, 1.0))
    creator.create("Individual", list, fitness=creator.FitnessMulti)

    toolbox = base.Toolbox()

    IND_SIZE = chords_in_vector - len(window)

    toolbox.register("attr_chord", cg.generate_chord)
    toolbox.register("individual", tools.initRepeat, creator.Individual, toolbox.attr_chord, n=IND_SIZE)
    toolbox.register("population", tools.initRepeat, list, toolbox.individual)

    toolbox.register("evaluate", predict)
    toolbox.register("mate", tools.cxTwoPoint)
    toolbox.register("mutate", mutate_individual, indpb=ind_pb)
    toolbox.register("select", tools.selTournament, tournsize=tourn_size)

    population = toolbox.population(n=pop_size)

    NGEN = num_gens
    for gen in range(NGEN):
        offspring = algorithms.varAnd(population, toolbox, cxpb=cx_pb, mutpb=mut_pb)
        fits = toolbox.map(toolbox.evaluate, offspring)
        for fit, ind in zip(fits, offspring):
            ind.fitness.values = fit
        population = toolbox.select(offspring, k=len(population))

    top = tools.selBest(population, k=1)[0]

    np.set_printoptions(threshold=np.nan, suppress=True)
    #pprint("%s, %s" % (window, top))
    #pprint(predict(top))

    score = predict(top)

    end = time()

    run_time = end - start

    #time_dist = power(absolute(20 - run_time), 2) + 1
    #f = -log(score[1] / time_dist)

    f = -log(score[1]) * 100000000

    print(params)
    print("{:2.10f}".format(f))
    results.append([list(params), f])
    return f
예제 #39
0
def eaSimpleCustom(population,
                   toolbox,
                   cxpb,
                   mutpb,
                   sgen=1,
                   ngen=1,
                   stats=None,
                   halloffame=None,
                   verbose=__debug__):
    logbook = tools.Logbook()
    logbook.header = ['gen', 'nevals'] + (stats.fields if stats else [])

    # Evaluate the individuals with an invalid fitness
    invalid_ind = [ind for ind in population if not ind.fitness.valid]

    fitnesses = eval_exec_async(toolbox.evaluate, invalid_ind)
    for ind, fit in zip(invalid_ind, fitnesses):
        ind.fitness.values = fit

    if halloffame is not None:
        halloffame.update(population)
        log_hof(sgen, halloffame)

    record = stats.compile(population) if stats else {}
    logbook.record(gen=sgen, nevals=len(invalid_ind), **record)
    if verbose:
        log_stats(logbook.stream)

    # Begin the generational process
    for gen in range(sgen, ngen + 1):
        # Select the next generation individuals
        offspring = toolbox.select(population, len(population))

        # Vary the pool of individuals
        offspring = algorithms.varAnd(offspring, toolbox, cxpb, mutpb)

        # Evaluate the individuals with an invalid fitness
        invalid_ind = [ind for ind in offspring if not ind.fitness.valid]

        fitnesses = eval_exec_async(toolbox.evaluate, invalid_ind)
        for ind, fit in zip(invalid_ind, fitnesses):
            ind.fitness.values = fit

        # Update the hall of fame with the generated individuals
        if halloffame is not None:
            halloffame.update(offspring)
            log_hof(gen, halloffame)

        # Replace the current population by the offspring
        population[:] = offspring
        population_persist(population, gen)

        # Append the current generation statistics to the logbook
        record = stats.compile(population) if stats else {}
        logbook.record(gen=gen, nevals=len(invalid_ind), **record)
        if verbose:
            log_stats(logbook.stream)

    return population, logbook
예제 #40
0
파일: genetic.py 프로젝트: anhpt204/ctp
def evolve(population,
           toolbox,
           cxpb,
           mutpb,
           ngen,
           stats=None,
           halloffame=None,
           verbose=__debug__):

    logbook = tools.Logbook()
    logbook.header = ['gen', 'nevals'] + (stats.fields if stats else [])

    # Evaluate the individuals with an invalid fitness
    invalid_ind = [ind for ind in population if not ind.fitness.valid]
    fitnesses = toolbox.map(toolbox.evaluate, invalid_ind)
    for ind, fit in zip(invalid_ind, fitnesses):
        ind.fitness.values = fit

    if halloffame is not None:
        halloffame.update(population)

    record = stats.compile(population) if stats else {}
    logbook.record(gen=0, nevals=len(invalid_ind), **record)
    if verbose:
        print logbook.stream

    # Begin the generational process
    for gen in range(1, ngen + 1):
        # Select the next generation individuals
        offspring = toolbox.select(population, len(population))

        # Vary the pool of individuals
        offspring = varAnd(offspring, toolbox, cxpb, mutpb)

        # Evaluate the individuals with an invalid fitness
        invalid_ind = [ind for ind in offspring if not ind.fitness.valid]
        fitnesses = toolbox.map(toolbox.evaluate, invalid_ind)
        for ind, fit in zip(invalid_ind, fitnesses):
            ind.fitness.values = fit

        # Update the hall of fame with the generated individuals
        if halloffame is not None:
            halloffame.update(offspring)

        # Replace the current population by the offspring
        population[:] = offspring

        # elitism
        t = random.randint(0, len(population) - 1)
        #         t = 0
        population[t] = halloffame[0]

        # Append the current generation statistics to the logbook
        record = stats.compile(population) if stats else {}
        logbook.record(gen=gen, nevals=len(invalid_ind), **record)
        if verbose:
            print logbook.stream

    return population, logbook
예제 #41
0
def run_ea(fitness_function, time_function, max_evals, max_gen, n_cpus=50, pop_size=100, cxpb = 0.8, mutpb= 0.1):

    toolbox = create_toolbox(fitness_function)
    initial_pop = toolbox.population(n=pop_size)
    aspirant_pairs = utils.generate_aspirant_pairs(pop_size)

    pool = ParallelSimulator(n_cpus=n_cpus, eval_func=toolbox.evaluate, time_func=time_function)

    start = datetime.datetime.now()
    last = start

    gens = [Generation(pop_size, tournament_aspirants=aspirant_pairs, pop=initial_pop)]

    t = 0
    best_ind = None

    while pool.evals < max_evals:

        # submit individuals for current generation
        for idx, ind in enumerate(gens[t].pop):
            if not ind.fitness.valid:
                ind.pop_idx = idx
                pool.submit(ind)

        while not pool.all_evaluations_finished():
            result = pool.next_finished()
            ind = result.args[0]
            gens[t].pop[ind.pop_idx].fitness.values = result.value
            if not best_ind or ind.fitness > best_ind.fitness:
                best_ind = ind

        pop = gens[t].pop

        # finish tournament selection
        gens[t].selected = [max(pop[asp1], pop[asp2], key=attrgetter('fitness')) for asp1, asp2 in gens[t].tournament_aspirants]

        # run operators
        gens[t].offspring = map(toolbox.clone, gens[t].selected)
        gens[t].offspring = algorithms.varAnd(gens[t].offspring, toolbox, cxpb, mutpb)

        # create next generation
        gens.append(Generation(pop_size, tournament_aspirants=utils.generate_aspirant_pairs(pop_size), pop=gens[t].offspring[:]))

        t += 1

        # print logging information every second
        now = datetime.datetime.now()
        if now - last > datetime.timedelta(seconds=1):
            runtime = (now - start).total_seconds()
            print('TIME:', runtime, 'SPEED:', pool.evals / runtime)
            last = now

    end = datetime.datetime.now()
    print(pool.evals / (end - start).total_seconds())
    print(pool.evals)
    print(pool.current_time)
    pool.print_stats()

    return best_ind, pool.log
예제 #42
0
def eaSimpleModified(population, toolbox, cxpb, mutpb, ngen, stats=None,
             halloffame=None, verbose=__debug__):
    logbook = tools.Logbook()
    logbook.header = ['gen', 'nevals'] + (stats.fields if stats else [])

    # Evaluate the individuals with an invalid fitness
    invalid_ind = [ind for ind in population if not ind.fitness.valid]
    fitnesses = toolbox.map(toolbox.evaluate, invalid_ind)
    for ind, fit in zip(invalid_ind, fitnesses):
        ind.fitness.values = fit

    if halloffame is not None:
        halloffame.update(population)

    record = stats.compile(population) if stats else {}
    logbook.record(gen=0, nevals=len(invalid_ind), **record)
    if verbose:
        print(logbook.stream)

    best = []

    best_ind = max(population, key=attrgetter("fitness"))
    best.append(best_ind)

    # Begin the generational process
    for gen in range(1, ngen + 1):
        # Select the next generation individuals
        offspring = toolbox.select(population, len(population))

        # Vary the pool of individuals
        offspring = algorithms.varAnd(offspring, toolbox, cxpb, mutpb)

        # Evaluate the individuals with an invalid fitness
        invalid_ind = [ind for ind in offspring if not ind.fitness.valid]
        fitnesses = toolbox.map(toolbox.evaluate, invalid_ind)
        for ind, fit in zip(invalid_ind, fitnesses):
            ind.fitness.values = fit

        # Save the best individual from the generation
        best_ind = max(offspring, key=attrgetter("fitness"))
        best.append(best_ind)

        # Update the hall of fame with the generated individuals
        if halloffame is not None:
            halloffame.update(offspring)

        # Replace the current population by the offspring
        population[:] = offspring

        # Append the current generation statistics to the logbook
        record = stats.compile(population) if stats else {}
        logbook.record(gen=gen, nevals=len(invalid_ind), **record)
        if verbose:
            print(logbook.stream)

    return population, logbook, best
예제 #43
0
def eaSimpleWarp(population, toolbox, filename, cxpb, mutpb, ngen, stats=None,
                 halloffame=None, verbose=__debug__, labels=None):
    logbook = tools.Logbook()
    logbook.header = ['gen', 'nevals'] + (stats.fields if stats else [])

    # Evaluate the individuals with an invalid fitness
    # TODO: Change fitness evaluation to operate on the population not on individuals
    # TODO because all fitnesses are returned from WARP we need to pass all to the batch script simulatneously
    # TODO and then wait.
    # generate_fitnesses(population, toolbox)

    # Find which individuals have no fitness assigned (probably all of them here)
    fitnesses = return_efficiency(population, 'generation_0')
    print fitnesses
    # Assign new fitness values to the individuals
    for ind, fit in zip(population, fitnesses):
        ind.fitness.values = (fit,)
    # Update HoF
    if halloffame is not None:
        halloffame.update(population)

    save_generation(filename, population, generation=0, labels=None)

    # Begin the generational process
    for gen in range(1, ngen + 1):
        print "Starting Generation: {}".format(gen)
        # Select the next generation individuals
        offspring = toolbox.select(population, len(population))

        # Vary the pool of individuals
        offspring = varAnd(offspring, toolbox, cxpb, mutpb)

        # ######################## Start server setup routine ##################################################

        # ######################## End server setup routine ####################################################
        fitnesses = return_efficiency(offspring, 'generation_{}'.format(gen))
        for ind, fit in zip(offspring, fitnesses):
            ind.fitness.values = (fit,)

        # Update the hall of fame with the generated individuals
        if halloffame is not None:
            halloffame.update(offspring)

        # Replace the current population by the offspring
        population[:] = offspring

        # Append the current generation statistics to the logbook and save data file
        save_generation(filename, population, generation=gen, labels=None)
        #         record = stats.compile(population) if stats else {}
        #         logbook.record(gen=gen, nevals=len(invalid_ind), **record)
        #         if verbose:
        #             print logbook.stream
        print "Completed Generation: {}".format(gen)

    # TODO switch return back to population
    return offspring, logbook
예제 #44
0
def main(extended=True, verbose=True):
    target_set = []
    species = []
    
    stats = tools.Statistics(lambda ind: ind.fitness.values, n=TARGET_TYPE)
    stats.register("avg", tools.mean)
    stats.register("std", tools.std)
    stats.register("min", min)
    stats.register("max", max)
    
    if verbose:
        column_names = ["gen", "species", "evals"]
        column_names.extend(stats.functions.keys())
        logger = tools.EvolutionLogger(column_names)
        logger.logHeader()
    
    ngen = 200
    g = 0
    
    schematas = nicheSchematas(TARGET_TYPE, IND_SIZE)
    for i in range(TARGET_TYPE):
        size = int(TARGET_SIZE/TARGET_TYPE)
        target_set.extend(toolbox.target_set(schematas[i], size))
        species.append(toolbox.species())
    
    # Init with a random representative for each species
    representatives = [random.choice(s) for s in species]
    
    while g < ngen:
        # Initialize a container for the next generation representatives
        next_repr = [None] * len(species)
        for i, s in enumerate(species):
            # Variate the species individuals
            s = algorithms.varAnd(s, toolbox, 0.6, 1.0)
            
            # Get the representatives excluding the current species
            r = representatives[:i] + representatives[i+1:]
            for ind in s:
                ind.fitness.values = toolbox.evaluate([ind] + r, target_set)
            
            stats.update(s, index=i)
            
            if verbose: 
                logger.logGeneration(gen=g, species=i, evals=len(s), stats=stats, index=i)
            
            # Select the individuals
            species[i] = toolbox.select(s, len(s))  # Tournament selection
            next_repr[i] = toolbox.get_best(s)[0]   # Best selection
        
            g += 1
        representatives = next_repr

    if extended:
        for r in representatives:
            print("".join(str(x) for x in r))
예제 #45
0
def runCoEA(toolbox, stats, logbook, numGen=100, rnd=False, cxp=0.6, mutp=1.0, **kwargs):
    """Initializes and runs the coevolutionary algorithm.

    :returns: the best individual of the run."""
    # RUN IT
    log.info("CxP: %f; MutP: %f" % (cxp, mutp))
    log.info("Creating the population...")
    NUMSPECIES = 2
    species_index = list(range(NUMSPECIES))
    species = [toolbox.species() for _ in range(NUMSPECIES)]
    representatives = [random.choice(species[i]) for i in range(NUMSPECIES)]
    representatives[0].fitness.values = (toolbox.evaluate(representatives, curspecies=0),)
    representatives[1].fitness.values = (toolbox.evaluate(representatives[::-1], curspecies=1),)
    # pop = toolbox.population(n=4)
    bestsofar = [random.choice(species[i]) for i in range(NUMSPECIES)]
    bestsofar[0].fitness.values = (toolbox.evaluate(bestsofar, curspecies=0),)
    bestsofar[1].fitness.values = (toolbox.evaluate(bestsofar[::-1], curspecies=1),)
    log.info("Running the algorithm...")
    for g in xrange(numGen):
        # Initialize a container for the next generation representatives
        next_repr = [None] * len(species)
        for (i, s), j in zip(enumerate(species), species_index):
            # Vary the species individuals
            s = algorithms.varAnd(s, toolbox, cxp, mutp)
            # Get the representatives excluding the current species
            r = representatives[:i] + representatives[i + 1 :]
            for ind in s:
                log.debug("Evaluating species %d" % (j,))
                log.debug(r)
                # Evaluate and set the individual fitness
                ind.fitness.values = (toolbox.evaluate([ind] + r, curspecies=j),)

            # Select the individuals
            species[i] = toolbox.select(s, len(s))  # Tournament selection
            if not rnd:
                next_repr[i] = toolbox.get_best(species[i])[0]  # Best selection
            else:
                next_repr[i] = random.choice(species[i])

            # Update stats
            record = stats.compile(s)
            logbook.record(gen=g, species=j, evals=len(s), **record)
            log.info(logbook.stream)

        for i in species_index:
            if next_repr[i].fitness.values <= representatives[i].fitness.values:
                representatives[i] = next_repr[i]
            # for index in range(len(representatives)):
            if representatives[i].fitness.values < bestsofar[i].fitness.values:
                bestsofar[i] = representatives[i]

    log.info("Done!\n")
    log.info(bestsofar[0])
    log.info(bestsofar[1])
    return bestsofar
예제 #46
0
def main():
    random.seed(64)

    NBR_DEMES = 3
    MU = 300
    NGEN = 40
    CXPB = 0.5
    MUTPB = 0.2
    MIG_RATE = 5    
    
    demes = [toolbox.population(n=MU) for _ in range(NBR_DEMES)]
    hof = tools.HallOfFame(1)
    stats = tools.Statistics(lambda ind: ind.fitness.values, 4)
    stats.register("avg", tools.mean)
    stats.register("std", tools.std)
    stats.register("min", min)
    stats.register("max", max)
    
    column_names = ["gen", "deme", "evals"]
    column_names.extend(stats.functions.keys())
    logger = tools.EvolutionLogger(column_names)
    logger.logHeader()
    
    for idx, deme in enumerate(demes):
        for ind in deme:
            ind.fitness.values = toolbox.evaluate(ind)
        stats.update(deme, idx)
        hof.update(deme)
        logger.logGeneration(gen="0", deme=idx, evals=len(deme), stats=stats, index=idx)
    
    stats.update(demes[0]+demes[1]+demes[2], 3)
    logger.logGeneration(gen=0, deme=idx, evals="-", stats=stats, index=3)
    
    gen = 1
    while gen <= NGEN and stats.max[3][-1][0] < 100.0:
        for idx, deme in enumerate(demes):
            deme[:] = toolbox.select(deme, len(deme))
            deme[:] = algorithms.varAnd(deme, toolbox, cxpb=CXPB, mutpb=MUTPB)
            
            invalid_ind = [ind for ind in deme if not ind.fitness.valid]
            for ind in invalid_ind:
                ind.fitness.values = toolbox.evaluate(ind)
            
            stats.update(deme, idx)
            hof.update(deme)
            logger.logGeneration(gen="%d" %gen, deme=idx, evals=len(invalid_ind), stats=stats, index=idx)
            
        if gen % MIG_RATE == 0:
            toolbox.migrate(demes)
        stats.update(demes[0]+demes[1]+demes[2], 3)
        logger.logGeneration(gen="%d" % gen, deme="-", evals="-", stats=stats, index=3)
        gen += 1
    
    return demes, stats, hof
예제 #47
0
파일: paralg.py 프로젝트: JiriVanek/GAKeras
 def gen_new_offspring():
     valid_offspring = True
     offspring = None
     while valid_offspring:
         # select two individuals and clone them 
         offspring = map(toolbox.clone, toolbox.select(population, 2))
         # apply crossover and mutation, take the first offspring
         offspring = algorithms.varAnd(offspring, toolbox, cxpb, mutpb)[0]
         valid_offspring = offspring.fitness.valid
         # if the offspring is valid it is already in the population
     return offspring 
예제 #48
0
파일: generate.py 프로젝트: tyarkoni/precis
    def _evolve(self, measure, population, toolbox, ngen, cxpb, mutpb,
                verbose=True):
        ''' Main evolution algorithm. A tweaked version of the eaSimple
        algorithm included in the DEAP package that adds per-generation logging
        of the best individual's properties and drops all the
        Statistics/HallOfFame stuff (since we're handling that ourselves). See
        DEAP documentation of algorithms.eaSimple() for all arguments.
        '''

        # if verbose:
        #     column_names = ["gen", "evals"]
        #     if stats is not None:
        #         column_names += stats.functions.keys()
        # logger = tools.Logbook(column_names)
        # logger.logHeader()
        # logger.logGeneration(evals=len(population), gen=0, stats=stats)

        # Begin the generational process
        for gen in range(0, ngen):

            # Select the next generation individuals
            offspring = toolbox.select(population, k=len(population))

            # Variate the pool of individuals
            offspring = algorithms.varAnd(offspring, toolbox, cxpb, mutpb)

            # Evaluate the individuals with an invalid fitness
            invalid_ind = [ind for ind in offspring if not ind.fitness.valid]
            fitnesses = toolbox.map(toolbox.evaluate, invalid_ind)
            for ind, fit in zip(invalid_ind, fitnesses):
                ind.fitness.values = fit

            # Replace the current population by the offspring
            offspring = sorted(
                offspring, key=lambda x: x.fitness, reverse=True)
            population[:] = offspring

            # Save best individual as an AbbreviatedMeasure
            self.best_individuals.append(population[0])
            best_abb = AbbreviatedMeasure(
                self.measure, population[0], abbreviator=self.abbreviator,
                evaluator=self.evaluator, stats=True)
            self.best_measures.append(best_abb)
            r_squared = np.round(best_abb.r_squared.mean(), 2)
            n_items = np.sum(population[0])

            # Update the statistics with the new population
            if self.stats is not None:
                record = self.stats.compile(population)
                self.logbook.record(
                    gen=gen, r_squared=r_squared, n_items=n_items, **record)

        # Save last population in case we want to resume
        self.pop = population
예제 #49
0
def main():
    if os.path.isfile(CP):
        # A file name has been given, then load the data from the file
	cp = read_checkpoint()
        population = cp["population"]
        start_gen = cp["generation"] + 1
        halloffame = cp["halloffame"]
        logbook = cp["logbook"]
        random.setstate(cp["rndstate"])
    else:
        # Start a new evolution
        random.seed()
        population = toolbox.population(n=300)
        start_gen = 0
        halloffame = tools.HallOfFame(maxsize=1)
        logbook = tools.Logbook()

    stats_fit = tools.Statistics(lambda ind: ind.fitness.values)
    stats_size = tools.Statistics(len)
    mstats = tools.MultiStatistics(fitness=stats_fit, size=stats_size)
    mstats.register("avg", numpy.mean)
    mstats.register("std", numpy.std)
    mstats.register("min", numpy.min)
    mstats.register("max", numpy.max)

    #algorithms.eaSimple(pop, toolbox, 0.5, 0.2, NGEN, mstats, halloffame=hof)
    #print(hof[0])

    begin = start_gen
    end = begin + NGEN
    print("begin: {},  end: {}".format(begin, end))
    for gen in range(begin, end):
        population = algorithms.varAnd(population, toolbox, cxpb=toolbox.mate, mutpb=toolbox.mutate)

        # Evaluate the individuals with an invalid fitness
        invalid_ind = [ind for ind in population if not ind.fitness.valid]
        fitnesses = toolbox.map(toolbox.evaluate, invalid_ind)
        for ind, fit in zip(invalid_ind, fitnesses):
            ind.fitness.values = fit

        halloffame.update(population)
        record = mstats.compile(population)
        logbook.record(gen=gen, evals=len(invalid_ind), **record)

        population = toolbox.select(population, k=len(population))

        if (gen + 1) % FREQ == 0 or gen == end - 1:
            # Fill the dictionary using the dict(key=value[, ...]) constructor
            cp = dict(population=population, generation=gen, halloffame=halloffame,
                      logbook=logbook, rndstate=random.getstate())

            with open(CP, "wb") as cp_file:
                pickle.dump(cp, cp_file, -1)
예제 #50
0
파일: advanced.py 프로젝트: Gab0/e-vchess
def evolve_machines(POP):
    population = POP

    offspring = algorithms.varAnd(population, toolbox, cxpb=0.5, mutpb=0.1)

    fits = toolbox.map(toolbox.evaluate, population)
    for fit, ind in zip(fits, population):
        ind.fitness = fit
    population = toolbox.select(population, k=len(population))
    top10 = tools.selBest(population, k=10)

    return population
예제 #51
0
def main(extended=True, verbose=True):
    target_set = []
    species = []
    
    stats = tools.Statistics(lambda ind: ind.fitness.values)
    stats.register("avg", numpy.mean)
    stats.register("std", numpy.std)
    stats.register("min", numpy.min)
    stats.register("max", numpy.max)
    
    logbook = tools.Logbook()
    logbook.header = "gen", "species", "evals", "std", "min", "avg", "max"
    
    ngen = 200
    g = 0
    
    schematas = nicheSchematas(TARGET_TYPE, IND_SIZE)
    for i in range(TARGET_TYPE):
        size = int(TARGET_SIZE/TARGET_TYPE)
        target_set.extend(toolbox.target_set(schematas[i], size))
        species.append(toolbox.species())
    
    # Init with a random representative for each species
    representatives = [random.choice(s) for s in species]
    
    while g < ngen:
        # Initialize a container for the next generation representatives
        next_repr = [None] * len(species)
        for i, s in enumerate(species):
            # Vary the species individuals
            s = algorithms.varAnd(s, toolbox, 0.6, 1.0)
            
            # Get the representatives excluding the current species
            r = representatives[:i] + representatives[i+1:]
            for ind in s:
                ind.fitness.values = toolbox.evaluate([ind] + r, target_set)
            
            record = stats.compile(s)
            logbook.record(gen=g, species=i, evals=len(s), **record)
            
            if verbose: 
                print(logbook.stream)
            
            # Select the individuals
            species[i] = toolbox.select(s, len(s))  # Tournament selection
            next_repr[i] = toolbox.get_best(s)[0]   # Best selection
        
            g += 1
        representatives = next_repr

    if extended:
        for r in representatives:
            print("".join(str(x) for x in r))
예제 #52
0
def main(procid, pipein, pipeout, sync, seed=None):
    random.seed(seed)
    toolbox.register("migrate", migPipe, k=5, pipein=pipein, pipeout=pipeout,
        selection=tools.selBest, replacement=random.sample)

    MU = 300
    NGEN = 40
    CXPB = 0.5
    MUTPB = 0.2
    MIG_RATE = 5
    
    deme = toolbox.population(n=MU)
    hof = tools.HallOfFame(1)
    stats = tools.Statistics(lambda ind: ind.fitness.values)
    stats.register("avg", numpy.mean)
    stats.register("std", numpy.std)
    stats.register("min", numpy.min)
    stats.register("max", numpy.max)
    
    logbook = tools.Logbook()
    logbook.header = "gen", "deme", "evals", "std", "min", "avg", "max"
    
    for ind in deme:
        ind.fitness.values = toolbox.evaluate(ind)
    record = stats.compile(deme)
    logbook.record(gen=0, deme=procid, evals=len(deme), **record)
    hof.update(deme)
    
    if procid == 0:
        # Synchronization needed to log header on top and only once
        print(logbook.stream)
        sync.set()
    else:
        logbook.log_header = False  # Never output the header
        sync.wait()
        print(logbook.stream)
    
    for gen in range(1, NGEN):
        deme = toolbox.select(deme, len(deme))
        deme = algorithms.varAnd(deme, toolbox, cxpb=CXPB, mutpb=MUTPB)
        
        invalid_ind = [ind for ind in deme if not ind.fitness.valid]
        for ind in invalid_ind:
            ind.fitness.values = toolbox.evaluate(ind)
        
        hof.update(deme)
        record = stats.compile(deme)
        logbook.record(gen=gen, deme=procid, evals=len(deme), **record)
        print(logbook.stream)
            
        if gen % MIG_RATE == 0 and gen > 0:
            toolbox.migrate(deme)
예제 #53
0
	def train(self, pop = 20, gen = 10):
		from deap import algorithms
		from deap import base
		from deap import creator
		from deap import tools
		from deap.tools import Statistics
		# import random
		

		from scipy.stats import rv_discrete

		# creator.create("FitnessMulti", base.Fitness, weights=(1.0, -1.0))
		# creator.create("Individual", list, fitness=creator.FitnessMulti)

		creator.create("FitnessMin", base.Fitness, weights=(-1.0,))
		creator.create("Individual", list, fitness=creator.FitnessMin)

		toolbox = base.Toolbox()
		# Attribute generator
		custm = rv_discrete(name='custm', values=(self.a_w.index, self.a_w.values))

		toolbox.register("attr_int", custm.rvs)
		# Structure initializers
		toolbox.register("individual", tools.initRepeat, creator.Individual, toolbox.attr_int, n=len(self.s))
		toolbox.register("population", tools.initRepeat, list, toolbox.individual, n=pop)

		# Operator registering
		toolbox.register("evaluate", self.eval_classifer)
		toolbox.register("mate", tools.cxUniform, indpb=0.5)
		toolbox.register("mutate", tools.mutUniformInt, low=min(self.a.index), up=max(self.a.index), indpb=0.1)
		toolbox.register("select", tools.selNSGA2)

		MU, LAMBDA = pop, pop
		population = toolbox.population(n=MU)
		hof = tools.ParetoFront()
		
		s = Statistics(key=lambda ind: ind.fitness.values)
		s.register("mean", np.mean)
		s.register("min", min)

		# pop, logbook = algorithms.eaMuPlusLambda(pop, toolbox, mu=MU, lambda_=LAMBDA, cxpb=0.7, mutpb=0.3, ngen=gen, stats=s, halloffame=hof)
		for i in range(gen):
			offspring = algorithms.varAnd(population, toolbox, cxpb=0.95, mutpb=0.1)
			fits = toolbox.map(toolbox.evaluate, offspring)
			for fit, ind in zip(fits, offspring):
				ind.fitness.values = fit

			population = tools.selBest(offspring, int(0.05*len(offspring))) + tools.selTournament(offspring, len(offspring)-int(0.05*len(offspring)), tournsize=3)
			# population = toolbox.select(offspring, k=len(population))
			print s.compile(population)
		top10 = tools.selBest(population, k=10)
		return top10
예제 #54
0
def main(procid, pipein, pipeout, sync, seed=None):
    random.seed(seed)
    toolbox.register(
        "migrate", migPipe, k=5, pipein=pipein, pipeout=pipeout, selection=tools.selBest, replacement=random.sample
    )

    MU = 300
    NGEN = 100
    CXPB = 0.8
    MUTPB = 1
    MIG_RATE = 5

    deme = toolbox.population(n=MU)
    hof = tools.HallOfFame(1)
    stats = tools.Statistics(lambda ind: ind.fitness.values)
    stats.register("avg", tools.mean)
    stats.register("std", tools.std)
    stats.register("min", min)
    stats.register("max", max)

    logger = tools.EvolutionLogger(["gen", "deme", "evals"] + stats.functions.keys())
    if procid == 0:
        # Synchronization needed to log header on top and only once
        logger.logHeader()
        sync.set()
    else:
        sync.wait()

    for ind in deme:
        ind.fitness.values = toolbox.evaluate(ind)
    stats.update(deme)
    hof.update(deme)
    logger.logGeneration(gen="0", deme=procid, evals=len(deme), stats=stats)

    for gen in range(1, NGEN):
        deme = toolbox.select(deme, len(deme))
        deme = algorithms.varAnd(deme, toolbox, cxpb=CXPB, mutpb=MUTPB)

        invalid_ind = [ind for ind in deme if not ind.fitness.valid]
        for ind in invalid_ind:
            ind.fitness.values = toolbox.evaluate(ind)

        stats.update(deme)
        hof.update(deme)
        logger.logGeneration(gen="%d" % gen, deme=procid, evals=len(invalid_ind), stats=stats)

        if gen % MIG_RATE == 0 and gen > 0:
            toolbox.migrate(deme)
    print "Best individual:  " + str(convertArrToFloat(hof[-1]))
    print "Rastrigin value: " + str(rastrigin_arg0(hof[-1])[0]) + "\n\n\n"
예제 #55
0
	def train(self, pop = 20, gen = 10):
		from deap import algorithms
		from deap import base
		from deap import creator
		from deap import tools
		import random
		import numpy as np

		from deap.tools import Statistics

		# creator.create("FitnessMulti", base.Fitness, weights=(1.0, -1.0))
		# creator.create("Individual", list, fitness=creator.FitnessMulti)

		creator.create("FitnessMax", base.Fitness, weights=(1.0,))
		creator.create("Individual", list, fitness=creator.FitnessMax)

		toolbox = base.Toolbox()
		# Attribute generator
		toolbox.register("attr_bool", random.randint, 0, 1)
		# Structure initializers
		toolbox.register("individual", tools.initRepeat, creator.Individual, toolbox.attr_bool, n=len(self.X.columns))
		toolbox.register("population", tools.initRepeat, list, toolbox.individual, n=pop)

		# Operator registering
		toolbox.register("evaluate", self.eval_classifer)
		toolbox.register("mate", tools.cxUniform, indpb=0.1)
		toolbox.register("mutate", tools.mutFlipBit, indpb=0.05)
		# toolbox.register("select", tools.selNSGA2)

		MU, LAMBDA = pop, pop
		population = toolbox.population(n=MU)
		# hof = tools.ParetoFront()
		
		s = Statistics(key=lambda ind: ind.fitness.values)
		s.register("mean", np.mean)
		s.register("max", max)

		# pop, logbook = algorithms.eaMuPlusLambda(pop, toolbox, mu=MU, lambda_=LAMBDA, cxpb=0.7, mutpb=0.3, ngen=gen, stats=s, halloffame=hof)
		for i in range(gen):
			offspring = algorithms.varAnd(population, toolbox, cxpb=0.95, mutpb=0.1)
			fits = toolbox.map(toolbox.evaluate, offspring)
			for fit, ind in zip(fits, offspring):
				ind.fitness.values = fit

			population = tools.selBest(offspring, int(0.05*len(offspring))) + tools.selTournament(offspring, len(offspring)-int(0.05*len(offspring)), tournsize=3)
			# population = toolbox.select(offspring, k=len(population))
			print s.compile(population)
		top10 = tools.selBest(population, k=10)
		print top10
		return top10[0]
def eaSimple(population, toolbox, cxpb, mutpb, ngen, stats=None,
             halloffame=None, verbose=__debug__):
    logbook = tools.Logbook()
    logbook.header = ['gen', 'nevals'] + (stats.fields if stats else [])

    # Evaluate the individuals with an invalid fitness
    invalid_ind = [ind for ind in population if not ind.fitness.valid]
    fitnesses = toolbox.map(toolbox.evaluate, invalid_ind)
    for ind, fit in zip(invalid_ind, fitnesses):
        ind.fitness.values = fit

    if halloffame is not None:
        halloffame.update(population)

    record = stats.compile(population) if stats else {}
    logbook.record(gen=0, nevals=len(invalid_ind), **record)
    if verbose:
        print logbook.stream

    # Begin the generational process
    gen = 1
    while evalNumThreaten(tools.selBest(population, k=1)[0])[0] != 0:
        gen += 1
        # Select the next generation individuals
        offspring = toolbox.select(population, len(population))

        # Vary the pool of individuals
        offspring = algorithms.varAnd(offspring, toolbox, cxpb, mutpb)

        # Evaluate the individuals with an invalid fitness
        invalid_ind = [ind for ind in offspring if not ind.fitness.valid]
        fitnesses = toolbox.map(toolbox.evaluate, invalid_ind)
        for ind, fit in zip(invalid_ind, fitnesses):
            ind.fitness.values = fit

        # Update the hall of fame with the generated individuals
        if halloffame is not None:
            halloffame.update(offspring)

        # Replace the current population by the offspring
        population[:] = offspring

        # Append the current generation statistics to the logbook
        record = stats.compile(population) if stats else {}
        logbook.record(gen=gen, nevals=len(invalid_ind), **record)
        if verbose:
            print logbook.stream
    print 'total generations is',gen
    return population, logbook
예제 #57
0
def main():
    random.seed(64)

    NBR_DEMES = 3
    MU = 300
    NGEN = 40
    CXPB = 0.5
    MUTPB = 0.2
    MIG_RATE = 5

    demes = [toolbox.population(n=MU) for _ in range(NBR_DEMES)]
    hof = tools.HallOfFame(1)

    stats = tools.Statistics(lambda ind: ind.fitness.values)
    stats.register("avg", numpy.mean)
    stats.register("std", numpy.std)
    stats.register("min", numpy.min)
    stats.register("max", numpy.max)

    logbook = tools.Logbook()
    logbook.header = "gen", "deme", "evals", "std", "min", "avg", "max"

    for idx, deme in enumerate(demes):
        for ind in deme:
            ind.fitness.values = toolbox.evaluate(ind)
        logbook.record(gen=0, deme=idx, evals=len(deme), **stats.compile(deme))
        hof.update(deme)
    print(logbook.stream)

    gen = 1
    while gen <= NGEN and logbook[-1]["max"] < 100.0:
        for idx, deme in enumerate(demes):
            deme[:] = toolbox.select(deme, len(deme))
            deme[:] = algorithms.varAnd(deme, toolbox, cxpb=CXPB, mutpb=MUTPB)

            invalid_ind = [ind for ind in deme if not ind.fitness.valid]
            for ind in invalid_ind:
                ind.fitness.values = toolbox.evaluate(ind)

            logbook.record(gen=gen, deme=idx, evals=len(
                deme), **stats.compile(deme))
            hof.update(deme)
        print(logbook.stream)

        if gen % MIG_RATE == 0:
            toolbox.migrate(demes)
        gen += 1

    return demes, logbook, hof
예제 #58
0
def main(seed=None):
    random.seed(seed)
    node = Node()
    toolbox.register("migrate", migRingMPI, k=5, node=node,
        selection=tools.selBest, replacement=random.sample)

    MU = 300
    NGEN = 200
    CXPB = 0.5
    MUTPB = 0.2
    MIG_RATE = 5
    
    deme = toolbox.population(n=MU)
    hof = tools.HallOfFame(1)
    stats = tools.Statistics(lambda ind: ind.fitness.values)
    stats.register("avg", tools.mean)
    stats.register("std", tools.std)
    stats.register("min", min)
    stats.register("max", max)
    
    logger = tools.EvolutionLogger(["gen", "deme", "evals"] + stats.functions.keys())
    if rank == 0:
        # Synchronization needed to log header on top and only once
        logger.logHeader()
        
    comm.Barrier()
    
    for ind in deme:
        ind.fitness.values = toolbox.evaluate(ind)
    stats.update(deme)
    hof.update(deme)
    logger.logGeneration(gen="0", deme=rank, evals=len(deme), stats=stats)
    
    for gen in range(1, NGEN):
        deme = toolbox.select(deme, len(deme))
        deme = algorithms.varAnd(deme, toolbox, cxpb=CXPB, mutpb=MUTPB)
        
        invalid_ind = [ind for ind in deme if not ind.fitness.valid]
        for ind in invalid_ind:
            ind.fitness.values = toolbox.evaluate(ind)
        
        stats.update(deme)
        hof.update(deme)
        logger.logGeneration(gen="%d" % gen, deme=rank, evals=len(invalid_ind), stats=stats)
            
        if gen % MIG_RATE == 0 and gen > 0:
            toolbox.migrate(deme)
예제 #59
0
    def run(self):
        meta_spec = self.experiment.spec['meta']
        ray.init(**meta_spec.get('resources', {}))
        max_generation = meta_spec['max_generation']
        pop_size = meta_spec['max_trial'] or calc_population_size(self.experiment)
        logger.info(f'EvolutionarySearch max_generation: {max_generation}, population size: {pop_size}')
        trial_data_dict = {}
        config_hash = {}  # config hash_str to trial_index

        toolbox = self.init_deap()
        population = toolbox.population(n=pop_size)
        for gen in range(1, max_generation + 1):
            logger.info(f'Running generation: {gen}/{max_generation}')
            ray_id_to_config = {}
            pending_ids = []
            for individual in population:
                config = dict(individual.items())
                hash_str = util.to_json(config, indent=0)
                if hash_str not in config_hash:
                    trial_index = self.experiment.info_space.tick('trial')['trial']
                    config_hash[hash_str] = config['trial_index'] = trial_index
                    ray_id = run_trial.remote(self.experiment, config)
                    ray_id_to_config[ray_id] = config
                    pending_ids.append(ray_id)
                individual['trial_index'] = config_hash[hash_str]

            trial_data_dict.update(get_ray_results(pending_ids, ray_id_to_config))

            for individual in population:
                trial_index = individual.pop('trial_index')
                trial_data = trial_data_dict.get(trial_index, {'fitness': 0})  # if trial errored
                individual.fitness.values = trial_data['fitness'],

            preview = 'Fittest of population preview:'
            for individual in tools.selBest(population, k=min(10, pop_size)):
                preview += f'\nfitness: {individual.fitness.values[0]}, {individual}'
            logger.info(preview)

            # prepare offspring for next generation
            if gen < max_generation:
                population = toolbox.select(population, len(population))
                # Vary the pool of individuals
                population = algorithms.varAnd(population, toolbox, cxpb=0.5, mutpb=0.5)

        ray.worker.cleanup()
        return trial_data_dict
예제 #60
0
def genetic_keyboard(pop_num, gen_num, input_pop=None):
        #What creator.create does is that it creates a new class. Its name is the first argument of the function.
    # Here on the first line we create a class named FitnessMax().base.Fitness tells you that this class is derived from the class base.Fitness().weight() is explained in the tutorial.

    creator.create("FitnessMin", base.Fitness, weights=(-1.0,))
    # On the second line we create a class named Individual() derived from a list. We add the class creator.Fitness as one of its additionnal attribute.
    creator.create("Individual", list, fitness=creator.FitnessMin)

    toolbox = base.Toolbox()
    toolbox.register("indices", random.sample, range(len(CHARACTERS)), len(CHARACTERS))
    # container – The type to put in the data from func.
    # generator – A function returning an iterable (list, tuple, ...), the content of this iterable will fill the container.
    toolbox.register("individual", tools.initIterate, creator.Individual,
                     toolbox.indices)

    toolbox.register("population", tools.initRepeat, list, 
                     toolbox.individual)
    toolbox.register("evaluate", frequencyFitness)
    #ordered crossover
    toolbox.register("mate", tools.cxOrdered)
    #mutation we will swap elements from two points of the individual.
    toolbox.register("mutate", tools.mutShuffleIndexes, indpb=0.05)
    toolbox.register("select", tools.selTournament, tournsize=3)

    # result, log = algorithms.eaSimple(population, toolbox,
    #                              cxpb=0.8, mutpb=0.2,
    #                              gen_num=400, verbose=False)
    # best_individual = tools.selBest(result, k=1)[0]

    # pop_num = 100
    # gen_num=100
    population = toolbox.population(n=pop_num)
    with open('deap_results', 'w') as f:
        for gen in range(gen_num):
            offspring = algorithms.varAnd(population, toolbox,
                                          cxpb=0.5, mutpb=0.1)
            fits = toolbox.map(toolbox.evaluate, offspring)
            for fit, ind in zip(fits, offspring):
                ind.fitness.values = fit
            population = toolbox.select(offspring, k=len(population))
            # best_individual = tools.selBest(population, k=1)[0]
            # f.write(str(gen) + ' ' + str(frequencyFitness(best_individual)) +
            #         ' ' + str(indices_to_keyboard(best_individual)))
            # f.write('\n')
    return population