def SA(model,kmax=10**5,cooling=5,emax=0):
print("Model Name is " + model.model_name + ", Optimizer is Simulated Annealing")
# Base variables
eMax = 0
reading = ""
# Start with a random value
state = model.get_neighbor()
en = model.normalize_val(model.eval(state))
lives = 5
previous_era = []
current_era = []
b_state,be_en = state,en
i = 0
while i < kmax - 1 and state > emax:
state_reading = " ."
neigh_state = model.get_neighbor()
neigh_en = model.normalize_val(model.eval(neigh_state))
if model.type1(neigh_state,b_state):
state_reading = " !"
b_state,be_en = neigh_state,neigh_en
elif model.type1(neigh_state,state):
state_reading = " +"
state,en = neigh_state,neigh_en
elif math.e**((en - neigh_en)/((1-(i/kmax))**cooling))>random.random():
state_reading = " ?"
state,en = neigh_state,neigh_en
reading += state_reading
if i % 100 is 0 and i is not 0:
if len(previous_era) is not 0:
lives += type2(current_era, previous_era, model)
previous_era = list(current_era)
current_era = []
else:
current_era.append(neigh_state)
if lives == 0:
return previous_era
i += 1
return previous_era
def DE(model):
def build_frontier():
new_frontier = []
for _ in xrange(100):
neighbor = model.get_neighbor()
while model.okay(neighbor) is False:
neighbor = model.get_neighbor()
new_frontier.append(neighbor)
return new_frontier
def get_frontier_neighbors(cur):
seen = []
while len(seen) < 3:
rand_index = random.randint(0, 99)
if rand_index == cur:
continue
if rand_index not in seen:
seen.append(rand_index)
return seen
def get_mutation(seen):
soln = []
for j in xrange(model.number_vars):
l , m = model.var_bounds[j]
inter = (frontier[seen[0]][j] + 0.75 * (frontier[seen[1]][j] - frontier[seen[2]][j]))
if inter >= l and inter <= m:
soln.append(inter)
else:
soln.append(frontier[seen[random.randint(0, 2)]][j])
return soln
print("Model Name : " + model.model_name + ", Optimizer : differential evolution")
frontier = build_frontier()
e = model.eval(frontier[0])
best_sol = frontier[0]
eras = 5
previous_era = []
current_era = []
k_max = 100000
k = 0
cf = 0.3
threshold = 0
while k < k_max:
output = ""
if model.normalize_val(e) == threshold:
break
for i, solution in enumerate(frontier):
seen = get_frontier_neighbors(i)
mutation = frontier[seen[0]]
cur_e = model.eval(solution)
out = "."
if cf < random.random():
if model.type1(mutation, solution):
cur_e = model.eval(mutation)
frontier[i] = mutation
out += "+"
else:
mutation = get_mutation(seen)
if model.okay(mutation) and model.type1(mutation, solution):
frontier[i] = mutation
cur_e = model.eval(mutation)
out = "+"
if model.type1(solution, best_sol) and model.normalize_val(cur_e) >= threshold:
out = "?"
e = cur_e
best_sol = frontier[i]
output += out
k += 1
if k % 25 is 0:
# print ("%.5f, %20s" % (model.normalize_val(e), output))
output = ""
if k % 100 is 0 and k is not 0:
if len(previous_era) is not 0:
eras += type2(current_era, previous_era, model)
previous_era = list(current_era)
current_era = []
else:
current_era.append(solution)
if eras == 0:
print("Early Termination " + str(k) + " : " + str(eras))
return previous_era
return previous_era
def MWS(model,val=False,kmax=1000,maxtries=1000,maxchanges=50,threshold=0,p=0.5):
def change_to_maximize(soln, index,steps=10):
evaluations = 0
best = soln
solution = soln
low, high = model.var_bounds[index]
delta = (high - low)/steps
for k in xrange(0, steps):
evaluations += 1
solution[index] = low + delta*k
if model.okay(solution) and model.type1(solution, best):
best = list(solution)
return best
print("Model Name is " + model.model_name + ", Optimizer is Max Walk Sat")
best_solution = model.get_neighbor()
be_en = model.normalize_val(model.eval(best_solution))
output = ""
lives = 5
previous_era = []
current_era = []
step = 10
for i in xrange(0,maxtries):
new_solution = model.get_neighbor()
new_en = model.normalize_val(model.eval(new_solution))
for j in xrange(0,maxchanges):
record = " ."
curr_en = new_en
if curr_en<threshold:
if len(previous_era) is not 0:
return previous_era
else:
return current_era
c = random.randint(0,model.number_vars-1)
oldsolution = copy.copy(new_solution)
old_en = new_en
if p< random.random():
new_solution[c] = random.uniform(model.var_bounds[c][0],model.var_bounds[c][1])
else:
new_solution = change_to_maximize(new_solution, c)
curr_en = model.normalize_val(model.eval(new_solution))
if(old_en==curr_en):
record = " ."
elif(old_en>curr_en):
record = " ?"
else:
if(old_en<curr_en):
record = " +"
if(be_en<curr_en):
best_solution = copy.copy(new_solution)
be_en = curr_en
record = " !"
output += record
if i % 100 is 0 and i is not 0:
if len(previous_era) is not 0:
lives += type2(current_era, previous_era, model)
previous_era = list(current_era)
current_era = []
else:
current_era.append(new_solution)
if lives <= 0:
return previous_era
if len(previous_era) is not 0:
return previous_era
else:
return current_era
