def convert_to_jmoo(problem, pareto_fronts):
tpopulation = []
for front_no, front in enumerate(pareto_fronts[:-1]):
for i, dIndividual in enumerate(front):
cells = []
for j in xrange(len(dIndividual)):
cells.append(dIndividual[j])
tpopulation.append(
jmoo_individual(problem, cells,
list(dIndividual.fitness.values)))
for pop in tpopulation:
pop.front_no = 0 # all the front except the last front
lpopulation = []
for front_no, front in enumerate(pareto_fronts[-1:]):
for i, dIndividual in enumerate(front):
cells = []
for j in xrange(len(dIndividual)):
cells.append(dIndividual[j])
lpopulation.append(
jmoo_individual(problem, cells,
list(dIndividual.fitness.values)))
for pop in lpopulation:
pop.front_no = -1 # last front
from itertools import chain
assert (len(list(chain(*pareto_fronts))) <= len(lpopulation) +
len(tpopulation)), "Non Dominated Sorting is wrong!"
return lpopulation + tpopulation
def gale_nm_Mutate(problem, NDLeafs, configuration):
#################
# Mutation Phase
#################
number_of_evaluation = 0
# After mutation; Convert back to JMOO Data Structures
population = []
for leaf in NDLeafs:
for row in leaf.table.rows:
if row.evaluated:
population.append(jmoo_individual(problem, [x for x in row.cells[:len(problem.decisions)]],
[x for x in row.cells[len(problem.decisions):]]))
number_of_evaluation += 1
else:
population.append(jmoo_individual(problem, [x for x in row.cells[:len(problem.decisions)]], None))
if number_of_evaluation < 2:
while True:
from random import randint
index = randint(0, len(population) - 1)
if population[index].valid is not True:
population[index].evaluate()
number_of_evaluation +=1
break
if number_of_evaluation == 0:
return population, 0
else:
return population, number_of_evaluation
def gale_4_Mutate(problem, NDLeafs, configuration):
#################
# Mutation Phase
#################
number_of_evaluation = 0
# After mutation; Convert back to JMOO Data Structures
population = []
for leaf in NDLeafs:
for row in leaf.table.rows:
if row.evaluated:
population.append(
jmoo_individual(
problem,
[x for x in row.cells[:len(problem.decisions)]],
[x for x in row.cells[len(problem.decisions):]]))
number_of_evaluation += 1
else:
population.append(
jmoo_individual(
problem,
[x for x in row.cells[:len(problem.decisions)]], None))
if number_of_evaluation < 2:
while True:
from random import randint
index = randint(0, len(population) - 1)
if population[index].valid is not True:
population[index].evaluate()
number_of_evaluation += 1
break
if number_of_evaluation == 0:
return population, 0
else:
return population, number_of_evaluation
def gale0WHERE(problem, population, configuration, values_to_be_passed):
"The Core method behind GALE"
# for pop in population:
# assert(pop.generation_number == 0), "Generation has to be 0"
# Compile population into table form used by WHERE
t = slurp([[x for x in row.decisionValues] + ["?" for y in problem.objectives] for row in population],
problem.buildHeader().split(","))
# Initialize some parameters for WHERE
The.allowDomination = True
The.alpha = 1
for i, row in enumerate(t.rows):
row.evaluated = False
# Run WHERE
m = Moo(problem, t, len(t.rows), N=1).divide(minnie=rstop(t))
print "Where done"
# Organizing
NDLeafs = m.nonPrunedLeaves() # The surviving non-dominated leafs
allLeafs = m.nonPrunedLeaves() + m.prunedLeaves() # All of the leafs
# After mutation: Check how many rows were actually evaluated
numEval = 0
for leaf in allLeafs:
for row in leaf.table.rows:
if row.evaluated:
numEval += 1
# After mutation; Convert back to JMOO Data Structures
population = []
for leaf in NDLeafs:
for row in leaf.table.rows:
if row.evaluated:
population.append(jmoo_individual(problem, [x for x in row.cells[:len(problem.decisions)]], 0,
[x for x in row.cells[len(problem.decisions):]]))
else:
indi = jmoo_individual(problem, [x for x in row.cells[:len(problem.decisions)]], 0, None)
indi.fitness.fitness = problem.evaluate(indi.decisionValues)
# print "> ", indi.fitness.fitness
population.append(indi)
numEval += 1
# median_values = []
# for i in xrange(len(problem.objectives)):
# temp_values = []
# for pop in population:
# temp_values.append(pop.fitness.fitness[i])
# median_values.append(median(temp_values))
#
# print median_values
print "number of evals: ", numEval
return population, numEval
def galeEWWHERE(problem, population, configuration, values_to_be_passed):
"The Core method behind GALE"
# for pop in population:
# assert(pop.generation_number == 0), "Generation has to be 0"
# Compile population into table form used by WHERE
t = slurp([[x for x in row.decisionValues] + ["?" for y in problem.objectives] for row in population],
problem.buildHeader().split(","))
# Initialize some parameters for WHERE
The.allowDomination = True
The.alpha = 1
for i, row in enumerate(t.rows):
row.evaluated = False
# Run WHERE
m = Moo(problem, t, len(t.rows), N=1).divide(minnie=rstop(t))
print "Where done"
# Organizing
NDLeafs = m.nonPrunedLeaves() # The surviving non-dominated leafs
allLeafs = m.nonPrunedLeaves() + m.prunedLeaves() # All of the leafs
# After mutation: Check how many rows were actually evaluated
numEval = 0
for leaf in allLeafs:
for row in leaf.table.rows:
if row.evaluated:
numEval += 1
# After mutation; Convert back to JMOO Data Structures
population = []
for leaf in NDLeafs:
for row in leaf.table.rows:
if row.evaluated:
population.append(jmoo_individual(problem, [x for x in row.cells[:len(problem.decisions)]],
[x for x in row.cells[len(problem.decisions):]]))
else:
indi = jmoo_individual(problem, [x for x in row.cells[:len(problem.decisions)]], None)
indi.fitness.fitness = problem.evaluate(indi.decisionValues)
population.append(indi)
numEval += 1
# median_values = []
# for i in xrange(len(problem.objectives)):
# temp_values = []
# for pop in population:
# temp_values.append(pop.fitness.fitness[i])
# median_values.append(median(temp_values))
#
# print median_values
return population, numEval
def over_sampling(problem, population, more_count, f=0.75):
def trim(mutated, low, up):
"""Constraint checking of decision"""
return max(low, min(mutated, up))
def interpolate(a, b, random_number):
return a + random_number * (b - a)
new_population = []
for i in xrange(more_count):
from random import choice, randint, random
one_count = i % len(population)
one = population[one_count]
while True:
two_count = randint(0, len(population) - 1)
if one_count != two_count: break
two = population[two_count]
solution = []
for d, decision in enumerate(problem.decisions):
assert isinstance(one, jmoo_individual)
assert isinstance(two, jmoo_individual)
solution.append(
trim(
interpolate(one.decisionValues[d], two.decisionValues[d],
random()), decision.low, decision.up))
new_population.append(jmoo_individual(problem, solution, None))
return new_population
def polynomial_mutation(problem, individual, configuration):
from numpy.random import random
eta_m_ = configuration["NSGAIII"]["ETA_M_DEFAULT_"]
distributionIndex_ = eta_m_
output = jmoo_individual(problem, individual.decisionValues)
probability = 1/len(problem.decisions)
for var in xrange(len(problem.decisions)):
if random() <= probability:
y = individual.decisionValues[var]
yU = problem.decisions[var].up
yL = problem.decisions[var].low
delta1 = (y - yL)/(yU - yL)
delta2 = (yU - y)/(yU - yL)
rnd = random()
mut_pow = 1.0/(eta_m_ + 1.0)
if rnd < 0.5:
xy = 1.0 - delta1
val = 2.0 * rnd + (1 - 2 * rnd) * (xy ** (distributionIndex_ + 1.0))
deltaq = val ** mut_pow - 1
else:
xy = 1.0 - delta2
val = 2.0 * (1.0-rnd) + 2.0 * (rnd-0.5) * (xy ** (distributionIndex_+1.0))
deltaq = 1.0 - (val ** mut_pow)
y += deltaq * (yU - yL)
if y < yL: y = yL
if y > yU: y = yU
output.decisionValues[var] = y
return output
def extrapolate(problem, individuals, one, f, cf):
from random import randint
two, three, four = three_others(individuals, one)
solution = []
# from Binary Differential Evolution Algorithm with New Mutation Operator
if problem.is_binary is True:
for d, decision in enumerate(problem.decisions):
assert isinstance(two, jmoo_individual)
x, y, z = two.decisionValues[d], three.decisionValues[d], four.decisionValues[d]
if random.random() < cf:
if x == 0 or x == 1:
solution.append(1 - x)
else:
solution.append(1 - x)
else:
solution.append(one.decisionValues[d])
else:
for d, decision in enumerate(problem.decisions):
assert isinstance(two, jmoo_individual)
x, y, z = two.decisionValues[d], three.decisionValues[d], four.decisionValues[d]
if random.random() < cf or randint(0, len(problem.decisions)) == d:
solution.append(trim(x + f * (y - z), decision.low, decision.up))
else:
solution.append(one.decisionValues[d])
return jmoo_individual(problem, [float(d) for d in solution], None)
def selNSGA2(problem, population, selectees, configurations):
k = configurations["Universal"]["Population_Size"]
# Evaluate any new guys
for individual in population + selectees:
if not individual.valid:
individual.evaluate()
# Format a population Data structure usable by DEAP's package
dIndividuals = deap_format(problem, population + selectees)
# Combine
from Algorithms.DEAP.tools.emo import deap_selNSGA2
dIndividuals = deap_selNSGA2(dIndividuals, k)
# Copy from DEAP structure to JMOO structure
population = []
for i, dIndividual in enumerate(dIndividuals):
cells = []
for j in range(len(dIndividual)):
cells.append(dIndividual[j])
population.append(
jmoo_individual(problem, cells,
[f for f in dIndividual.fitness.values]))
return population, k
def loadInitialPopulation(problem, MU):
"a way to load *the* initial problem as used in jmoo_jmoea.py"
"this will load a csv as generated by the dataGen method of"
"jmoo_problems.py"
filename = "data/" + problem.name + "-p" + str(MU) + "-d" + str(len(problem.decisions)) + "-o" + str(len(problem.objectives)) + "-dataset.txt"
input = open(filename, 'rb')
reader = csv.reader(input, delimiter=',')
population = []
#Use the csv file to build the initial population
for k,p in enumerate(reader):
if k > MU:
problem.objectives[k-MU-1].med = float(p[1])
lownotfound = False
upnotfound = False
if problem.objectives[k-MU-1].low == None:
problem.objectives[k-MU-1].low = float(p[0])
lownotfound = True
if problem.objectives[k-MU-1].up == None:
problem.objectives[k-MU-1].up = float(p[2])
upnotfound = True
rangeX5 = (problem.objectives[k-MU-1].up - problem.objectives[k-MU-1].low)*5
if lownotfound:
problem.objectives[k-MU-1].low -= rangeX5
if upnotfound:
problem.objectives[k-MU-1].up += rangeX5
elif k > 0:
population.append(jmoo_individual(problem,[float(p[n]) for n,dec in enumerate(problem.decisions)],None))
#population[-1].fitness = jmoo_fitness(problem, [float(p[n+len(problem.decisions)]) for n,obj in enumerate(problem.objectives)])
return population
def update_neighbor(problem, individual, mutant, population, dist_function, configuration, values_to_be_passed):
from copy import deepcopy
new_population = population[:] #deepcopy(population)
for i in xrange(configuration["MOEAD"]["niche"]):
k = individual.neighbor[i]
neighbor = [pop for pop in new_population if pop.id == k][-1]
f1 = dist_function(problem, neighbor.fitness.fitness, neighbor.weight, values_to_be_passed, configuration)
f2 = dist_function(problem, mutant.fitness.fitness, neighbor.weight, values_to_be_passed, configuration)
if f2 < f1:
backup_copy = None
for pop in new_population:
if pop.id == k:
backup_copy = deepcopy(pop)
new_population.remove(pop)
break
assert(backup_copy.id == k), "Assumption of value of pop exists is wrong!"
new_solution = jmoo_individual(problem, mutant.decisionValues, mutant.fitness.fitness)
new_solution.id = k
new_solution.neighbor = deepcopy(backup_copy.neighbor)
new_solution.weight = deepcopy(backup_copy.weight)
new_population.append(new_solution)
assert(new_solution.id == backup_copy.id), "Something is wrong"
assert(len(new_population) == configuration["Universal"]["Population_Size"]), "Something is wrong with updation"
return new_population
def polynomial_mutation(problem, individual, configuration):
from numpy.random import random
eta_m_ = configuration["NSGAIII"]["ETA_M_DEFAULT_"]
distributionIndex_ = eta_m_
output = jmoo_individual(problem, individual.decisionValues)
probability = 1 / len(problem.decisions)
for var in xrange(len(problem.decisions)):
if random() <= probability:
y = individual.decisionValues[var]
yU = problem.decisions[var].up
yL = problem.decisions[var].low
delta1 = (y - yL) / (yU - yL)
delta2 = (yU - y) / (yU - yL)
rnd = random()
mut_pow = 1.0 / (eta_m_ + 1.0)
if rnd < 0.5:
xy = 1.0 - delta1
val = 2.0 * rnd + (1 - 2 * rnd) * (xy**
(distributionIndex_ + 1.0))
deltaq = val**mut_pow - 1
else:
xy = 1.0 - delta2
val = 2.0 * (1.0 - rnd) + 2.0 * (rnd - 0.5) * (xy**(
distributionIndex_ + 1.0))
deltaq = 1.0 - (val**mut_pow)
y += deltaq * (yU - yL)
if y < yL: y = yL
if y > yU: y = yU
output.decisionValues[var] = y
return output
def update_neighbor(problem, individual, mutant, population, dist_function,
configuration, values_to_be_passed):
from copy import deepcopy
new_population = population[:] #deepcopy(population)
for i in xrange(configuration["MOEAD"]["niche"]):
k = individual.neighbor[i]
neighbor = [pop for pop in new_population if pop.id == k][-1]
f1 = dist_function(problem, neighbor.fitness.fitness, neighbor.weight,
values_to_be_passed, configuration)
f2 = dist_function(problem, mutant.fitness.fitness, neighbor.weight,
values_to_be_passed, configuration)
if f2 < f1:
backup_copy = None
for pop in new_population:
if pop.id == k:
backup_copy = deepcopy(pop)
new_population.remove(pop)
break
assert (backup_copy.id == k
), "Assumption of value of pop exists is wrong!"
new_solution = jmoo_individual(problem, mutant.decisionValues,
mutant.fitness.fitness)
new_solution.id = k
new_solution.neighbor = deepcopy(backup_copy.neighbor)
new_solution.weight = deepcopy(backup_copy.weight)
new_population.append(new_solution)
assert (new_solution.id == backup_copy.id), "Something is wrong"
assert (len(new_population) == configuration["Universal"]
["Population_Size"]), "Something is wrong with updation"
return new_population
def over_sampling(problem, population, more_count, f=0.75):
def trim(mutated, low, up):
"""Constraint checking of decision"""
return max(low, min(mutated, up))
def interpolate(a, b, random_number):
return a + random_number * (b - a)
new_population = []
for i in xrange(more_count):
from random import choice, randint, random
one_count = i%len(population)
one = population[one_count]
while True:
two_count = randint(0, len(population)-1)
if one_count != two_count: break
two = population[two_count]
solution = []
for d, decision in enumerate(problem.decisions):
assert isinstance(one, jmoo_individual)
assert isinstance(two, jmoo_individual)
solution.append(trim(interpolate(one.decisionValues[d], two.decisionValues[d], random()), decision.low, decision.up))
new_population.append(jmoo_individual(problem, solution, None))
return new_population
def gale_8_Mutate(problem, leaves, configuration):
def mutate(candidate, SouthPole, NorthPole):
mutant = [None for _ in xrange(len(candidate.decisionValues))]
g = abs(SouthPole.x - NorthPole.x)
for attr in range(0, len(problem.decisions)):
# just some naming shortcuts
me = candidate.decisionValues[attr]
good = SouthPole.decisionValues[attr]
bad = NorthPole.decisionValues[attr]
dec = problem.decisions[attr]
# Find direction to mutate (Want to mutate towards good pole)
if me > good: d = -1
if me < good: d = +1
if me == good: d = 0
mutant[attr] = min(dec.up, max(dec.low, (me + me * g * d) * 1.1))
return jmoo_individual(problem, mutant, None)
#################
# Mutation Phase
#################
new_population = []
# Keep track of evals
number_of_evaluations = 0
for leaf in leaves:
initial_length = len(leaf)
sorted_population = fastmap(problem, leaf)
# print "sorted_population: ", len(sorted_population), len([g for g in sorted_population if g.fitness.valid])
number_of_evaluations += 2
good_ones = sorted_population[:initial_length / 2]
# print "good_ones: ", len(good_ones), len([g for g in good_ones if g.fitness.valid])
mutants = [
mutate(good_one, sorted_population[0], sorted_population[-1])
for good_one in good_ones
]
# print "mutants: ", len(mutants)
excess = initial_length - (len(good_ones) + len(mutants))
random_points = [
jmoo_individual(problem, problem.generateInput(), None)
for _ in xrange(excess)
]
# print "excess: ", excess
new_population += good_ones
new_population += mutants
new_population += random_points
# print "new_population: ", len(new_population)
assert (initial_length == len(good_ones) + len(mutants) +
len(random_points)), "Something is wrong"
# print len(new_population), configuration["Universal"]["Population_Size"]
assert (len(new_population) == configuration["Universal"]
["Population_Size"]), "Something is wrong"
return new_population, number_of_evaluations
def gale2Regen(problem, unusedslot, mutants, configuration):
howMany = configuration["Universal"]["Population_Size"] - len(mutants)
# Generate random individuals
population = []
for i in range(howMany):
population.append(jmoo_individual(problem, problem.generateInput(), None))
return mutants+population, 0
def gale_nm_Regen(problem, unusedslot, mutants, configuration, generation_number):
howMany = configuration["Universal"]["Population_Size"]
# Generate random individuals
population = []
for i in range(howMany):
population.append(jmoo_individual(problem, problem.generateInput(), [generation_number], None))
return population, 0
def gale_nm_Mutate(problem, NDLeafs, configuration, gen, actual_population):
#################
# Mutation Phase
#################
# After mutation; Convert back to JMOO Data Structures
population = []
for leaf in NDLeafs:
for row in leaf.table.rows:
if row.evaluated:
population.append(jmoo_individual(problem, [x for x in row.cells[:len(problem.decisions)]], 0,
[x for x in row.cells[len(problem.decisions):]]))
else:
population.append(jmoo_individual(problem, [x for x in row.cells[:len(problem.decisions)]], 0, None))
# Return selectees and number of evaluations
return population, 0
def gale_64_Regen(problem, unusedslot, mutants, configuration):
howMany = configuration["Universal"]["Population_Size"] - len(mutants)
# Generate random individuals
population = []
for i in range(howMany):
population.append(jmoo_individual(problem, problem.generateInput(), None))
return mutants+population, 0
def generate_population(problem, N):
population = []
for i in xrange(N):
temp_decision = problem.generateInput()
population.append(
jmoo_individual(problem,
temp_decision,
problem.evaluate(temp_decision),
index=i))
return population
def galeRegen(problem, unusedSlot, mutants, MU):
howMany = MU - len(mutants)
# Generate random individuals
population = []
for i in range(howMany):
population.append(jmoo_individual(problem, problem.generateInput(), None))
return mutants+population, 0
def gale_8_Mutate(problem, leaves, configuration):
def mutate(candidate, SouthPole, NorthPole):
mutant = [None for _ in xrange(len(candidate.decisionValues))]
g = abs(SouthPole.x - NorthPole.x)
for attr in range(0, len(problem.decisions)):
# just some naming shortcuts
me = candidate.decisionValues[attr]
good = SouthPole.decisionValues[attr]
bad = NorthPole.decisionValues[attr]
dec = problem.decisions[attr]
# Find direction to mutate (Want to mutate towards good pole)
if me > good: d = -1
if me < good: d = +1
if me == good: d = 0
mutant[attr] = min(dec.up, max(dec.low, (me + me * g * d) * 1.1))
return jmoo_individual(problem, mutant, None)
#################
# Mutation Phase
#################
new_population = []
# Keep track of evals
number_of_evaluations = 0
for leaf in leaves:
initial_length = len(leaf)
sorted_population = fastmap(problem, leaf)
# print "sorted_population: ", len(sorted_population), len([g for g in sorted_population if g.fitness.valid])
number_of_evaluations += 2
good_ones = sorted_population[:initial_length/2]
# print "good_ones: ", len(good_ones), len([g for g in good_ones if g.fitness.valid])
mutants = [mutate(good_one, sorted_population[0], sorted_population[-1]) for good_one in good_ones]
# print "mutants: ", len(mutants)
excess = initial_length - (len(good_ones) + len(mutants))
random_points = [jmoo_individual(problem, problem.generateInput(), None) for _ in xrange(excess)]
# print "excess: ", excess
new_population += good_ones
new_population += mutants
new_population += random_points
# print "new_population: ", len(new_population)
assert(initial_length == len(good_ones) + len(mutants) + len(random_points)), "Something is wrong"
# print len(new_population), configuration["Universal"]["Population_Size"]
assert(len(new_population) == configuration["Universal"]["Population_Size"]), "Something is wrong"
return new_population, number_of_evaluations
def gale_nm_Regen(problem, unusedslot, mutants, configuration,
generation_number):
howMany = configuration["Universal"]["Population_Size"]
# Generate random individuals
population = []
for i in range(howMany):
population.append(
jmoo_individual(problem, problem.generateInput(),
[generation_number], None))
return population, 0
def extrapolate(problem, individuals, one, f, cf):
from random import randint
two, three, four = three_others(individuals, one)
solution = []
for d, decision in enumerate(problem.decisions):
assert isinstance(two, jmoo_individual)
x, y, z = two.decisionValues[d], three.decisionValues[d], four.decisionValues[d]
if random.random() < cf or randint(0, len(problem.decisions)) == d:
solution.append(trim(x + f * (y - z), decision.low, decision.up))
else: solution.append(one.decisionValues[d])
return jmoo_individual(problem, [float(d) for d in solution], None)
def convert_to_jmoo(problem, pareto_fronts):
tpopulation = []
for front_no, front in enumerate(pareto_fronts[:-1]):
for i, dIndividual in enumerate(front):
cells = []
for j in xrange(len(dIndividual)):
cells.append(dIndividual[j])
tpopulation.append(jmoo_individual(problem, cells, list(dIndividual.fitness.values)))
for pop in tpopulation: pop.front_no = 0 # all the front except the last front
lpopulation = []
for front_no, front in enumerate(pareto_fronts[-1:]):
for i, dIndividual in enumerate(front):
cells = []
for j in xrange(len(dIndividual)):
cells.append(dIndividual[j])
lpopulation.append(jmoo_individual(problem, cells, list(dIndividual.fitness.values)))
for pop in lpopulation: pop.front_no = -1 # last front
from itertools import chain
assert(len(list(chain(*pareto_fronts))) <= len(lpopulation) + len(tpopulation)), "Non Dominated Sorting is wrong!"
return lpopulation + tpopulation
def gale_8_WHERE(problem, population, configuration, values_to_be_passed):
"The Core method behind GALE"
from Utilities.where import where
import numpy as np
decisions = np.array([pop.decisionValues for pop in population])
leaves = where(decisions)
filled_leaves = []
for leaf in leaves:
temp_list = [jmoo_individual(problem, list(member), None) for member in leaf]
filled_leaves.append(temp_list)
return filled_leaves, 0
def extrapolate(problem, individuals, one, f, cf):
from random import randint
two, three, four = three_others(individuals, one)
solution = []
for d, decision in enumerate(problem.decisions):
assert isinstance(two, jmoo_individual)
x, y, z = two.decisionValues[d], three.decisionValues[
d], four.decisionValues[d]
if random.random() < cf or randint(0, len(problem.decisions)) == d:
solution.append(trim(x + f * (y - z), decision.low, decision.up))
else:
solution.append(one.decisionValues[d])
return jmoo_individual(problem, [float(d) for d in solution], None)
def gale_nm_Mutate(problem, NDLeafs, configuration):
#################
# Mutation Phase
#################
# After mutation; Convert back to JMOO Data Structures
population = []
for leaf in NDLeafs:
for row in leaf.table.rows:
if row.evaluated:
population.append(
jmoo_individual(
problem,
[x for x in row.cells[:len(problem.decisions)]],
[x for x in row.cells[len(problem.decisions):]]))
else:
population.append(
jmoo_individual(
problem,
[x for x in row.cells[:len(problem.decisions)]], None))
# Return selectees and number of evaluations
return population, 0
def gale_8_WHERE(problem, population, configuration, values_to_be_passed):
"The Core method behind GALE"
from Utilities.where import where
import numpy as np
decisions = np.array([pop.decisionValues for pop in population])
leaves = where(decisions)
filled_leaves = []
for leaf in leaves:
temp_list = [
jmoo_individual(problem, list(member), None) for member in leaf
]
filled_leaves.append(temp_list)
return filled_leaves, 0
def extrapolate(problem, individuals, one, f, cf):
# #print "Extrapolate"
two, three, four = three_others(individuals, one)
# #print two,three,four
solution = []
for d, decision in enumerate(problem.decisions):
assert isinstance(two, jmoo_individual)
x, y, z = two.decisionValues[d], three.decisionValues[
d], four.decisionValues[d]
if random.random() < cf:
mutated = x + f * (y - z)
solution.append(trim(mutated, decision.low, decision.up))
else:
solution.append(one.decisionValues[d])
return jmoo_individual(problem, [float(d) for d in solution], None)
def extrapolate(problem, individuals, one, f, cf):
# #print "Extrapolate"
two, three, four = three_others(individuals, one)
# #print two,three,four
solution = []
for d, decision in enumerate(problem.decisions):
assert isinstance(two, jmoo_individual)
x, y, z = two.decisionValues[d], three.decisionValues[d], four.decisionValues[d]
if random.random() < cf:
mutated = x + f * (y - z)
solution.append(trim(mutated, decision.low, decision.up))
else:
solution.append(one.decisionValues[d])
return jmoo_individual(problem, [float(d) for d in solution], None)
def mutate(candidate, SouthPole, NorthPole):
mutant = [None for _ in xrange(len(candidate.decisionValues))]
g = abs(SouthPole.x - NorthPole.x)
for attr in range(0, len(problem.decisions)):
# just some naming shortcuts
me = candidate.decisionValues[attr]
good = SouthPole.decisionValues[attr]
bad = NorthPole.decisionValues[attr]
dec = problem.decisions[attr]
# Find direction to mutate (Want to mutate towards good pole)
if me > good: d = -1
if me < good: d = +1
if me == good: d = 0
mutant[attr] = min(dec.up, max(dec.low, (me + me * g * d) * 1.1))
return jmoo_individual(problem, mutant, None)
def mutate(candidate, SouthPole, NorthPole):
mutant = [None for _ in xrange(len(candidate.decisionValues))]
g = abs(SouthPole.x - NorthPole.x)
for attr in range(0, len(problem.decisions)):
# just some naming shortcuts
me = candidate.decisionValues[attr]
good = SouthPole.decisionValues[attr]
bad = NorthPole.decisionValues[attr]
dec = problem.decisions[attr]
# Find direction to mutate (Want to mutate towards good pole)
if me > good: d = -1
if me < good: d = +1
if me == good: d = 0
mutant[attr] = min(dec.up, max(dec.low, (me + me * g * d) * 1.1))
return jmoo_individual(problem, mutant, None)
def loadInitialPopulation(problem, MU, path=""):
"a way to load *the* initial problem as used in jmoo_jmoea.py"
"this will load a csv as generated by the dataGen method of"
"jmoo_problems.py"
if path == "":
filename = "Data/" + problem.name + "-p" + str(MU) + "-d" + str(
len(problem.decisions)) + "-o" + str(len(
problem.objectives)) + "-dataset.txt"
elif path == "unittesting":
filename = "../../Data/Testing-dataset.txt"
else:
print "No accounted for"
exit()
input = open(filename, 'rb')
reader = csv.reader(input, delimiter=',')
population = []
#Use the csv file to build the initial population
for k, p in enumerate(reader):
if k > MU:
problem.objectives[k - MU - 1].med = float(p[1])
lownotfound = False
upnotfound = False
if problem.objectives[k - MU - 1].low == None:
problem.objectives[k - MU - 1].low = float(p[0])
lownotfound = True
if problem.objectives[k - MU - 1].up == None:
problem.objectives[k - MU - 1].up = float(p[2])
upnotfound = True
# rangeX5 = (problem.objectives[k-MU-1].up - problem.objectives[k-MU-1].low)*5
# if lownotfound:
# problem.objectives[k-MU-1].low -= rangeX5
# if upnotfound:
# problem.objectives[k-MU-1].up += rangeX5
elif k > 0:
population.append(
jmoo_individual(problem, [
float(p[n]) for n, dec in enumerate(problem.decisions)
], None))
#population[-1].fitness = jmoo_fitness(problem, [float(p[n+len(problem.decisions)]) for n,obj in enumerate(problem.objectives)])
return population
def over_sampling(problem, population, more_count, f=0.75):
def trim(mutated, low, up):
"""Constraint checking of decision"""
return max(low, min(mutated, up))
new_population = []
for _ in xrange(more_count):
from random import choice, randint
one = choice(population)
two = choice(population)
three = choice(population)
solution = []
for d, decision in enumerate(problem.decisions):
assert isinstance(one, jmoo_individual)
assert isinstance(two, jmoo_individual)
assert isinstance(three, jmoo_individual)
x, y, z = one.decisionValues[d], two.decisionValues[d], three.decisionValues[d]
solution.append(trim(x + f * (y - z), decision.low, decision.up))
new_population.append(jmoo_individual(problem, solution, None))
return new_population
def over_sampling(problem, population, more_count, f=0.75):
def trim(mutated, low, up):
"""Constraint checking of decision"""
return max(low, min(mutated, up))
new_population = []
for _ in xrange(more_count):
from random import choice, randint
one = choice(population)
two = choice(population)
three = choice(population)
solution = []
for d, decision in enumerate(problem.decisions):
assert isinstance(one, jmoo_individual)
assert isinstance(two, jmoo_individual)
assert isinstance(three, jmoo_individual)
x, y, z = one.decisionValues[d], two.decisionValues[
d], three.decisionValues[d]
solution.append(trim(x + f * (y - z), decision.low, decision.up))
new_population.append(jmoo_individual(problem, solution, None))
return new_population
def selNSGA2(problem, population, selectees, k):
# Evaluate any new guys
for individual in population+selectees:
if not individual.valid:
individual.evaluate()
# Format a population data structure usable by DEAP's package
dIndividuals = deap_format(problem, population+selectees)
# Combine
dIndividuals = tools.selNSGA2(dIndividuals, k)
# Copy from DEAP structure to JMOO structure
population = []
for i,dIndividual in enumerate(dIndividuals):
cells = []
for j in range(len(dIndividual)):
cells.append(dIndividual[j])
population.append(jmoo_individual(problem, cells, dIndividual.fitness.values))
return population,k
def selSPEA2(problem, population, selectees, k):
# Evaluate any new guys
for individual in population + selectees:
if not individual.valid:
individual.evaluate()
# Format a population data structure usable by DEAP's package
dIndividuals = deap_format(problem, population + selectees)
# Combine
dIndividuals = tools.selSPEA2(dIndividuals, k)
# Copy from DEAP structure to JMOO structure
population = []
for i, dIndividual in enumerate(dIndividuals):
cells = []
for j in range(len(dIndividual)):
cells.append(dIndividual[j])
population.append(
jmoo_individual(problem, cells, dIndividual.fitness.values))
return population, k
def loadInitialPopulation(problem, MU): #Done
"a way to load *the* initial problem as used in jmoo_jmoea.py"
"this will load a csv as generated by the dataGen method of"
"jmoo_problems.py"
"Vivek: This will return a list of object <jmoo_individual>"
input = open('./data/' + problem.name + str(MU) + 'dataset.txt', 'rb')
reader = csv.reader(input, delimiter=',')
population = []
#Use the csv file to build the initial population
for k, p in enumerate(reader):
if k > MU:
problem.objectives[k - MU - 1].med = float(p[1])
lownotfound = False
upnotfound = False
if problem.objectives[k - MU - 1].low == None:
problem.objectives[k - MU - 1].low = float(p[0])
lownotfound = True
if problem.objectives[k - MU - 1].up == None:
problem.objectives[k - MU - 1].up = float(p[2])
upnotfound = True
rangeX5 = (problem.objectives[k - MU - 1].up -
problem.objectives[k - MU - 1].low) * 5
if lownotfound:
problem.objectives[k - MU - 1].low -= rangeX5
if upnotfound:
problem.objectives[k - MU - 1].up += rangeX5
elif k > 0:
population.append(
jmoo_individual(problem, [
float(p[n]) for n, dec in enumerate(problem.decisions)
], None))
#population[-1].fitness = jmoo_fitness(problem, [float(p[n+len(problem.decisions)]) for n,obj in enumerate(problem.objectives)])
return population
def selNSGA2(problem, population, selectees, configurations):
k = configurations["Universal"]["Population_Size"]
# Evaluate any new guys
for individual in population + selectees:
if not individual.valid:
individual.evaluate()
# Format a population Data structure usable by DEAP's package
dIndividuals = deap_format(problem, population + selectees)
# Combine
from Algorithms.DEAP.tools.emo import deap_selNSGA2
dIndividuals = deap_selNSGA2(dIndividuals, k)
# Copy from DEAP structure to JMOO structure
population = []
for i, dIndividual in enumerate(dIndividuals):
cells = []
for j in range(len(dIndividual)):
cells.append(dIndividual[j])
population.append(jmoo_individual(problem, cells, [f for f in dIndividual.fitness.values]))
return population, k
def get_non_dominated_solutions(problem, population, configurations):
# NOTE: This might look wierd but this would return all the non dominated solutions
k = configurations["Universal"]["Population_Size"]
# Evaluate any new guys
for individual in population:
if not individual.valid:
individual.evaluate()
# Format a population Data structure usable by DEAP's package
dIndividuals = deap_format(problem, population)
# Combine
from Algorithms.DEAP.tools.emo import deap_selNSGA2
dIndividuals = deap_selNSGA2(dIndividuals, k)
# Copy from DEAP structure to JMOO structure
population = []
for i, dIndividual in enumerate(dIndividuals):
cells = []
for j in range(len(dIndividual)):
cells.append(dIndividual[j])
population.append(jmoo_individual(problem, cells, [f for f in dIndividual.fitness.values]))
return population
def update(statBox, population, gen, num_new_evals, initial = False, population_size=None, printOption=True):
"add a stat box - compute the statistics first"
# Find a file name to write the stats to
if (statBox.alg.name == "GALE0" or statBox.alg.name == "GALE_no_mutation") and population_size is not None:
filename = "Data/results_"+statBox.problem.name + "-p" + str(population_size) + "-d" + \
str(len(statBox.problem.decisions)) + "-o" + str(len(statBox.problem.objectives))+\
"_"+statBox.alg.name+".datatable"
else:
filename = "Data/results_"+statBox.problem.name + "-p" + str(len(population)) + "-d" + \
str(len(statBox.problem.decisions)) + "-o" + str(len(statBox.problem.objectives))+\
"_"+statBox.alg.name+".datatable"
fa = open(filename, 'a')
# Update Number of Evaluations
statBox.numEval += num_new_evals
# population represents on the individuals which have been evaluated
shorten_population = [pop for pop in population if pop.fitness.valid]
objectives = [individual.fitness.fitness for individual in shorten_population]
# Split Columns into Lists
objective_columns = [[objective[i] for objective in objectives] for i, obj in enumerate(statBox.problem.objectives)]
# Calculate Medians of objective scores
objective_medians = [median(fitCol) for fitCol in objective_columns]
# Calculate IQR of objective scores
objective_iqr = [spread(fitCol) for fitCol in objective_columns]
# Initialize Reference Point on Initial Run
if initial is True:
statBox.referencePoint = [o.med for o in statBox.problem.objectives]
statBox.reference_point_for_hypervolume = [o.up for o in statBox.problem.objectives]
# Calculate IBD & IBS
# Finding min and max for each objectives
norms = [[min(objective_columns[i]+[statBox.referencePoint[i]]), max(objective_columns[i]+[statBox.referencePoint[i]])] for i,obj in enumerate(statBox.problem.objectives)]
lossInQualities = [{"qual": loss_in_quality(statBox.problem, [statBox.referencePoint], fit, norms), "index": i} for i,fit in enumerate(objectives)]
lossInQualities.sort(key=lambda(r): r["qual"])
if len(objectives) > 0:
best_fitness = objectives[lossInQualities[0]["index"]]
else:
best_fitness = objective_medians
lossInQualities = [item["qual"] for item in lossInQualities]
IBD = median(lossInQualities)
IBS = spread(lossInQualities)
if initial is True:
IBD = 1.0
statBox.referenceIBD = 1.0
changes = []
# Print Option
if printOption is True:
outString = ""
if initial:
outString += str(statBox.numEval) + ","
for med, spr, initmed, obj, o in zip(statBox.referencePoint, [0 for x in statBox.problem.objectives],
statBox.referencePoint, statBox.problem.objectives,
range(len(statBox.problem.objectives))):
change = percentChange(med, initmed, obj.lismore, obj.low, obj.up)
changes.append(float(change.strip("%")))
statBox.bests[o] = changes[-1]
statBox.bests_actuals[o] = med
outString += str("%8.4f" % med) + "," + change + "," + str("%8.4f" % spr) + ","
if statBox.numEval in statBox.foam[o]: statBox.foam[o][statBox.numEval].append(change)
else: statBox.foam[o][statBox.numEval] = [change]
outString += str("%8.4f" % IBD) + "," + percentChange(statBox.referenceIBD, statBox.referenceIBD, True, 0, 1) + "," + str("%8.4f" % IBS)
else:
outString += str(statBox.numEval) + ","
for med, spr, initmed, obj, o in zip(best_fitness, objective_iqr, statBox.referencePoint,
statBox.problem.objectives, range(len(statBox.problem.objectives))):
change = percentChange(med, initmed, obj.lismore, obj.low, obj.up)
changes.append(float(change.strip("%")))
if changes[-1] < statBox.bests[o]:
statBox.bests[o] = changes[-1]
statBox.bests_actuals[o] = med
outString += str("%8.4f" % med) + "," + change + "," + str("%8.4f" % spr) + ","
if statBox.numEval in statBox.foam[o]: statBox.foam[o][statBox.numEval].append(change)
else: statBox.foam[o][statBox.numEval] = [change]
outString += str("%8.4f" % IBD) + "," + percentChange(IBD, statBox.referenceIBD, True, 0, 1) + "," + str("%8.4f" % IBS)
fa.write(outString + "\n")
# Add Stat to the Stat Box
trunk = []
for i,pop in enumerate(shorten_population):
trunk.append(jmoo_individual(statBox.problem, pop.decisionValues, pop.fitness.fitness))
statBox.box[-1] = jmoo_stats(trunk, objectives, best_fitness, objective_iqr, statBox.numEval, gen, IBD, IBS, changes)
fa.close()
def update(statBox, population, gen, numNewEvals, initial = False, printOption=True):
"add a stat box - compute the statistics first"
filename = "data/results_"+statBox.problem.name + "-p" + str(len(population)) + "-d" + \
str(len(statBox.problem.decisions)) + "-o" + str(len(statBox.problem.objectives))+\
"_"+statBox.alg.name+".datatable"
fa = open(filename, 'a')
# Calculate percentage of violations
violationsPercent = sum([ 1 for pop in population if statBox.problem.evalConstraints(pop.decisionValues)])/float(len(population))
# Update Number of Evaluations
statBox.numEval += numNewEvals
#front = population
#for pop in population:
# if not pop.valid: pop.evaluate()
population = [pop for pop in population if pop.fitness.valid]
fitnesses = [individual.fitness.fitness for individual in population if individual.valid]
# Split Columns into Lists
fitnessColumns = [[fit[i] for fit in fitnesses] for i,obj in enumerate(statBox.problem.objectives)]
# Calculate Medians and Spreads
fitnessMedians = [median(fitCol) for fitCol in fitnessColumns]
fitnessSpreads = [spread(fitCol) for fitCol in fitnessColumns]
# Initialize Reference Point on Initial Run
if initial == True:
statBox.referencePoint = [o.med for o in statBox.problem.objectives]
# Calculate IBD & IBS
norms = [[min(fitnessColumns[i]+[statBox.referencePoint[i]]), max(fitnessColumns[i]+[statBox.referencePoint[i]])] for i,obj in enumerate(statBox.problem.objectives)]
lossInQualities = [{"qual": loss_in_quality(statBox.problem, [statBox.referencePoint], fit, norms), "index": i} for i,fit in enumerate(fitnesses)]
lossInQualities.sort(key=lambda(r): r["qual"])
if len(fitnesses) > 0:
best_fitness = fitnesses[lossInQualities[0]["index"]]
else:
best_fitness = fitnessMedians
lossInQualities = [item["qual"] for item in lossInQualities]
#best_fitness = [min(fitCol) for fitCol in fitnessColumns if len(fitCol) > 0]
# + IGD Calculation: This would only work if the true PF is known.
if IGDMEASURE is True:
approximate = []
true_PF = readpf(statBox.problem)
for individual in population:
temp = []
for x in individual.fitness.fitness: temp.append(round(x, 5))
approximate.append(temp)
# - IGD Calculation
IBD = median(lossInQualities)
IBS = spread(lossInQualities)
if IGDMEASURE is True:
IGD = IGD_Calculation.IGD(approximate, true_PF)
if initial == True:
IBD = 1.0
statBox.referenceIBD = 1.0
# TODO: Need to come up with an smart way to assign reference IGD: This is stupid I ran into the problems
# with this
if IGDMEASURE is True:
statBox.referenceIGD = 1e30
changes = []
# Print Option
if printOption == True:
outString = ""
if initial:
outString += str(statBox.numEval) + ","
for med, spr, initmed, obj, o in zip(statBox.referencePoint, [0 for x in statBox.problem.objectives],
statBox.referencePoint, statBox.problem.objectives,
range(len(statBox.problem.objectives))):
change = percentChange(med, initmed, obj.lismore, obj.low, obj.up)
changes.append(float(change.strip("%")))
statBox.bests[o] = changes[-1]
statBox.bests_actuals[o] = med
outString += str("%8.4f" % med) + "," + change + "," + str("%8.4f" % spr) + ","
if statBox.numEval in statBox.foam[o]: statBox.foam[o][statBox.numEval].append(change)
else: statBox.foam[o][statBox.numEval] = [change]
outString += str("%8.4f" % IBD) + "," + percentChange(statBox.referenceIBD, statBox.referenceIBD, True, 0, 1) + "," + str("%8.4f" % IBS)
if IGDMEASURE is True:
outString += "," + str("%8.4f" % IGD) + "," + percentChange(statBox.referenceIGD, statBox.referenceIGD, True, 0, 1e3)
else:
outString += str(statBox.numEval) + ","
for med, spr, initmed, obj, o in zip(best_fitness, fitnessSpreads, statBox.referencePoint,
statBox.problem.objectives, range(len(statBox.problem.objectives))):
change = percentChange(med, initmed, obj.lismore, obj.low, obj.up)
changes.append(float(change.strip("%")))
if changes[-1] < statBox.bests[o]:
statBox.bests[o] = changes[-1]
statBox.bests_actuals[o] = med
outString += str("%8.4f" % med) + "," + change + "," + str("%8.4f" % spr) + ","
if statBox.numEval in statBox.foam[o]: statBox.foam[o][statBox.numEval].append(change)
else: statBox.foam[o][statBox.numEval] = [change]
outString += str("%8.4f" % IBD) + "," + percentChange(IBD, statBox.referenceIBD, True, 0, 1) + "," + str("%8.4f" % IBS)
print outString + ", violations: " + str("%4.1f" % violationsPercent)
if IGDMEASURE is True:
outString += "," + str("%8.4f" % IGD) + "," + percentChange(IGD, statBox.referenceIGD, True, 0, 1e3)
# if initial:
# if IGDMEASURE is True:
# print outString + ", violations: " + str("%4.1f" % violationsPercent) + "||IGD: " + str(IGD_Calculation.IGD(approximate, true_PF))
# else: print outString + ", violations: " + str("%4.1f" % violationsPercent)
# else:
# # print outString + ", violations: " + str("%4.1f" % violationsPercent) + "||IGD: " + str(IGD(approximate, true_PF))
# # print str(statBox.numEval) + "|IGD: |" + str(IGD(approximate, true_PF)) + "|Fitness:| ", normalized_median
# print "|Fitness: |", fitnessMedians
fa.write(outString + "\n")
# Add Stat to the Stat Box
trunk = []
for i,pop in enumerate(population):
trunk.append(jmoo_individual(statBox.problem, pop.decisionValues, pop.fitness.fitness))
#if i < 5: print trunk[-1].decisionValues, statBox.problem.evalConstraints(trunk[-1].decisionValues)
statBox.box.append(jmoo_stats(trunk, fitnesses, best_fitness, fitnessSpreads, statBox.numEval, gen, IBD, IBS, changes))
fa.close()
def sbxcrossover(problem, parent1, parent2, configuration):
EPS = 1.0e-14
distribution_index = configuration["NSGAIII"]["ETA_C_DEFAULT_"]
probability = configuration["NSGAIII"]["SBX_Probability"]
from numpy.random import random
offspring1 = jmoo_individual(problem, parent1.decisionValues)
offspring2 = jmoo_individual(problem, parent2.decisionValues)
number_of_variables = len(problem.decisions)
if random() <= probability:
for i in xrange(number_of_variables):
valuex1 = offspring1.decisionValues[i]
valuex2 = offspring2.decisionValues[i]
if random() <= 0.5:
if abs(valuex1 - valuex2) > EPS:
if valuex1 < valuex2:
y1 = valuex1
y2 = valuex2
else:
y1 = valuex2
y2 = valuex1
yL = problem.decisions[i].low
yU = problem.decisions[i].up
rand = random()
beta = 1.0 + (2.0 * (y1 - yL) / (y2 - y1))
alpha = 2.0 - beta ** (-1 * (distribution_index + 1.0))
if rand <= 1/alpha:
betaq = (1.0 / (2.0 - rand * alpha)) ** (1.0 / (distribution_index + 1.0))
else:
betaq = (1.0 / (2.0 - rand * alpha)) ** (1.0 / (distribution_index + 1.0))
c1 = 0.5 * ((y1 + y2) - betaq * (y2 - y1))
beta = 1.0 + (2.0 * (yU - y2) / (y2 - y1))
alpha = 2.0 - beta ** -(distribution_index + 1.0)
if rand <= (1.0 / alpha):
betaq = (rand * alpha) ** (1.0 / (distribution_index + 1.0))
else:
betaq = ((1.0 / (2.0 - rand * alpha)) ** (1.0 / (distribution_index + 1.0)))
c2 = 0.5 * ((y1 + y2) + betaq * (y2 - y1))
if c1 < yL: c1 = yL
if c2 < yL: c2 = yL
if c1 > yU: c1 = yU
if c2 > yU: c2 = yU
if random() <= 0.5:
offspring1.decisionValues[i] = c2
offspring2.decisionValues[i] = c1
else:
offspring1.decisionValues[i] = c1
offspring2.decisionValues[i] = c2
else:
offspring1.decisionValues[i] = valuex1
offspring2.decisionValues[i] = valuex2
else:
offspring1.decisionValues[i] = valuex2
offspring2.decisionValues[i] = valuex1
return offspring1, offspring2
def gale_64_Mutate(problem, NDLeafs, configuration):
#################
# Mutation Phase
#################
# Keep track of evals
numEval = 0
population = []
for leaf in NDLeafs:
initial_size = len(leaf.table.rows)
# print "Number of mutants: ", len(leaf.table.rows)
# Pull out the Poles
east = leaf.table.rows[0]
west = leaf.table.rows[-1]
# Evaluate those poles if needed
if not east.evaluated:
for o, objScore in enumerate(problem.evaluate(east.cells)):
east.cells[-(len(problem.objectives) - o)] = objScore
east.evaluated = True
numEval += 1
if not west.evaluated:
for o, objScore in enumerate(problem.evaluate(west.cells)):
west.cells[-(len(problem.objectives) - o)] = objScore
west.evaluated = True
numEval += 1
# Score the poles
n = len(problem.decisions)
weights = []
for obj in problem.objectives:
# w is negative when we are maximizing that objective
if obj.lismore:
weights.append(+1)
else:
weights.append(-1)
weightedWest = [c * w for c, w in zip(west.cells[n:], weights)]
weightedEast = [c * w for c, w in zip(east.cells[n:], weights)]
westLoss = loss(weightedWest,
weightedEast,
mins=[obj.low for obj in problem.objectives],
maxs=[obj.up for obj in problem.objectives])
eastLoss = loss(weightedEast,
weightedWest,
mins=[obj.low for obj in problem.objectives],
maxs=[obj.up for obj in problem.objectives])
# Determine better Pole
if eastLoss < westLoss:
to_be_mutated = leaf.table.rows[:int(len(leaf.table.rows) / 2)]
else:
to_be_mutated = leaf.table.rows[:int(len(leaf.table.rows) / 2)]
to_be_mutated_jmoo = []
for row in to_be_mutated:
if row.evaluated:
to_be_mutated_jmoo.append(
jmoo_individual(
problem,
[x for x in row.cells[:len(problem.decisions)]],
[x for x in row.cells[len(problem.decisions):]]))
else:
to_be_mutated_jmoo.append(
jmoo_individual(
problem,
[x for x in row.cells[:len(problem.decisions)]], None))
for i in xrange(initial_size - len(to_be_mutated)):
index = i % len(to_be_mutated_jmoo)
mutant = variation(problem, index, to_be_mutated_jmoo,
configuration)
to_be_mutated_jmoo.append(mutant)
members_evaluated = sum([1 for i in to_be_mutated_jmoo if i.valid])
while members_evaluated <= 2:
from random import randint
index = randint(0, len(to_be_mutated_jmoo) - 1)
to_be_mutated_jmoo[index].evaluate()
numEval += 1
members_evaluated += 1
print "> ", members_evaluated
population += to_be_mutated_jmoo
return population, numEval
def evolve_neighbor(problem, individual, population):
mutant = genetic_operation(problem, individual, population)
mutant = jmoo_individual(problem, [float(d) for d in mutant], None)
mutant.evaluate()
return update_neighbor(problem, individual, mutant, population, weighted_tche)
def gale2Mutate(problem, NDLeafs, configuration, gen, actual_population):
#################
# Mutation Phase
#################
# Keep track of evals
numEval = 0
for leaf in NDLeafs:
# Pull out the Poles
east = leaf.table.rows[0]
west = leaf.table.rows[-1]
# Evaluate those poles if needed
if not east.evaluated:
for o, objScore in enumerate(problem.evaluate(east.cells)):
east.cells[-(len(problem.objectives) - o)] = objScore
east.evaluated = True
numEval += 1
if not west.evaluated:
for o, objScore in enumerate(problem.evaluate(west.cells)):
west.cells[-(len(problem.objectives) - o)] = objScore
west.evaluated = True
numEval += 1
# Score the poles
n = len(problem.decisions)
weights = []
for obj in problem.objectives:
# w is negative when we are maximizing that objective
if obj.lismore:
weights.append(+1)
else:
weights.append(-1)
weightedWest = [c * w for c, w in zip(west.cells[n:], weights)]
weightedEast = [c * w for c, w in zip(east.cells[n:], weights)]
westLoss = loss(weightedWest,
weightedEast,
mins=[obj.low for obj in problem.objectives],
maxs=[obj.up for obj in problem.objectives])
eastLoss = loss(weightedEast,
weightedWest,
mins=[obj.low for obj in problem.objectives],
maxs=[obj.up for obj in problem.objectives])
# Determine better Pole
if eastLoss < westLoss:
SouthPole, NorthPole = east, west
else:
SouthPole, NorthPole = west, east
# Magnitude of the mutations
g = abs(SouthPole.x - NorthPole.x)
# Iterate over the individuals of the leaf
for row in leaf.table.rows:
# Make a copy of the row in case we reject it
copy = [item for item in row.cells]
gen_num_xyz = get_previous_generation_number(
actual_population, copy)
print "Generation Number: ", gen_num_xyz
temp_generation_number = get_previous_generation_number(
actual_population, copy)
cx = row.x
for attr in range(0, len(problem.decisions)):
# just some naming shortcuts
me = row.cells[attr]
good = SouthPole.cells[attr]
bad = NorthPole.cells[attr]
dec = problem.decisions[attr]
# Find direction to mutate (Want to mutate towards good pole)
if me > good: d = -1
if me < good: d = +1
if me == good: d = 0
row.cells[attr] = min(
dec.up,
max(dec.low,
(me + me * g * d) * configuration["GALE"]["DELTA"]))
# Project the Mutant
a = row.distance(NorthPole)
b = row.distance(SouthPole)
c = NorthPole.distance(SouthPole)
x = (a**2 + row.c**2 - b**2) / (2 * row.c + 0.00001)
# Test Mutant for Acceptance
# confGAMMA = 0.15 #note: make this a property
# print abs(cx-x), (cx + (g * configuration["GALE"]["GAMMA"]))
if abs(x - cx) > (g * configuration["GALE"]["GAMMA"]
) or problem.evalConstraints(
row.cells[:n]): # reject it
row.cells = copy
row.x = x
row.generation = temp_generation_number + [gen]
# After mutation; Convert back to JMOO Data Structures
population = []
for leaf in NDLeafs:
for row in leaf.table.rows:
if row.evaluated:
population.append(
jmoo_individual(
problem,
[x for x in row.cells[:len(problem.decisions)]],
row.generation,
[x for x in row.cells[len(problem.decisions):]]))
else:
population.append(
jmoo_individual(
problem,
[x for x in row.cells[:len(problem.decisions)]],
row.generation, None))
# Return selectees and number of evaluations
return population, numEval
def update(statBox, population, gen, numNewEvals, initial = False, printOption=True):
"add a stat box - compute the statistics first"
fa = open("data/results_"+statBox.problem.name+"_"+statBox.alg.name+".datatable", 'a')
# Calculate percentage of violations
violationsPercent = sum([ 1 for pop in population if statBox.problem.evalConstraints(pop.decisionValues)])/float(len(population))
# Update Number of Evaluations
statBox.numEval += numNewEvals
#front = population
#for pop in population:
# if not pop.valid: pop.evaluate()
population = [pop for pop in population if pop.fitness.valid]
#population = jmoo_algorithms.deap_format(statBox.problem, population)
#front = ParetoFront()
#front.update(population)
"""
fitnesses = []
population = []
for i,dIndividual in enumerate(front):
cells = []
for j in range(len(dIndividual)):
cells.append(dIndividual[j])
fit = []
for k in range(len(statBox.problem.objectives)):
fit.append(dIndividual.fitness.values[k])
population.append( jmoo_individual(statBox.problem, cells, fit) )
"""
# Evaluate Fitnesses
#for individual in population:
# if not individual.valid: individual.evaluate()
fitnesses = [individual.fitness.fitness for individual in population if individual.valid]
# Split Columns into Lists
fitnessColumns = [[fit[i] for fit in fitnesses] for i,obj in enumerate(statBox.problem.objectives)]
# Calculate Medians and Spreads
fitnessMedians = [median(fitCol) for fitCol in fitnessColumns]
fitnessSpreads = [spread(fitCol) for fitCol in fitnessColumns]
# Initialize Reference Point on Initial Run
if initial == True:
#statBox.referencePoint = fitnessMedians
#statBox.referencePoint = statBox.problem.referencePoint
#statBox.referencePoint = statBox.problem.evaluate(population[0].decisionValues)
statBox.referencePoint = [o.med for o in statBox.problem.objectives]
print [(o.low, o.up) for o in statBox.problem.objectives]
# Calculate IBD & IBS
norms = [[min(fitnessColumns[i]+[statBox.referencePoint[i]]), max(fitnessColumns[i]+[statBox.referencePoint[i]])] for i,obj in enumerate(statBox.problem.objectives)]
lossInQualities = [loss_in_quality(statBox.problem, [statBox.referencePoint], fit, norms) for fit in fitnesses]
IBD = median(lossInQualities)
IBS = spread(lossInQualities)
if initial == True:
IBD = 1.0
statBox.referenceIBD = 1.0
changes = []
# Print Option
if printOption == True:
outString = ""
if initial:
outString += str(statBox.numEval) + ","
for med,spr,initmed,obj,o in zip(statBox.referencePoint, [0 for x in statBox.problem.objectives], statBox.referencePoint,statBox.problem.objectives,range(len(statBox.problem.objectives))):
change = percentChange(med, initmed, obj.lismore, obj.low, obj.up)
changes.append(float(change.strip("%")))
statBox.bests[o] = changes[-1]
statBox.bests_actuals[o] = med
outString += str("%8.4f" % med) + "," + change + "," + str("%8.4f" % spr) + ","
if statBox.numEval in statBox.foam[o]: statBox.foam[o][statBox.numEval].append(change)
else: statBox.foam[o][statBox.numEval] = [change]
outString += str("%8.4f" % IBD) + "," + percentChange(statBox.referenceIBD, statBox.referenceIBD, True, 0, 1) + "," + str("%8.4f" % IBS)
else:
outString += str(statBox.numEval) + ","
for med,spr,initmed,obj,o in zip(fitnessMedians, fitnessSpreads, statBox.referencePoint,statBox.problem.objectives,range(len(statBox.problem.objectives))):
change = percentChange(med, initmed, obj.lismore, obj.low, obj.up)
changes.append(float(change.strip("%")))
if changes[-1] < statBox.bests[o]:
statBox.bests[o] = changes[-1]
statBox.bests_actuals[o] = med
outString += str("%8.4f" % med) + "," + change + "," + str("%8.4f" % spr) + ","
if statBox.numEval in statBox.foam[o]: statBox.foam[o][statBox.numEval].append(change)
else: statBox.foam[o][statBox.numEval] = [change]
outString += str("%8.4f" % IBD) + "," + percentChange(IBD, statBox.referenceIBD, True, 0, 1) + "," + str("%8.4f" % IBS)
print outString + ", violations: " + str("%4.1f" % violationsPercent)
fa.write(outString + "\n")
# Add Stat to the Stat Box
trunk = []
for i,pop in enumerate(population):
trunk.append(jmoo_individual(statBox.problem, pop.decisionValues, pop.fitness.fitness))
#if i < 5: print trunk[-1].decisionValues, statBox.problem.evalConstraints(trunk[-1].decisionValues)
statBox.box.append(jmoo_stats(trunk, fitnesses, fitnessMedians, fitnessSpreads, statBox.numEval, gen, IBD, IBS, changes))
fa.close()
def galeMutate(problem, NDLeafs, configuration):
#################
# Mutation Phase
#################
# Keep track of evals
numEval = 0
for leaf in NDLeafs:
# Pull out the Poles
east = leaf.table.rows[0]
west = leaf.table.rows[-1]
# Evaluate those poles if needed
if not east.evaluated:
for o, objScore in enumerate(problem.evaluate(east.cells)):
east.cells[-(len(problem.objectives) - o)] = objScore
east.evaluated = True
numEval += 1
if not west.evaluated:
for o, objScore in enumerate(problem.evaluate(west.cells)):
west.cells[-(len(problem.objectives) - o)] = objScore
west.evaluated = True
numEval += 1
# Score the poles
n = len(problem.decisions)
weights = []
for obj in problem.objectives:
# w is negative when we are maximizing that objective
if obj.lismore:
weights.append(+1)
else:
weights.append(-1)
weightedWest = [c * w for c, w in zip(west.cells[n:], weights)]
weightedEast = [c * w for c, w in zip(east.cells[n:], weights)]
westLoss = loss(
weightedWest,
weightedEast,
mins=[obj.low for obj in problem.objectives],
maxs=[obj.up for obj in problem.objectives],
)
eastLoss = loss(
weightedEast,
weightedWest,
mins=[obj.low for obj in problem.objectives],
maxs=[obj.up for obj in problem.objectives],
)
# Determine better Pole
if eastLoss < westLoss:
SouthPole, NorthPole = east, west
else:
SouthPole, NorthPole = west, east
# Magnitude of the mutations
g = abs(SouthPole.x - NorthPole.x)
# Iterate over the individuals of the leaf
for row in leaf.table.rows:
# Make a copy of the row in case we reject it
copy = [item for item in row.cells]
cx = row.x
for attr in range(0, len(problem.decisions)):
# just some naming shortcuts
me = row.cells[attr]
good = SouthPole.cells[attr]
bad = NorthPole.cells[attr]
dec = problem.decisions[attr]
# Find direction to mutate (Want to mutate towards good pole)
if me > good:
d = -1
if me < good:
d = +1
if me == good:
d = 0
row.cells[attr] = min(dec.up, max(dec.low, me + me * g * d))
# Project the Mutant
a = row.distance(NorthPole)
b = row.distance(SouthPole)
c = NorthPole.distance(SouthPole)
x = (a ** 2 + row.c ** 2 - b ** 2) / (2 * row.c + 0.00001)
# Test Mutant for Acceptance
# confGAMMA = 0.15 #note: make this a property
# print abs(cx-x), (cx + (g * configuration["GALE"]["GAMMA"]))
if abs(x - cx) > (g * configuration["GALE"]["GAMMA"]) or problem.evalConstraints(
row.cells[:n]
): # reject it
row.cells = copy
row.x = x
# After mutation; Convert back to JMOO Data Structures
population = []
for leaf in NDLeafs:
for row in leaf.table.rows:
if row.evaluated:
population.append(
jmoo_individual(
problem,
[x for x in row.cells[: len(problem.decisions)]],
[x for x in row.cells[len(problem.decisions) :]],
)
)
else:
population.append(jmoo_individual(problem, [x for x in row.cells[: len(problem.decisions)]], None))
# Return selectees and number of evaluations
return population, numEval
def fastmap(problem, true_population):
"""
Fastmap function that projects all the points on the principal component
:param problem: Instance of the problem
:param population: Set of points in the cluster population
:return:
"""
def list_equality(lista, listb):
for a, b in zip(lista, listb):
if a != b: return False
return True
from random import choice
from Techniques.euclidean_distance import euclidean_distance
decision_population = [pop.decisionValues for pop in true_population]
one = choice(decision_population)
west = furthest(one, decision_population)
east = furthest(west, decision_population)
west_indi = jmoo_individual(problem,west, None)
east_indi = jmoo_individual(problem,east, None)
west_indi.evaluate()
east_indi.evaluate()
for true_pop in true_population:
if list_equality(true_pop.decisionValues, west_indi.decisionValues): true_pop.fitness.fitness = west_indi.fitness.fitness
if list_equality(true_pop.decisionValues, east_indi.decisionValues): true_pop.fitness.fitness = east_indi.fitness.fitness
# Score the poles
n = len(problem.decisions)
weights = []
for obj in problem.objectives:
# w is negative when we are maximizing that objective
if obj.lismore:
weights.append(+1)
else:
weights.append(-1)
weightedWest = [c * w for c, w in zip(west_indi.fitness.fitness, weights)]
weightedEast = [c * w for c, w in zip(east_indi.fitness.fitness, weights)]
westLoss = loss(weightedWest, weightedEast, mins=[obj.low for obj in problem.objectives],
maxs=[obj.up for obj in problem.objectives])
eastLoss = loss(weightedEast, weightedWest, mins=[obj.low for obj in problem.objectives],
maxs=[obj.up for obj in problem.objectives])
# Determine better Pole
if eastLoss < westLoss:
SouthPole, NorthPole = east_indi, west_indi
else:
SouthPole, NorthPole = west_indi, east_indi
east = SouthPole.decisionValues
west = NorthPole.decisionValues
c = euclidean_distance(east, west)
tpopulation = []
for one in decision_population:
a = euclidean_distance(one, west)
b = euclidean_distance(one, east)
tpopulation.append([one, projection(a, b, c)])
for tpop in tpopulation:
for true_pop in true_population:
if list_equality(tpop[0], true_pop.decisionValues):
true_pop.x = tpop[-1]
temp_list = sorted(true_population, key=lambda pop: pop.x)
return temp_list
def gale_64_Mutate(problem, NDLeafs, configuration):
#################
# Mutation Phase
#################
# Keep track of evals
numEval = 0
population = []
for leaf in NDLeafs:
initial_size = len(leaf.table.rows)
# print "Number of mutants: ", len(leaf.table.rows)
# Pull out the Poles
east = leaf.table.rows[0]
west = leaf.table.rows[-1]
# Evaluate those poles if needed
if not east.evaluated:
for o, objScore in enumerate(problem.evaluate(east.cells)):
east.cells[-(len(problem.objectives) - o)] = objScore
east.evaluated = True
numEval += 1
if not west.evaluated:
for o, objScore in enumerate(problem.evaluate(west.cells)):
west.cells[-(len(problem.objectives) - o)] = objScore
west.evaluated = True
numEval += 1
# Score the poles
n = len(problem.decisions)
weights = []
for obj in problem.objectives:
# w is negative when we are maximizing that objective
if obj.lismore:
weights.append(+1)
else:
weights.append(-1)
weightedWest = [c * w for c, w in zip(west.cells[n:], weights)]
weightedEast = [c * w for c, w in zip(east.cells[n:], weights)]
westLoss = loss(weightedWest, weightedEast, mins=[obj.low for obj in problem.objectives],
maxs=[obj.up for obj in problem.objectives])
eastLoss = loss(weightedEast, weightedWest, mins=[obj.low for obj in problem.objectives],
maxs=[obj.up for obj in problem.objectives])
# Determine better Pole
if eastLoss < westLoss:
to_be_mutated = leaf.table.rows[:int(len(leaf.table.rows)/2)]
else:
to_be_mutated = leaf.table.rows[:int(len(leaf.table.rows)/2)]
to_be_mutated_jmoo = []
for row in to_be_mutated:
if row.evaluated:
to_be_mutated_jmoo.append(jmoo_individual(problem, [x for x in row.cells[:len(problem.decisions)]],
[x for x in row.cells[len(problem.decisions):]]))
else:
to_be_mutated_jmoo.append(jmoo_individual(problem, [x for x in row.cells[:len(problem.decisions)]], None))
for i in xrange(initial_size - len(to_be_mutated)):
index = i%len(to_be_mutated_jmoo)
mutant = variation(problem, index, to_be_mutated_jmoo, configuration)
to_be_mutated_jmoo.append(mutant)
members_evaluated = sum([1 for i in to_be_mutated_jmoo if i.valid])
while members_evaluated <= 2:
from random import randint
index = randint(0, len(to_be_mutated_jmoo)-1)
to_be_mutated_jmoo[index].evaluate()
numEval += 1
members_evaluated += 1
print "> ", members_evaluated
population += to_be_mutated_jmoo
return population, numEval
def sbxcrossover(problem, parent1, parent2, configuration):
EPS = 1.0e-14
distribution_index = configuration["NSGAIII"]["ETA_C_DEFAULT_"]
probability = configuration["NSGAIII"]["SBX_Probability"]
from numpy.random import random
offspring1 = jmoo_individual(problem, parent1.decisionValues)
offspring2 = jmoo_individual(problem, parent2.decisionValues)
number_of_variables = len(problem.decisions)
if random() <= probability:
for i in xrange(number_of_variables):
valuex1 = offspring1.decisionValues[i]
valuex2 = offspring2.decisionValues[i]
if random() <= 0.5:
if abs(valuex1 - valuex2) > EPS:
if valuex1 < valuex2:
y1 = valuex1
y2 = valuex2
else:
y1 = valuex2
y2 = valuex1
yL = problem.decisions[i].low
yU = problem.decisions[i].up
rand = random()
beta = 1.0 + (2.0 * (y1 - yL) / (y2 - y1))
alpha = 2.0 - beta**(-1 * (distribution_index + 1.0))
if rand <= 1 / alpha:
betaq = (1.0 / (2.0 - rand * alpha))**(
1.0 / (distribution_index + 1.0))
else:
betaq = (1.0 / (2.0 - rand * alpha))**(
1.0 / (distribution_index + 1.0))
c1 = 0.5 * ((y1 + y2) - betaq * (y2 - y1))
beta = 1.0 + (2.0 * (yU - y2) / (y2 - y1))
alpha = 2.0 - beta**-(distribution_index + 1.0)
if rand <= (1.0 / alpha):
betaq = (rand * alpha)**(1.0 /
(distribution_index + 1.0))
else:
betaq = ((1.0 / (2.0 - rand * alpha))**(
1.0 / (distribution_index + 1.0)))
c2 = 0.5 * ((y1 + y2) + betaq * (y2 - y1))
if c1 < yL: c1 = yL
if c2 < yL: c2 = yL
if c1 > yU: c1 = yU
if c2 > yU: c2 = yU
if random() <= 0.5:
offspring1.decisionValues[i] = c2
offspring2.decisionValues[i] = c1
else:
offspring1.decisionValues[i] = c1
offspring2.decisionValues[i] = c2
else:
offspring1.decisionValues[i] = valuex1
offspring2.decisionValues[i] = valuex2
else:
offspring1.decisionValues[i] = valuex2
offspring2.decisionValues[i] = valuex1
return offspring1, offspring2
def fastmap(problem, true_population):
"""
Fastmap function that projects all the points on the principal component
:param problem: Instance of the problem
:param population: Set of points in the cluster population
:return:
"""
def list_equality(lista, listb):
for a, b in zip(lista, listb):
if a != b: return False
return True
from random import choice
from Techniques.euclidean_distance import euclidean_distance
decision_population = [pop.decisionValues for pop in true_population]
one = choice(decision_population)
west = furthest(one, decision_population)
east = furthest(west, decision_population)
west_indi = jmoo_individual(problem, west, None)
east_indi = jmoo_individual(problem, east, None)
west_indi.evaluate()
east_indi.evaluate()
for true_pop in true_population:
if list_equality(true_pop.decisionValues, west_indi.decisionValues):
true_pop.fitness.fitness = west_indi.fitness.fitness
if list_equality(true_pop.decisionValues, east_indi.decisionValues):
true_pop.fitness.fitness = east_indi.fitness.fitness
# Score the poles
n = len(problem.decisions)
weights = []
for obj in problem.objectives:
# w is negative when we are maximizing that objective
if obj.lismore:
weights.append(+1)
else:
weights.append(-1)
weightedWest = [c * w for c, w in zip(west_indi.fitness.fitness, weights)]
weightedEast = [c * w for c, w in zip(east_indi.fitness.fitness, weights)]
westLoss = loss(weightedWest,
weightedEast,
mins=[obj.low for obj in problem.objectives],
maxs=[obj.up for obj in problem.objectives])
eastLoss = loss(weightedEast,
weightedWest,
mins=[obj.low for obj in problem.objectives],
maxs=[obj.up for obj in problem.objectives])
# Determine better Pole
if eastLoss < westLoss:
SouthPole, NorthPole = east_indi, west_indi
else:
SouthPole, NorthPole = west_indi, east_indi
east = SouthPole.decisionValues
west = NorthPole.decisionValues
c = euclidean_distance(east, west)
tpopulation = []
for one in decision_population:
a = euclidean_distance(one, west)
b = euclidean_distance(one, east)
tpopulation.append([one, projection(a, b, c)])
for tpop in tpopulation:
for true_pop in true_population:
if list_equality(tpop[0], true_pop.decisionValues):
true_pop.x = tpop[-1]
temp_list = sorted(true_population, key=lambda pop: pop.x)
return temp_list
def update(statBox,
population,
gen,
num_new_evals,
initial=False,
population_size=None,
printOption=True):
"add a stat box - compute the statistics first"
# Find a file name to write the stats to
if (statBox.alg.name == "GALE0" or statBox.alg.name
== "GALE_no_mutation") and population_size is not None:
filename = "Data/results_"+statBox.problem.name + "-p" + str(population_size) + "-d" + \
str(len(statBox.problem.decisions)) + "-o" + str(len(statBox.problem.objectives))+\
"_"+statBox.alg.name+".datatable"
else:
filename = "Data/results_"+statBox.problem.name + "-p" + str(len(population)) + "-d" + \
str(len(statBox.problem.decisions)) + "-o" + str(len(statBox.problem.objectives))+\
"_"+statBox.alg.name+".datatable"
fa = open(filename, 'a')
# Update Number of Evaluations
statBox.numEval += num_new_evals
# population represents on the individuals which have been evaluated
shorten_population = [pop for pop in population if pop.fitness.valid]
objectives = [
individual.fitness.fitness for individual in shorten_population
]
# Split Columns into Lists
objective_columns = [[
objective[i] for objective in objectives
] for i, obj in enumerate(statBox.problem.objectives)]
# Calculate Medians of objective scores
objective_medians = [median(fitCol) for fitCol in objective_columns]
# Calculate IQR of objective scores
objective_iqr = [spread(fitCol) for fitCol in objective_columns]
# Initialize Reference Point on Initial Run
if initial is True:
statBox.referencePoint = [
o.med for o in statBox.problem.objectives
]
statBox.reference_point_for_hypervolume = [
o.up for o in statBox.problem.objectives
]
# Calculate IBD & IBS
# Finding min and max for each objectives
norms = [[
min(objective_columns[i] + [statBox.referencePoint[i]]),
max(objective_columns[i] + [statBox.referencePoint[i]])
] for i, obj in enumerate(statBox.problem.objectives)]
lossInQualities = [{
"qual":
loss_in_quality(statBox.problem, [statBox.referencePoint], fit,
norms),
"index":
i
} for i, fit in enumerate(objectives)]
lossInQualities.sort(key=lambda (r): r["qual"])
if len(objectives) > 0:
best_fitness = objectives[lossInQualities[0]["index"]]
else:
best_fitness = objective_medians
lossInQualities = [item["qual"] for item in lossInQualities]
IBD = median(lossInQualities)
IBS = spread(lossInQualities)
if initial is True:
IBD = 1.0
statBox.referenceIBD = 1.0
changes = []
# Print Option
if printOption is True:
outString = ""
if initial:
outString += str(statBox.numEval) + ","
for med, spr, initmed, obj, o in zip(
statBox.referencePoint,
[0 for x in statBox.problem.objectives],
statBox.referencePoint, statBox.problem.objectives,
range(len(statBox.problem.objectives))):
change = percentChange(med, initmed, obj.lismore, obj.low,
obj.up)
changes.append(float(change.strip("%")))
statBox.bests[o] = changes[-1]
statBox.bests_actuals[o] = med
outString += str("%8.4f" % med) + "," + change + "," + str(
"%8.4f" % spr) + ","
if statBox.numEval in statBox.foam[o]:
statBox.foam[o][statBox.numEval].append(change)
else:
statBox.foam[o][statBox.numEval] = [change]
outString += str("%8.4f" % IBD) + "," + percentChange(
statBox.referenceIBD, statBox.referenceIBD, True, 0,
1) + "," + str("%8.4f" % IBS)
else:
outString += str(statBox.numEval) + ","
for med, spr, initmed, obj, o in zip(
best_fitness, objective_iqr, statBox.referencePoint,
statBox.problem.objectives,
range(len(statBox.problem.objectives))):
change = percentChange(med, initmed, obj.lismore, obj.low,
obj.up)
changes.append(float(change.strip("%")))
if changes[-1] < statBox.bests[o]:
statBox.bests[o] = changes[-1]
statBox.bests_actuals[o] = med
outString += str("%8.4f" % med) + "," + change + "," + str(
"%8.4f" % spr) + ","
if statBox.numEval in statBox.foam[o]:
statBox.foam[o][statBox.numEval].append(change)
else:
statBox.foam[o][statBox.numEval] = [change]
outString += str("%8.4f" % IBD) + "," + percentChange(
IBD, statBox.referenceIBD, True, 0, 1) + "," + str(
"%8.4f" % IBS)
fa.write(outString + "\n")
# Add Stat to the Stat Box
trunk = []
for i, pop in enumerate(shorten_population):
trunk.append(
jmoo_individual(statBox.problem, pop.decisionValues,
pop.fitness.fitness))
statBox.box[-1] = jmoo_stats(trunk, objectives, best_fitness,
objective_iqr, statBox.numEval, gen, IBD,
IBS, changes)
fa.close()
def selNSGA3(problem, individuals, k):
"""Apply NSGA-III selection operator on the *individuals*. Usually, the
size of *individuals* will be larger than *k* because any individual
present in *individuals* will appear in the returned list at most once.
Having the size of *individuals* equals to *k* will have no effect other
than sorting the population according according to their front rank. The
list returned contains references to the input *individuals*. For more
details on the NSGA-II operator see [Deb2002]_.
:param individuals: A list of individuals to select from.
:param k: The number of individuals to select.
:returns: A list of selected individuals.
Deb, Kalyanmoy, and Himanshu Jain. "An evolutionary many-objective optimization algorithm using
reference-point-based nondominated sorting approach, part i: Solving problems with box constraints."x
Evolutionary Computation, IEEE Transactions on 18.4 (2014): 577-601.
"""
#print "Length of individuals: ", len(individuals)
pareto_fronts = sortNondominated(individuals, k)
f_l_no = len(pareto_fronts) - 1
P_t_1_no = len(list(chain(*pareto_fronts[:-1])))
total_points_returned = len(list(chain(*pareto_fronts)))
population =[]
for front_no, front in enumerate(pareto_fronts):
for i, dIndividual in enumerate(front):
cells = []
for j in xrange(len(dIndividual)):
cells.append(dIndividual[j])
population.append(jmoo_individual(problem, cells, dIndividual.fitness.values))
population[-1].front_no = front_no
print ">" * 10
Z_s = cover(len(problem.objectives))
Z_a = None
Z_r = None
if total_points_returned == k:
return normalize(problem, population, Z_r, Z_s, Z_a)
# S_t = P_t_1 + pareto_fronts[-1]
K = k - P_t_1_no
# Get the reference points
population = normalize(problem, population, Z_r, Z_s, Z_a)
population = associate(population, Z_s)
f_l = []
P_t_1 = []
for pop in population:
if pop.front_no == f_l_no:
f_l.append(pop)
else:
P_t_1.append(pop)
assert(len(P_t_1) == P_t_1_no), "Something's wrong"
P_t_1 = niching(K, len(Z_s), P_t_1, f_l)
assert(len(P_t_1) == jmoo_properties.MU), "Length is mismatched"
return P_t_1
def update(statBox,
population,
gen,
numNewEvals,
initial=False,
printOption=True):
"add a stat box - compute the statistics first"
fa = open(
"data/results_" + statBox.problem.name + "_" + statBox.alg.name +
".datatable", 'a')
# Calculate percentage of violations
violationsPercent = sum([
1 for pop in population
if statBox.problem.evalConstraints(pop.decisionValues)
]) / float(len(population)) # not sure what is this used for
# Update Number of Evaluations
statBox.numEval += numNewEvals
population = [pop for pop in population if pop.fitness.valid
] # population for which the score is calculated
# Evaluate Fitnesses
#for individual in population:
# if not individual.valid: individual.evaluate()
fitnesses = [
individual.fitness.fitness for individual in population
if individual.valid
]
# Split Columns into Lists
fitnessColumns = [[fit[i] for fit in fitnesses]
for i, obj in enumerate(statBox.problem.objectives)]
# Calculate Medians and Spreads
fitnessMedians = [median(fitCol) for fitCol in fitnessColumns]
fitnessSpreads = [spread(fitCol) for fitCol in fitnessColumns]
# Initialize Reference Point on Initial Run
if initial == True:
statBox.referencePoint = [
o.med for o in statBox.problem.objectives
]
# Calculate IBD & IBS
norms = [[
min(fitnessColumns[i] + [statBox.referencePoint[i]]),
max(fitnessColumns[i] + [statBox.referencePoint[i]])
] for i, obj in enumerate(statBox.problem.objectives)]
lossInQualities = [
loss_in_quality(statBox.problem, [statBox.referencePoint], fit,
norms) for fit in fitnesses
]
IBD = median(lossInQualities) #median
IBS = spread(lossInQualities) #IQR
if initial == True:
IBD = 1.0
statBox.referenceIBD = 1.0
changes = []
# Print Option
if printOption == True:
outString = ""
if initial:
outString += str(statBox.numEval) + ","
for med, spr, initmed, obj, o in zip(
statBox.referencePoint,
[0 for x in statBox.problem.objectives],
statBox.referencePoint, statBox.problem.objectives,
range(len(statBox.problem.objectives))):
change = percentChange(med, initmed, obj.lismore, obj.low,
obj.up)
changes.append(float(change.strip("%")))
statBox.bests[o] = changes[-1]
statBox.bests_actuals[o] = med
outString += str("%8.4f" % med) + "," + change + "," + str(
"%8.4f" % spr) + ","
if statBox.numEval in statBox.foam[o]:
statBox.foam[o][statBox.numEval].append(change)
else:
statBox.foam[o][statBox.numEval] = [change]
outString += str("%8.4f" % IBD) + "," + percentChange(
statBox.referenceIBD, statBox.referenceIBD, True, 0,
1) + "," + str("%8.4f" % IBS)
else:
outString += str(statBox.numEval) + ","
for med, spr, initmed, obj, o in zip(
fitnessMedians, fitnessSpreads, statBox.referencePoint,
statBox.problem.objectives,
range(len(statBox.problem.objectives))):
change = percentChange(med, initmed, obj.lismore, obj.low,
obj.up)
changes.append(float(change.strip("%")))
if changes[-1] < statBox.bests[o]:
statBox.bests[o] = changes[-1]
statBox.bests_actuals[o] = med
outString += str("%8.4f" % med) + "," + change + "," + str(
"%8.4f" % spr) + ","
if statBox.numEval in statBox.foam[o]:
statBox.foam[o][statBox.numEval].append(change)
else:
statBox.foam[o][statBox.numEval] = [change]
outString += str("%8.4f" % IBD) + "," + percentChange(
IBD, statBox.referenceIBD, True, 0, 1) + "," + str(
"%8.4f" % IBS)
print outString + ", violations: " + str(
"%4.1f" % violationsPercent)
fa.write(outString + "\n")
# Add Stat to the Stat Box
trunk = []
for i, pop in enumerate(population):
trunk.append(
jmoo_individual(statBox.problem, pop.decisionValues,
pop.fitness.fitness))
#if i < 5: print trunk[-1].decisionValues, statBox.problem.evalConstraints(trunk[-1].decisionValues)
statBox.box.append(
jmoo_stats(trunk, fitnesses, fitnessMedians, fitnessSpreads,
statBox.numEval, gen, IBD, IBS, changes))
fa.close()
