def mutation(prob, sol, local_search, ls_args): logging.info("Mutation") diam = prob.get_diam() bounds = np.zeros(prob.v_size, dtype=int) for i in range(sol.v_size): i_col = min(sol[i], diam - 1) + 1 bound = np.sum(prob.dist_matrix[i] == i_col) bounds[i] = bound v = np.argmax(bounds) v_col = min(sol[v], diam - 1) + 1 adj_mat = (prob.dist_matrix == 1) # changes = (prob.dist_matrix[v] == v_col) changes = np.logical_or((prob.dist_matrix[v] == v_col), adj_mat[v]) adj_mat[v] = changes adj_mat[..., v] = np.transpose(changes) new_prob = GraphProblem(adj_mat) new_sol = PackColSolution(new_prob) new_sol = rlf_algorithm(new_prob) new_sol = local_search(new_prob, sol=new_sol, **ls_args) # mutated = PackColSolution(prob) # mutated[v] = new_sol[v] # mutated = rlf_algorithm(prob, sol=mutated) ordering = new_sol.get_greedy_order() mutated = greedy_algorithm(prob, ordering) logging.info("mutation diff: " + str(np.sum(np.equal(mutated[:], sol[:])) / prob.v_size)) return mutated
def aics_algorithm(prob, iter_count=200, random_init=True): if random_init: best_sol = greedy_algorithm(prob, random_order(prob)) else: best_sol = rlf_algorithm(prob) best_score = best_sol.get_max_col() mean_score = best_score # print(best_sol, "->", best_score) blame = best_sol[:] # print(blame, "\n") permut = np.arange(1, best_sol.get_max_col() + 1, dtype=int) permut = rd.permutation(permut) priority_seq = best_sol.get_by_permut(permut) for i in np.arange(1, iter_count + 1): # The Constructor cur_sol = greedy_algorithm(prob, priority_seq) cur_score = cur_sol.get_max_col() # print(np.round(mean_score, decimals=2), cur_score) # The Analyzer if cur_score >= np.floor(mean_score): w = [mean_score, cur_score] blame = np.average([cur_sol[:], blame], axis=0, weights=w) permut = np.arange(1, cur_sol.get_max_col() + 1, dtype=int) permut = rd.permutation(permut) priority_seq = cur_sol.get_by_permut(permut) else: if cur_score < best_score: best_sol = cur_sol best_score = best_sol.get_max_col() blame = np.average([cur_sol[:], blame], axis=0) priority_seq = np.arange(prob.v_size)[np.argsort(blame)] mean_score = (mean_score * (3. / 4)) + (cur_score * (1. / 4)) # print(np.round(blame, decimals=2), "\n") # The Prioritizer return best_sol
def crossover_permut(prob, sols): logging.info("Crossover stupid and easy") p1 = sols[0].get_greedy_order() p2 = sols[1].get_greedy_order() child_permut = p1 chrom_size = np.floor(len(child_permut) / 2) to_change = rd.choice(np.arange(prob.v_size), chrom_size, replace=False) deleted = child_permut[to_change] replacing = np.intersect1d(p2, deleted) child_permut[to_change] = replacing return greedy_algorithm(prob, child_permut)
def generate_population(prob, size, heuristic, init_args): logging.info("Init population by permut") pop = [] indiv = heuristic(prob, **init_args) permut = np.arange(1, indiv.get_max_col()+1, dtype=int) pop.append(indiv) logging.info("init candidate 0: " + str(indiv.get_max_col())) for i in range(1, size): new_permut = rd.permutation(permut) priority = indiv.get_by_permut(new_permut) pop.append(greedy_algorithm(prob, priority)) logging.info("init candidate " + str(i) + ": " + str(pop[i].get_max_col())) return pop
def crossover_cx(prob, sols): logging.info("Crossover cycle") p1 = sols[0].get_greedy_order() p2 = sols[1].get_greedy_order() child1 = np.zeros(prob.v_size, dtype=int) child2 = np.zeros(prob.v_size, dtype=int) positions = np.arange(prob.v_size, dtype=int) order1 = np.argsort(p1) inplace = p1 == p2 child1[inplace] = p1[inplace] child2[inplace] = p2[inplace] positions[inplace] = -1 cycle_nbr = 0 while np.any(positions != -1): cycle = [np.argmax(positions > -1)] while p1[cycle[0]] != p2[cycle[-1]]: step = p2[cycle[-1]] pos = order1[step] cycle.append(pos) positions[cycle] = -1 if cycle_nbr % 2 == 0: child1[cycle] = p1[cycle] child2[cycle] = p2[cycle] else: child1[cycle] = p2[cycle] child2[cycle] = p1[cycle] cycle_nbr += 1 sol1 = greedy_algorithm(prob, child1) sol2 = greedy_algorithm(prob, child2) if sol1.get_max_col() <= sol2.get_max_col(): return sol1 else: return sol2
def pertub(prob, sol, heuristic, local_search): bounds = np.zeros(prob.v_size, dtype=int) for i in range(sol.v_size): i_col = sol[i] bound = np.sum(prob.dist_matrix[i] == i_col) bounds[i] = bound v = np.argmax(bounds) adj_mat = (prob.dist_matrix == 1) changes = (prob.dist_matrix[v] == sol[v]) adj_mat[v] = changes adj_mat[..., v] = np.transpose(changes) new_prob = GraphProblem(adj_mat) new_sol = heuristic(new_prob) new_sol = local_search(new_prob, sol=new_sol, duration=5) return greedy_algorithm(prob, new_sol.get_greedy_order())
def swo_algorithm(prob, iter_count=500, blame_value=25, blame_rate=0.85, random_init=True): if random_init: priority_seq = random_order(prob) else: priority_seq = (rlf_algorithm(prob)).get_greedy_order() best_score = float("inf") best_sol = None for i in np.arange(iter_count): cur_sol = greedy_algorithm(prob, priority_seq) cur_score = cur_sol.get_max_col() # print(cur_score) if cur_score < best_score: best_sol = cur_sol.copy() best_score = best_sol.get_max_col() priority_seq = best_sol.get_greedy_order() blame_treshold = np.ceil(blame_rate * min(best_score, prob.get_diam())) b_v = blame_value + abs(cur_score - blame_treshold) blame = np.zeros(prob.v_size, dtype=int) for v in np.arange(prob.v_size): if cur_sol[v] > blame_treshold: # blame[v] += max(b_v, cur_sol.pack_size(cur_sol[v]-1)) # blame[v] += np.ceil(blame_value * (1 + (cur_sol[v] / cur_score))) blame[v] += b_v prior_blame = blame[priority_seq] order = (-prior_blame, np.arange(prob.v_size) - prior_blame) priority_seq = priority_seq[np.lexsort(order)] return best_sol