def run_measurements(data, dist_matrix, neighbourhood, steps_for_time_measurements=1, method="none"): dist_1 = np.copy(dist_matrix) costs_greedy = [] times_measurements = [] best_cost = 1000 best_clusters = [] clusters = None # draw_scatter(data, clusters, False) np.random.seed(0) for i in range(steps_for_time_measurements): clusters = random_groups(data.shape[0]) measurement = time_measure(run_algorithm, (clusters, dist_1, neighbourhood, method)) times_measurements.append(measurement) cost = sum(count_costs(clusters, dist_1, 20)) / 20 # print("Koszt dla iteracji " + str(i) + ": " + str(cost)) if cost < best_cost: best_cost = cost best_clusters = clusters costs_greedy.append(cost) # draw_scatter(data, clusters, True) print( f"Najmniejszy koszt dla lokalnego przeszukiwania w wersji stromej ({method}) wynosi {min(costs_greedy)}, " f"największy {max(costs_greedy)}, średni {sum(costs_greedy)/len(costs_greedy)}." ) print( f"Pomiary czasu dla {steps_for_time_measurements} kroków dla algorytmu stromej to " f"min: {min(times_measurements)} sekund, max: {max(times_measurements)} sekund i " f"avg: {sum(times_measurements) / len(times_measurements)} sekund.\n") draw_scatter(data, best_clusters, True)
def run_measurements(data, dist_matrix, neighbourhood_radius, steps_for_time_measurements=50, option="prim"): greedy_times_measurements = [] steepest_times_measurements = [] greedy_measurements = [] steepest_measurements = [] dist = np.copy(dist_matrix) best_greedy = 10000 best_clusters_greedy = [] best_steepest = 10000 best_clusters_steepest = [] costs_greedy = [] costs_steepest = [] clusters_before_greedy = [] clusters_before_steepest = [] for i in range(steps_for_time_measurements): clusters = np.ones(len(data), dtype=np.int32) * (-1) if option == "prim": result = create_n_trees_prim(data, dist_matrix, 20, 1) clusters = create_clusters_from_tree(data, result) elif option == "kruskal": result = create_n_trees_kruskal(data, dist_matrix, 20, 1) clusters = create_clusters_from_tree(data, result) elif option == "random": clusters = random_groups(data.shape[0]) greedy_clusters = np.copy(clusters) steepest_clusters = np.copy(clusters) measurement = time_measure(run_algorithm_greedy, (greedy_clusters, dist, neighbourhood_radius)) greedy_times_measurements.append(measurement) greedy_cost = cost_function(dist_matrix, greedy_clusters)[0] greedy_measurements.append(greedy_cost) costs_greedy.append(greedy_cost) if greedy_cost < best_greedy: best_greedy = greedy_cost best_clusters_greedy = greedy_clusters clusters_before_greedy = clusters measurement = time_measure(run_algorithm_steepest, (steepest_clusters, dist, neighbourhood_radius)) steepest_times_measurements.append(measurement) steepest_cost = cost_function(dist_matrix, steepest_clusters)[0] steepest_measurements.append(steepest_cost) costs_steepest.append(steepest_cost) if steepest_cost < best_steepest: best_steepest = steepest_cost best_clusters_steepest = steepest_clusters clusters_before_steepest = clusters print(f"Greedy cost min:{min(greedy_measurements)}, max:{max(greedy_measurements)}, avg: {sum(greedy_measurements) / len(greedy_measurements)}") print(f"Greedy Time min:{min(greedy_times_measurements)}, max:{max(greedy_times_measurements)}, avg: {sum(greedy_times_measurements) / len(greedy_times_measurements)}") print(f"Steepest cost min:{min(steepest_measurements)}, max:{max(steepest_measurements)}, avg: {sum(steepest_measurements) / len(steepest_measurements)}") print(f"Steepest Time min:{min(steepest_times_measurements)}, max:{max(steepest_times_measurements)}, avg: {sum(steepest_times_measurements) / len(steepest_times_measurements)}") draw_scatter(data, best_clusters_greedy, True) draw_scatter(data, best_clusters_steepest, True) draw_scatter(data, clusters_before_greedy, False) draw_scatter(data, clusters_before_steepest, False)
def run_measurements_msls(data, dist_matrix, neighbourhood=50, steps_for_time_measurements=1, option="random", candidates=False, cache=True): dist = np.copy(dist_matrix) msls_times_measurements = [] msls_costs = [] ils_big_costs = [] ils_small_costs = [] evo_costs = [] for i in range(steps_for_time_measurements): print(f"CURRENT ITERATION: {i}") clusters = random_groups(data.shape[0]) print("MSLS...") time_limit, ret = time_measure(msls, (dist, neighbourhood, data, candidates, cache, option)) msls_times_measurements.append(time_limit) local_optimums = ret[0] local_optimums_costs = ret[1] msls_costs.append(np.max(local_optimums_costs)) print("ILS with small perturbation...") ret_small = ils(dist, neighbourhood, data, time_limit, candidates, cache, option, "small") ils_small_costs.append(ret_small[0]) print("ILS with big perturbation...") ret_big = ils(dist, neighbourhood, data, time_limit, candidates, cache, option, "big") ils_big_costs.append(ret_big[0]) print("Evolution algorithm...") ret_evo = evolutionary(dist, neighbourhood, local_optimums, local_optimums_costs, time_limit) evo_costs.append(np.max(ret_evo[1])) # similarities, avg_similarities = count_similarity(local_optimums, local_optimums_costs) # draw_similarity(similarities, avg_similarities, local_optimums_costs) # cor_coef = pearsonr(local_optimums_costs, similarities)[0] # cor_coef2 = pearsonr(local_optimums_costs, avg_similarities)[0] # print(f"Współczynnik koleracji podobieństwa względem najlepszego optimum lokalnego: {cor_coef}") # print(f"Współczynnik koleracji średniego podobieństwa względem pozostałych optimów lokalnych: {cor_coef2}") print(f"MSLS COST min:{min(msls_costs)}, max:{max(msls_costs)}, avg: {sum(msls_costs) / len(msls_costs)}") print(f"ILS with small perturbations COST min:{min(ils_small_costs)}, max:{max(ils_small_costs)}, avg: " f"{sum(ils_small_costs) / len(ils_small_costs)}") print(f"ILS with big perturbations COST min:{min(ils_big_costs)}, max:" f"{max(ils_big_costs)}, avg: {sum(ils_big_costs) / len(ils_big_costs)}") print(f"Evolutionary algorithm COST min:{min(evo_costs)}, max:" f"{max(evo_costs)}, avg: {sum(evo_costs) / len(evo_costs)}") draw_scatter(data, ret_evo[0][np.argmax(ret_evo[1])], True)
def run_measurements(data, dist_matrix, neighbourhood_radius, steps_for_time_measurements=50, option="prim"): steepest_times_measurements = [] steepest_measurements = [] dist = np.copy(dist_matrix) cache_times_measurements = [] cache_measurements = [] candidates_times_measurements = [] candidates_measurements = [] candidates_cache_times_measurements = [] candidates_cache_measurements = [] best_steepest = np.inf best_clusters_steepest = None best_cache = np.inf best_clusters_cache = None best_candidates = np.inf best_candidates_clusters = None best_candidates_cache = np.inf best_candidates_cache_clusters = None clusters_before_steepest = None clusters_before_cache = None clusters_before_candidates = None clusters_before_candidates_cache = None for i in range(steps_for_time_measurements): clusters = np.ones(len(data), dtype=np.int32) * (-1) if option == "prim": result = create_n_trees_prim(data, dist_matrix, 20, 1) clusters = create_clusters_from_tree(data, result) elif option == "kruskal": result = create_n_trees_kruskal(data, dist_matrix, 20, 1) clusters = create_clusters_from_tree(data, result) elif option == "random": clusters = random_groups(data.shape[0]) steepest_clusters = np.copy(clusters) cache_cluster = np.copy(clusters) candidates_cluster = np.copy(clusters) candidates_cache_cluster = np.copy(clusters) measurement = time_measure( run_algorithm_steepest, (steepest_clusters, dist, neighbourhood_radius, False, False)) steepest_times_measurements.append(measurement) steepest_cost = cost_function(dist_matrix, steepest_clusters)[0] steepest_measurements.append(steepest_cost) measurement = time_measure( run_algorithm_steepest, (cache_cluster, dist, neighbourhood_radius, False, True)) cache_times_measurements.append(measurement) cache_cost = cost_function(dist_matrix, steepest_clusters)[0] cache_measurements.append(cache_cost) measurement = time_measure( run_algorithm_steepest, (candidates_cluster, dist, neighbourhood_radius, True, False)) candidates_times_measurements.append(measurement) candidates_cost = cost_function(dist_matrix, candidates_cluster)[0] candidates_measurements.append(candidates_cost) measurement = time_measure(run_algorithm_steepest, (candidates_cache_cluster, dist, neighbourhood_radius, True, False)) candidates_cache_times_measurements.append(measurement) candidates_cache_cost = cost_function(dist_matrix, candidates_cache_cluster)[0] candidates_cache_measurements.append(candidates_cache_cost) if steepest_cost < best_steepest: best_steepest = steepest_cost best_clusters_steepest = steepest_clusters clusters_before_steepest = clusters if cache_cost < best_cache: best_cache = cache_cost best_clusters_cache = cache_cluster clusters_before_cache = clusters if candidates_cost < best_candidates: best_candidates = candidates_cost best_candidates_clusters = candidates_cluster clusters_before_candidates = clusters if candidates_cache_cost < best_candidates_cache: best_candidates_cache = candidates_cache_cost best_candidates_cache_clusters = candidates_cache_cluster clusters_before_candidates_cache = clusters print( f"Steepest cost min:{min(steepest_measurements)}, max:{max(steepest_measurements)}, avg: {sum(steepest_measurements) / len(steepest_measurements)}" ) print( f"Steepest time min:{min(steepest_times_measurements)}, max:{max(steepest_times_measurements)}, avg: {sum(steepest_times_measurements) / len(steepest_times_measurements)}" ) print( f"Cache steepest cost min:{min(cache_measurements)}, max:{max(cache_measurements)}, avg: {sum(cache_measurements) / len(cache_measurements)}" ) print( f"Cache steepest time min:{min(cache_times_measurements)}, max:{max(cache_times_measurements)}, avg: {sum(cache_times_measurements) / len(cache_times_measurements)}" ) print( f"Candidates steepest cost min:{min(candidates_measurements)}, max:{max(candidates_measurements)}, avg: {sum(candidates_measurements) / len(candidates_measurements)}" ) print( f"Candidates steepest time min:{min(candidates_times_measurements)}, max:{max(candidates_times_measurements)}, avg: {sum(candidates_times_measurements) / len(candidates_times_measurements)}" ) print( f"Candidates and cache steepest cost min:{min(candidates_cache_measurements)}, max:{max(candidates_cache_measurements)}, " f"avg: {sum(candidates_cache_measurements) / len(candidates_cache_measurements)}" ) print( f"Candidates and cache steepest time min:{min(candidates_cache_times_measurements)}, " f"max:{max(candidates_cache_times_measurements)}, " f"avg: {sum(candidates_cache_times_measurements) / len(candidates_cache_times_measurements)}" ) draw_scatter(data, best_clusters_steepest, True) draw_scatter(data, clusters_before_steepest, False) draw_scatter(data, best_clusters_cache, True) draw_scatter(data, clusters_before_cache, False) draw_scatter(data, best_candidates_clusters, True) draw_scatter(data, clusters_before_candidates, False) draw_scatter(data, best_candidates_cache_clusters, True) draw_scatter(data, clusters_before_candidates_cache, False)
def run_measurements_msls(data, dist_matrix, neighbourhood_radius, steps_for_time_measurements=1, option="random", neighbourhood=50, candidates=False, cache=True): msls_times_measurements = [] msls_measurements = [] dist = np.copy(dist_matrix) best_clusters = None ils_best_clusters = None clusters_before_best = None ils_clusters_before_best = None ils_times_measurements = [] ils_measurements = [] ils_big_best_clusters = None ils_big_clusters_before_best = None ils_big_times_measurements = [] ils_big_measurements = [] for i in range(steps_for_time_measurements): print(f"Aktualna iteracja to {steps_for_time_measurements}") time_measurement, ret = time_measure( msls, (dist, neighbourhood, data, candidates, cache, option)) cost, best_clusters, clusters_before_best = ret msls_times_measurements.append(time_measurement) msls_measurements.append(cost) ils_time_limit = sum(msls_times_measurements) / len(msls_measurements) ils_time_measurement, ret = \ time_measure(ils, (dist, neighbourhood, data, ils_time_limit, candidates, cache, option, "small")) ils_cost, ils_best_clusters, ils_clusters_before_best = ret ils_times_measurements.append(ils_time_measurement) ils_measurements.append(ils_cost) ils_big_time_measurement, big_ret = \ time_measure(ils, (dist, neighbourhood, data, ils_time_limit, candidates, cache, option, "big")) ils_big_cost, ils_big_best_clusters, ils_big_clusters_before_best = big_ret ils_big_times_measurements.append(ils_big_time_measurement) ils_big_measurements.append(ils_big_cost) print( f"MSLS COST min:{min(msls_measurements)}, max:{max(msls_measurements)}, avg: {sum(msls_measurements) / len(msls_measurements)}" ) print( f"MSLS TIME min:{min(msls_times_measurements)}, max:{max(msls_times_measurements)}, avg: {sum(msls_times_measurements) / len(msls_times_measurements)}" ) print( f"ILS with small perturbations COST min:{min(ils_measurements)}, max:{max(ils_measurements)}, avg: {sum(ils_measurements) / len(ils_measurements)}" ) print( f"ILS with small perturbations TIME min:{min(ils_times_measurements)}, max:{max(ils_times_measurements)}, avg: {sum(ils_times_measurements) / len(ils_times_measurements)}" ) print( f"ILS with big perturbations COST min:{min(ils_big_measurements)}, max:{max(ils_big_measurements)}, avg: {sum(ils_big_measurements) / len(ils_big_measurements)}" ) print( f"ILS with big perturbations TIME min:{min(ils_big_times_measurements)}, max:{max(ils_big_times_measurements)}, avg: {sum(ils_big_times_measurements) / len(ils_big_times_measurements)}" ) draw_scatter(data, best_clusters, True) draw_scatter(data, clusters_before_best, False) draw_scatter(data, ils_best_clusters, True) draw_scatter(data, ils_clusters_before_best, False) draw_scatter(data, ils_big_best_clusters, True) draw_scatter(data, ils_big_clusters_before_best, False)
def run_measurements(data, dist_matrix, neighbourhood, steps_for_time_measurements=1, option="prim"): times_measurements = [] times_measurements_2 = [] dist_1 = np.copy(dist_matrix) dist_2 = np.copy(dist_matrix) best_greedy = 10000 best_clusters_greedy = [] best_steepest = 10000 best_clusters_steepest = [] costs_greedy = [] costs_steepest = [] clusters_before_greedy = [] clusters_before_steepest = [] for i in range(steps_for_time_measurements): clusters = np.ones(len(data), dtype=np.int32) * (-1) if option == "prim": result = create_n_trees_prim(data, dist_matrix, 20, 1) clusters = create_clusters_from_tree(data, result) elif option == "kruskal": result = create_n_trees_kruskal(data, dist_matrix, 20, 1) clusters = create_clusters_from_tree(data, result) elif option == "random": clusters = random_groups(data.shape[0]) clusters_2 = np.copy(clusters) clusters_before = np.copy(clusters) measurement = time_measure(run_algorithm, (clusters, dist_1, neighbourhood, "greedy")) times_measurements.append(measurement) measurement2 = time_measure( run_algorithm, (clusters_2, dist_2, neighbourhood, "steepest")) times_measurements_2.append(measurement2) cost = sum(count_costs(clusters, dist_1, 20)) / 20 cost2 = sum(count_costs(clusters_2, dist_2, 20)) / 20 costs_greedy.append(cost) costs_steepest.append(cost2) if cost < best_greedy: best_greedy = cost best_clusters_greedy = clusters clusters_before_greedy = clusters_before if cost2 < best_steepest: best_steepest = cost2 best_clusters_steepest = clusters_2 clusters_before_steepest = clusters_before print(option) print(np.max(best_clusters_steepest)) print(np.max(best_clusters_greedy)) print( f"Najmniejszy koszt dla lokalnego przeszukiwania w wersji zachłannej dla wstępnych danych {option} wynosi {min(costs_greedy)}, " f"największy {max(costs_greedy)}, średni {sum(costs_greedy)/len(costs_greedy)}.\n" f"Najmniejszt koszt dla lokalnego przeszukiwania w wersji stromej wynosi {min(costs_steepest)}, " f"największy {max(costs_steepest)}, średni {sum(costs_steepest)/len(costs_steepest)}." ) print( f"Pomiary czasu dla {steps_for_time_measurements} kroków dla algorytmu greedy to " f"min: {min(times_measurements)} sekund, max: {max(times_measurements)} sekund i " f"avg: {sum(times_measurements) / len(times_measurements)} sekund") print( f"Pomiary czasu dla {steps_for_time_measurements} kroków dla algorytmu steepest to " f"min: {min(times_measurements_2)} sekund, max: {max(times_measurements_2)} sekund i " f"avg: {sum(times_measurements_2) / len(times_measurements_2)} sekund") draw_scatter(data, best_clusters_greedy, True) draw_scatter(data, best_clusters_steepest, True) draw_scatter(data, clusters_before_greedy, False) draw_scatter(data, clusters_before_steepest, False)