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)