def mutate_pop(best_policy, nindividuals, control_str_ids, n_steps):
"""
mutate the best policy of the current time step
"""
list_of_inds = []
for i in range(nindividuals):
# split because there may be more than one control
split_lists = ev.split_gene_by_ctl_ts(best_policy, control_str_ids,
n_steps)
mutated_ind = []
for seg_by_ctl in split_lists:
setting_length = len(seg_by_ctl[0])
# disregard the first control step since we need future policy
seg_by_ctl = seg_by_ctl[1:]
# set setting length to one in case there is only one setting
# mutate the remaining settings
mutated_ctl_segment = []
for seg_by_ts in seg_by_ctl:
tools.mutFlipBit(seg_by_ts, 0.2)
mutated_ctl_segment.extend(seg_by_ts)
# add a random setting for the last time step in the future policy
rand_sttng = [random.randint(0, 1) for i in range(setting_length)]
mutated_ctl_segment.extend(rand_sttng)
# add the new policy for the control structure to the overall pol
mutated_ind.extend(mutated_ctl_segment)
# don't add the new indivi to the pop if identical indivi already there
if mutated_ind not in list_of_inds:
list_of_inds.append(mutated_ind)
return list_of_inds
def mutate(self, individual):
if individual.auto_clustering:
alpha = individual.number_centroids - 1 if individual.number_centroids > 2 else individual.number_centroids
beta = individual.number_centroids + 1 if individual.number_centroids < individual.number_data // 2 else individual.number_centroids
individual.number_centroids = random.randint(alpha, beta)
tools.mutFlipBit(individual.attribute_flags, indpb=self.MUTPB)
return (individual, )
def mutateFlipBit(individual, indpb=0.015, indpb2 = 0.0):
genome = individual[0]
#print genome
genome = tools.mutFlipBit(genome, indpb)[0]
#print genome
individual[0] = genome
return individual,
def mutateOneAb(Ab, mut_rate):
numAttr = Ab.get_all_numeric()
boolAttr = Ab.get_all_boolean()
# print(tools.mutGaussian(numAttr,0,mut_rate,0.5))
Ab.set_all_numeric(tools.mutGaussian(numAttr, 0, mut_rate, 1)[0])
Ab.set_all_boolean(tools.mutFlipBit(boolAttr, mut_rate)[0])
return Ab
def mutate_gus(individual, indpb):
bit_array = individual.binary_vector_weights
new_bit_array = tools.mutFlipBit(bit_array, indpb)
new_bit_array = new_bit_array[0]
individual.binary_vector_weights = new_bit_array
individual.vector_weights = individual.binarray_to_nparray(
new_bit_array, individual.vector_weights.shape)
individual.set_mat_from_vect()
return individual,
def mate(self, parent1, parent2): # Changing the shapes to 1d solut1, solut2 = self._solut_to_1d_shape(parent1.get_solut()), self._solut_to_1d_shape(parent2.get_solut()) # Two point crossover if np.random.random() < self.crossver_prob: solut1, solut2 = tools.cxTwoPoint(solut1, solut2) # Flipbit mutation solut1 = tools.mutFlipBit(solut1, self.mutation_prob) solut2 = tools.mutFlipBit(solut2, self.mutation_prob) if not self.should_validate: solut1, solut2 = self._solut_to_original_shape(solut1), self._solut_to_original_shape(solut2) else: solut1, solut2 = self._solut_to_validation_shape(solut1), self._solut_to_validation_shape(solut2) return solut1, solut2
def main():
spec = Spec(bits=100, pc=0.5, pm=0.2, weights=(1.0,), m=300)
spec.evaluate = lambda ind: (sum(ind),)
spec.judgeExitCondition = judgeExitCondition
spec.selectReproduction = lambda pop: tools.selTournament(
pop, len(pop), tournsize=3)
spec.mate = tools.cxTwoPoint
spec.mutate = lambda ind: tools.mutFlipBit(ind, indpb=0.05)
spec.selectSurvival = lambda parents, children: children
director = Director(spec)
population, i = director.evolveLoop()
best = selectBest(population)
print("evolving times: ", i)
print("best individual: %s %s" % (best, best.fitness.values[0]))
return
def mutate(self, individual, probability):
if self.method == 'Shuffle':
return tools.mutShuffleIndexes(individual, probability)[0]
elif self.method == 'Flipbit':
return tools.mutFlipBit(individual, probability)[0]
def tspd_mutation(ind, indpb_cities, indpb_drone_visiting):
tools.mutShuffleIndexes(ind[0], indpb_cities)
tools.mutFlipBit(ind[1], indpb_drone_visiting)
return ind,
def mutate(self, individual, indpb=0.05):
return tools.mutFlipBit(individual, indpb)
def mut(individual):
return tools.mutFlipBit(individual,MINPDB)
def mutate(ind):
return tools.mutFlipBit(ind, 1 / ind.spec.bits)
def mutate(chrome1, chrome2, mutation_percentage=0.05):
chrome1, chrome2 = tools.mutFlipBit(chrome1,
mutation_percentage), tools.mutFlipBit(
chrome2, mutation_percentage)
return chrome1[0], chrome2[0]
def defaultMutFlipBit(individual):
return tools.mutFlipBit(individual, 0.05)
def defaultMut(individual, MINPDB):
return tools.mutFlipBit(individual, MINPDB)
def mutation_main(individual, indpb, column_names, heating_unit_names_share,
cooling_unit_names_share, column_names_buildings_heating,
column_names_buildings_cooling, district_heating_network,
district_cooling_network):
# create dict of individual with his/her name
individual_with_name_dict = dict(zip(column_names, individual))
if district_heating_network:
# MUTATE BUILDINGS CONNECTED
buildings_heating = [
individual_with_name_dict[column]
for column in column_names_buildings_heating
]
# apply mutations
buildings_heating_mutated = tools.mutFlipBit(buildings_heating,
indpb)[0]
# take back to the individual
for column, mutated_value in zip(column_names_buildings_heating,
buildings_heating_mutated):
individual_with_name_dict[column] = mutated_value
# MUTATE SUPPLY SYSTEM UNITS SHARE
heating_units_share = [
individual_with_name_dict[column]
for column in heating_unit_names_share
]
NDIM = len(heating_unit_names_share)
# apply mutations
heating_units_share_mutated = tools.mutPolynomialBounded(
heating_units_share, eta=20.0, low=0.0, up=1.0,
indpb=1.0 / NDIM)[0]
# takeback to teh individual
for column, mutated_value in zip(heating_unit_names_share,
heating_units_share_mutated):
individual_with_name_dict[column] = mutated_value
if district_cooling_network:
# MUTATE BUILDINGS CONNECTED
buildings_cooling = [
individual_with_name_dict[column]
for column in column_names_buildings_cooling
]
# apply mutations
buildings_cooling_mutated = tools.mutFlipBit(buildings_cooling,
indpb)[0]
# take back to teh individual
for column, mutated_value in zip(column_names_buildings_cooling,
buildings_cooling_mutated):
individual_with_name_dict[column] = mutated_value
# MUTATE SUPPLY SYSTEM UNITS SHARE
cooling_units_share = [
individual_with_name_dict[column]
for column in cooling_unit_names_share
]
NDIM = len(cooling_units_share)
# apply mutations
cooling_units_share_mutated = tools.mutPolynomialBounded(
cooling_units_share, eta=20.0, low=0.0, up=1.0,
indpb=1.0 / NDIM)[0]
# takeback to teh individual
for column, mutated_value in zip(cooling_unit_names_share,
cooling_units_share_mutated):
individual_with_name_dict[column] = mutated_value
# now validate individual
individual_with_name_dict = validation_main(
individual_with_name_dict, column_names_buildings_heating,
column_names_buildings_cooling, district_heating_network,
district_cooling_network)
# now pass all the values mutated to the original individual
for i, column in enumerate(column_names):
individual[i] = individual_with_name_dict[column]
return individual, # add the, because deap needs this
# else:
# job.types.append(furnace_id + '_heating')
# entity_mgr.update(job)
# product_id_list = job.product_id_list()
# for product_id in product_id_list:
# product = entity_mgr.get(product_id)
# product.properties['report'][0]['equipment_id'] = furnace_id
# product.properties['report'][0]['start_time'] = None
# product.properties['report'][0]['end_time'] = None
return furnace_schedule
def score(self):
E = self.simulator.total_results()
T = self.simulator.total_time()
T = (T - self.simulator.start_time).total_seconds()
score = E * self.w1 + T * self.w2
return score
def get_total_weight(self):
total = 0
for j in self.job_list:
weight = j['properties']['ingot']['current_weight']
#weight = job.get_initial_weight(self.entity_mgr)
total += weight
return total
if __name__ == "__main__":
for i in range(5):
print(tools.mutUniformInt([4, 1], 0, 4, 1))
tools.mutFlipBit(array('i', [4, 1, 2, 1, 1, 0, 2, 0, 2, 1, 4, 1, 4, 0, 3, 4, 0, 3, 3]), 1)
def mutate(self,individual,indpb=0.05):
return tools.mutFlipBit(individual,indpb)
