def init_simple_genetic_algorithm(self):
ind_size = self.topology_factory.ind_size
self.toolbox = base.Toolbox()
if hasattr(creator, 'FitnessMin') is False:
creator.create('FitnessMin', base.Fitness, weights=(-1.0, ))
if hasattr(creator, 'Individual') is False:
creator.create('Individual', list, fitness=creator.FitnessMin)
ind_size = self.topology_factory.ind_size
att = lambda: random.uniform(-1.0, 1.0)
ind = lambda: tools.initRepeat(creator.Individual, att, n=ind_size)
pop = lambda n: tools.initRepeat(list, ind, n=n)
mut = lambda xs: tools.mutGaussian(xs, mu=0, sigma=1, indpb=0.1)
self.toolbox.register('evaluate', self.objective_function)
self.toolbox.register('mate', tools.cxTwoPoint)
self.toolbox.register('mutate', mut)
self.toolbox.register('select', tools.selTournament, tournsize=3)
self.population = pop(n=self.nind)
self.hof = tools.HallOfFame(1)
self.stats = tools.Statistics(lambda ind: ind.fitness.values)
self.stats.register('min', np.min)
def population(start_pop, f, n):
if start_pop:
pop = tools.initRepeat(list, f, n)
for (i, p) in enumerate(start_pop):
pop[i][:] = start_pop[i]
return pop
return tools.initRepeat(list, f, n)
def __init__(self, cond_tree: gp.PrimitiveTree, val_tree: gp.PrimitiveTree,
fitness: base.Fitness, **kwargs):
super().__init__(**kwargs)
self.cond_trees: List[gp.PrimitiveTree] = tools.initRepeat(
list, cond_tree, NUM_COND_TREES)
self.value_trees: List[gp.PrimitiveTree] = tools.initRepeat(
list, val_tree, NUM_VAL_TREES)
self.fitness = fitness
def maker(icls, attr, dimension):
individual = tools.initRepeat(icls, attr, dimension)
node = py2neo.Node("I", str(SEED), gene=individual, gen=0, fitness=None)
neoNodes.append(node)
neodb.graph.merge(node)
individual.neoNodeIndex = len(neoNodes) - 1
print(individual.neoNodeIndex)
return individual
def __init__(self, individual_size: int, configuration: dict) -> None:
super().__init__()
self.individual_size = individual_size
self.configuration = OptimizerMuLambdaCfg(**configuration)
self.indices = partial(np.random.uniform,
-self.configuration.initial_gene_range,
self.configuration.initial_gene_range,
individual_size)
self.individual = partial(tools.initIterate, Individual, self.indices)
self.population = tools.initRepeat(list,
self.individual,
n=self.configuration.mu)
self.offspring = None
mate_list = [
tools.cxOnePoint, # Executes a one point crossover
tools.cxTwoPoint, # Executes a two point crossover
]
def mate(ind1, ind2):
return np.random.choice(mate_list)(ind1, ind2)
def fct_mutation_learned(ind1):
# need to clip in up-direction because too large numbers create overflows
# need to clip below to avoid stagnation, which happens when a top individuals
# mutates bad strategy parameters
ind1[-1] = np.clip(ind1[-1], -5, 3)
ind1[-2] = np.clip(ind1[-2], -5, 3)
sigma = 2**ind1[-1]
indpb = 2**(ind1[-2] - 3)
# mu here means 'mean' like in a gaussian distribution, sigma therefore standard deviation
return tools.mutGaussian(individual=ind1,
mu=0,
sigma=sigma,
indpb=indpb)
self.toolbox = base.Toolbox()
self.toolbox.register("mate", mate)
self.toolbox.register("mutate", fct_mutation_learned)
self.select = tools.selBest
def initGabilI(container, func, n):
"""Consideramos que un individuo puede ser de 1 a 4 reglas.
"""
return tools.initRepeat(container,func,n*random.randint(1,4))
def population(self, n):
return tools.initRepeat(list, self.toolbox.individual, n)
def individual(self):
return tools.initRepeat(
creator.Individual,
lambda: random.randint(self.minInput, self.maxInput), 3)
data = [np.ones((2, 2)), np.ones((2, 2))]
#toolbox = get_toolbox(data)
#toolbox.register("expr", gp.genHalfAndHalf, pset=pset, min_=1, max_=1)
#toolbox.register("individual", tools.initIterate, creator.Individual, toolbox.expr)
#toolbox.register("population", tools.initRepeat, list, toolbox.individual)
gen_idx = partial(random.sample, list(range(10)), 10)
population = [0, 1, 2, 3]
weights = [0.0, 1, 0.0, 0.0]
n = 10
toolbox = base.Toolbox()
toolbox.register("individual", tools.initIterate, wrap, population, weights, n)
b = toolbox.individual()
print(b)
diff_idx = partial(wrap, population, weights, n)
print(gen_idx)
print(diff_idx)
result = initIterate(list, diff_idx)
print(result)
result = initIterate(list, gen_idx)
print(type(result))
func = register()
ups = initRepeat(list, initIterate(list, diff_idx), n=2)
print(ups)
def population(self, n):
return tools.initRepeat(list, self.toolbox.individual, n)
def individual(self):
return tools.initRepeat(creator.Individual, lambda: random.randint(self.minInput, self.maxInput), 3)
def myInitRepeat(container, func, n):
return tools.initRepeat(container,func,n*random.randint(1,4))
def maker(icls, attr, dimension):
individual = tools.initRepeat(icls, attr, dimension)
individual.cid = tracker.deploy(individual)
return individual
creator.create("Individual", list, fitness=creator.FitnessMax)
def sumOfTwo(a, b):
return a + b
toolbox = base.Toolbox()
toolbox.register("incrementByFive", sumOfTwo, b=5)
toolbox.register("select", tools.selTournament, tournsize=3)
toolbox.register("mate", tools.cxTwoPoint)
toolbox.register("mutate", tools.mutFlipBit, indpb=0.02)
# Population initialization
randomList = tools.initRepeat(list, random.random, 30)
def zeroOrOne():
return random.randint(0, 1)
randomList2 = tools.initRepeat(list, zeroOrOne, 30)
toolbox.register("zeroOrOne", random.randint, 0, 1)
randomList3 = tools.initRepeat(list, toolbox.zeroOrOne, 30)
# Fitness
def someFitnessCalculationFunction(individual):
return None # _some_calculation_of_the_fitness
