def sim_Annealing(T, OBJs, execTime, *args):
temp = args[0]
alpha = args[1]
niter = args[2]
s = [0] * len(OBJs)
bs = s # best state found
start = time()
while temp > 1:
if time() - start > execTime:
break
si = neightborhood(s, T, OBJs)
for _ in range(niter):
sn = take_Random(si)
oValue = bp.state_Value(sn, OBJs)
if oValue > bp.state_Value(s, OBJs):
s = sn
si = neightborhood(s, T, OBJs) # updating neightborhood
if oValue > bp.state_Value(bs, OBJs):
bs = sn
else:
p = math.exp((oValue - bp.state_Value(s, OBJs)) / temp)
if random.random() < p:
s = sn
si = neightborhood(s, T, OBJs) # updating neightborhood
temp *= alpha
return bs
def grasp(iter):
bs = [0]*len(bp.OBJs)
for _ in range(iter):
s = greedy_Random_Construct()
s = local_Search(s)
if bp.state_Verify(s) and bp.state_Value(s) > bp.state_Value(bs):
bs = s
return bs
def genetic(popMaxSize, iter, crossoverRate, mutationRate):
si = init_Population(popMaxSize)
bs = [0]*len(bp.OBJs)
for _ in range(iter):
si = generate_New_Pop(si, crossoverRate, mutationRate)
s = best_in_Pop(si)
if bp.state_Verify(s) and bp.state_Value(s) > bp.state_Value(bs):
bs = s
return bs
def deepest_Descent(s):
bs = s # best state found
si = neightborhood(s)
c = True # continue flag
while c:
c, sn = select_Best(si)
if bp.state_Value(sn) > bp.state_Value(bs):
bs = sn
si = neightborhood(sn)
else:
break
return bs
def multistart_Descend(iter, use_Deepest=False):
if use_Deepest:
func = dd.deepest_Descent
else:
func = sd.simple_Descent
bs = [0] * len(bp.OBJs) # best state found
for _ in range(iter):
s = random_Start_State()
sn = func(s)
if bp.state_Verify(sn) and bp.state_Value(sn) > bp.state_Value(bs):
bs = sn
return bs
def beam_Search(m):
f = queue.Queue(m)
f.put([0]*len(bp.OBJs)) # starting queue with the initial state
bs = [0]*len(bp.OBJs) # starting best state as initial state
while f.qsize() > 0:
st = f.get()
if bp.state_Value(st) > bp.state_Value(bs):
bs = st
si = select_Best_States(m-f.qsize(), st)
for i in si:
f.put(i)
return bs
def simple_Descent(s):
bs = s # best state found
si = neightborhood(s)
while len(si) > 0:
for _ in range(len(si)):
sn = take_Random(si)
if bp.state_Value(sn) > bp.state_Value(bs):
bs = sn
si = neightborhood(sn)
break
else:
break # exiting if no better state is found
return bs
def deepest_Descent(T, OBJs, s, startTime, execTime):
bs = s # best state found
si = neightborhood(s, T, OBJs)
c = True # continue flag
while c:
if time() - startTime > execTime:
break
c, sn = select_Best(si, T, OBJs)
if bp.state_Value(sn, OBJs) > bp.state_Value(bs, OBJs):
bs = sn
si = neightborhood(sn, T, OBJs)
else:
break
return bs
def grasp(T, OBJs, execTime, *args):
niter = args[0]
numBest = args[1]
s = [0] * len(OBJs)
bs = s # best state found
start = time()
for _ in range(niter):
if time() - start > execTime:
break
s = greedy_Random_Construct(s, numBest, T, OBJs, start, execTime)
sl = local_Search(T, OBJs, s, start, execTime) # local state found
if bp.state_Verify(
sl, T,
OBJs) and bp.state_Value(sl, OBJs) > bp.state_Value(bs, OBJs):
bs = sl
return bs
def beam_Search(T, OBJs, execTime, *args):
m = args[0]
f = queue.Queue(m)
f.put([0] * len(OBJs)) # starting queue with the initial state
bs = [0] * len(OBJs) # starting best state as initial state
start = time()
while f.qsize() > 0:
if time() - start > execTime:
break
st = f.get()
if bp.state_Value(st, OBJs) > bp.state_Value(bs, OBJs):
bs = st
si = select_Best_States(m - f.qsize(), st, T, OBJs)
for i in si:
f.put(i)
return bs
def select_Best_States(n, st):
si = bp.state_Expansion(st)
si = [[bp.state_Value(s),s] for s in si]
si.sort(reverse=True)
si = [i[1] for i in si]
bss = []
for i in filter(bp.state_Verify, si):
bss.append(i)
return bss[:n]
def genetic(T, OBJs, execTime, *args):
popMaxSize = args[0]
niter = 500
crossoverRate = args[1]
mutationRate = args[2]
si = init_Population(popMaxSize, OBJs)
bs = [0] * len(OBJs)
start = time()
for _ in range(niter):
if time() - start > execTime:
break
si = generate_New_Pop(si, crossoverRate, mutationRate, T, OBJs)
s = best_in_Pop(si, T, OBJs)
if bp.state_Verify(
s, T,
OBJs) and bp.state_Value(s, OBJs) > bp.state_Value(bs, OBJs):
bs = s
return bs
def select_Best_States(n, st, T, OBJs):
si = bp.state_Expansion(st)
si = [[bp.state_Value(s, OBJs), s] for s in si]
si.sort(reverse=True)
si = [i[1] for i in si]
bss = []
for i in si:
if bp.state_Verify(i, T, OBJs):
bss.append(i)
return bss[:n]
def branch_n_bound(use_opt_estimate=True):
bs = triv_solution() # best state found
sv = bp.state_Value(bs) # value of best bs
pq.insert(0, [0] * len(bp.OBJs)) # pushing initial state in queue
while not pq.isEmpty():
cs = pq.remove() # current state
si = bp.state_Expansion(cs) # expansion of current state
for s in si:
if bp.state_Verify(s):
if use_opt_estimate: # selecting estimate method
est = opt_Estimate(s)
else:
est = n_Opt_Estimate(s)
if bp.state_Value(est) > sv:
if bp.state_Value(s) > sv:
bs = s # updating best bs
sv = bp.state_Value(s) # updating best value
pq.insert(bp.state_Value(s), s)
return bs
def init_Population(popMaxSize, OBJs):
pop = [[0] * len(OBJs)] # insert initial state
for _ in range(popMaxSize):
s = pop[len(pop) - 1].copy() # get last added state
s = mutation(s)
if bp.state_Value(s,
OBJs) == 0: # for safity, empty states are not added
p = random.randint(0, len(s) - 1)
s[p] += 1
pop.append(s)
return pop
def select_Best(si):
sn = -1 # best state position
sv = 0 # state value
for i in range(len(si)):
v = bp.state_Value(si[i]) # current value
if bp.state_Verify(si[i]) and v > sv:
sv = v
sn = i
if sn == -1:
return False, []
return True, si[sn]
def test():
results = [] # heuristics results
normResults = [] # heuristics normalized results
execTimes = [] # heuristics execution times
avr = [] # heuristics avarages
sdv = [] # heuristics standard deviations
normAvr = [] # normalized heuristics avarages
normSdv = [] # normalized heuristics standard deviations
timeAvr = [] # heuristics execution times avarages
timeSdv = [] # heuristics execution times standard deviations
for h in HEURISTICS: # for each metaheuristic
funcName = h[0]
func = h[1]
par = h[3]
r = [] # problens results
t = [] # problens execution time
for p in TEST: # for each test problem
T = p[0]
OBJs = p[1]
start = time()
ans = func(T, OBJs, 300, *par)
end = time()
r.append(bp.state_Value(ans, OBJs))
t.append(end - start)
results.append(r.copy())
execTimes.append(t.copy())
avr.append(mean(r))
sdv.append(stdev(r))
timeAvr.append(mean(t))
timeSdv.append(stdev(t))
names = [x[0] for x in HEURISTICS]
normResults = crossNormalize(results) # normalizing problens results
normAvr = [mean(x) for x in normResults]
normSdv = [stdev(x) for x in normResults]
# saving boxplots:
genarate_Boxplot(' Teste - Valores', normResults, names, 'Valor',
'Meta-Heurística')
genarate_Boxplot(' Teste - Tempo de Execução', execTimes, names,
'Tempo (segundos)', 'Meta-Heurística')
headers = [
'Meta-heurística', 'Média Absoluta', 'Desvio Padrão Absoluto',
'Média Normalizada', 'Desvio Padrão Normalizado',
'Média do Tempo de Execução', 'Desvio Padrão do Tempo de Execução'
]
# saving table:
generateLatexTable([names, avr, sdv, normAvr, normSdv, timeAvr, timeSdv],
headers, 'Tabela')
# making and saving ranks:
avgRank(results)
normRank(normAvr)
def roulette(si, OBJs):
probRatio = [] # roulette
# Adding all states's values to probRatio:
for s in si:
probRatio.append(bp.state_Value(s, OBJs))
# Normalizing the values:
ratioSum = sum(probRatio)
probRatio = [(i / ratioSum) for i in probRatio]
# Building the "partitions" of the roulette:
for i in range(len(probRatio)):
probRatio[i] = sum(probRatio[i:])
# Selecting a random element:
selector = random.random()
for i in range(len(probRatio)):
if selector >= probRatio[i]:
s = si[i]
break
return s
def roulette(si, OBJs):
probRatio = [] # roulette
c = []
# Adding values to probRatio:
for s in si:
probRatio.append(bp.state_Value(s, OBJs))
# Normalizing the values:
ratioSum = sum(probRatio)
probRatio = [(i / ratioSum) for i in probRatio]
# Building the "partitions" of the roulette:
probRatio = list(accumulate(probRatio))
# Selecting a random element:
ratioSum = sum(probRatio)
selector = random.random()
for i in range(len(probRatio)):
if selector <= probRatio[i]:
c = si[i]
break
return c
def train():
testParameters = []
for h in HEURISTICS: # for each metaheuristic
funcName = h[0]
func = h[1]
parList = h[2]
parameters = build_Parameters(parList)
results = [] # heuristics results
normResults = [] # heuristics normalized results
execTimes = [] # heuristics execution times
for p in TRAIN: # for each train problem
T = p[0]
OBJs = p[1]
r = [] # problem results
n = [] # problem normalized results
t = [] # problem execution time
for c in parameters: # for each configuration of hiperparameters
start = time()
ans = func(T, OBJs, 120, *c)
end = time()
r.append(bp.state_Value(ans, OBJs)) # saving result
t.append(end - start) # saving execution time
n = normalize(r) # normalizing results
results.append(r.copy()) # saving problem results
normResults.append(n.copy()) # saving problem normalized results
execTimes.append(t.copy()) # saving problem execution time
testPar, bestResults, bestTimes, xTickLabels = take_Best_Configurations(
parameters, results, normResults, execTimes)
testParameters.append(testPar.copy())
# saving best parameter in a file:
with open('Results.txt', 'a') as file:
file.write(funcName + ': ' + str(testPar) + '\n')
# printing boxplots:
genarate_Boxplot(funcName + '_-_Valores', bestResults, xTickLabels,
'Valor Normalizado', 'Melhores Hiperparâmetros')
genarate_Boxplot(funcName + '_-_Tempo_de_Execução', bestTimes,
xTickLabels, 'Tempo (segundos)',
'Melhores Hiperparâmetros')
return testParameters
def sim_Annealing(s,temp,iter):
bs = s # best state found
alpha = random.random() # random value in [0,1]
while temp > 1:
si = neightborhood(s)
for _ in range(iter):
sn = take_Random(si)
if bp.state_Value(sn) > bp.state_Value(s):
s = sn
si = neightborhood(s) # updating neightborhood
if bp.state_Value(sn) > bp.state_Value(bs):
bs = sn
else:
p = math.exp((bp.state_Value(sn) - bp.state_Value(s))/temp)
if random.random() < p:
s = sn
si = neightborhood(s) # updating neightborhood
temp *= alpha
return bs
def fitness(s, T, OBJs):
if bp.state_Verify(s, T, OBJs):
return bp.state_Value(s, OBJs)
return 0
