File size: 10,007 Bytes
ea8c728 | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 | // standart imports
#include <string>
#include <chrono>
#include <fstream>
#include <iomanip>
#include <iostream>
// json imports
#include "include/json.hpp"
using json = nlohmann::json;
using namespace std::chrono;
// other imports
#include "include/context.hpp"
#include "include/utils.hpp"
#include "include/random_solution.hpp"
#include "include/local_2_opt_search.hpp"
#include "include/local_k_opt_search.hpp"
// additional functions & methods
#include "include/additional.hpp"
// --- config parameters ---
// `cities_number`: number of points on the 2D surface.
// `input_path`: path to the file with cities coordinates and the edge heat map.
// `output_path`: path to the file where to write the optimal hamiltonian cycle and corresponding metrics.
// `use_heat_map_as_initial_weights`: whether to use the heat map as initial for the weights matrix.
// `candidates_source`: 'knn' or 'heat_map', if 'heat_map' the candidates for each city are the nearest cities to it.
// `candidates_number`: number of candidate cities for each city.
// `max_k_opt_depth`: maximum chain links (k parameter) in simulation.
// `random_k_opt_depth_after_first_iteration`: if to randomly change the `max_k_opt_depth` after the first iteration (restart).
// `min_potential_to_consider`: minimum potential of an edge to consider it in simulation (look at the formula for potential to understand fully).
// `exploration_coefficient`: hyperparameter for exploration.
// `weight_delta_coefficient`: hyperparameter for updating the weights matrix.
// `use_sensitivity_decrease`: whether to reduce weight flow for deep edges in unsuccessful k'opt search.
// `sensitivity_temperature`: hyperparameter for controlling the weight decrease in unsuccessful simulation depending on the length of a chain.
// `max_k_opt_simulations_without_improve_to_stop`: the number of MCTS simulations per restart.
// `restarts_number`: number of times algorithm restarts while maintaining the weights matrix (number of iterations).
// `distance_type`: "int32", "int64" or "double".
// `magnify_rate`: when `distance_type` is "int32" or "int64" algorithm relies only on integers to find an optimal solution (for speed), therefore each distance is magnified by `magnify_rate` value and rounded to integer. (if `distance_type` = 'double' this parameter is ignored)
void read_input_data(const Config& config, Context& context) {
std::ifstream input_file(config.input_path);
int cities_number; input_file >> cities_number;
// reading coordinates
for (int i = 0; i < config.cities_number; ++i) {
input_file >> context.coordinates_double_x[i] >> context.coordinates_double_y[i];
if (config.distance_type == DistanceType::Int32) {
context.coordinates_int32_x[i] = static_cast<int>(0.5 + context.coordinates_double_x[i] * config.magnify_rate);
context.coordinates_int32_y[i] = static_cast<int>(0.5 + context.coordinates_double_y[i] * config.magnify_rate);
}
if (config.distance_type == DistanceType::Int64) {
context.coordinates_int64_x[i] = static_cast<long long>(0.5 + context.coordinates_double_x[i] * config.magnify_rate);
context.coordinates_int64_y[i] = static_cast<long long>(0.5 + context.coordinates_double_y[i] * config.magnify_rate);
}
}
// calculating distances
for (int i = 0; i < config.cities_number; ++i) {
for (int j = 0; j < config.cities_number; ++j) {
context.distance_double[i * config.cities_number + j] = calc_distance_double(context, i, j);
if (config.distance_type == DistanceType::Int32) {
context.distance_int32[i * config.cities_number + j] = calc_distance_int32(context, i, j);
}
if (config.distance_type == DistanceType::Int64) {
context.distance_int64[i * config.cities_number + j] = calc_distance_int64(context, i, j);
}
}
}
if (config.use_heat_map_as_initial_weights) {
// reading heat map
for (int i = 0; i < config.cities_number * config.cities_number; ++i) {
input_file >> context.heat_map[i];
context.weight[i] = context.heat_map[i];
}
} else {
for (int i = 0; i < config.cities_number * config.cities_number; ++i) {
context.weight[i] = 0.0;
}
}
// initializing total weight
for (int i = 0; i < config.cities_number; ++i) {
double total_weight = 0.0;
for (int j = 0; j < config.cities_number; ++j) {
total_weight += smooth_relu(context.weight[i * config.cities_number + j]);
}
context.total_weight[i] = total_weight;
}
// calculating candidates
if (config.candidates_source == CandidatesSource::KNN) {
identify_candidates_for_each_node(config, context, context.distance_double, false);
} else if (config.candidates_source == CandidatesSource::HeatMap) {
identify_candidates_for_each_node(config, context, context.heat_map, true);
} else {
throw std::invalid_argument("Unknown candidates source.");
}
}
void solve(const Config& config, Context& context) { // the found solution will be stored in context.solution
// initialization
std::chrono::time_point<std::chrono::high_resolution_clock> start_total_time = high_resolution_clock::now(), end_total_time;
std::chrono::time_point<std::chrono::high_resolution_clock> start_time, end_time;
int max_k_opt_depth = config.max_k_opt_depth;
for (int i = 1; i < config.restarts_number + 1; ++i) { // maybe add some stopping criteria (with BHH 2D constant for example)
if (i % 100 == 0) { std::cout << "# --------- Iteration: " << i << '\n'; }
int improved_times = 0;
// random solution
start_time = high_resolution_clock::now();
generate_random_solution(config, context);
convert_solution_to_path(config, context);
end_time = high_resolution_clock::now();
calc_and_save_total_distance(config, context);
if (config.distance_type != DistanceType::Double) {
context.path_distance_double = calc_total_distance_double(config, context);
}
if (i % 100 == 0) { std::cout << std::setprecision(8) << "Phase #1 (random cycle). Total distance: " << context.path_distance_double << ", Time: " << duration_cast<milliseconds>(end_time - start_time).count() << " ms\n"; }
// local 2opt search
start_time = high_resolution_clock::now();
improved_times = local_2_opt_search(config, context);
end_time = high_resolution_clock::now();
if (config.distance_type != DistanceType::Double) {
context.path_distance_double = calc_total_distance_double(config, context);
}
if (i % 100 == 0) { std::cout << std::setprecision(8) << "Phase #2 (local 2'opt search). Total distance: " << context.path_distance_double << ", Improved times: " << improved_times << ", Time: " << duration_cast<milliseconds>(end_time - start_time).count() << " ms\n"; }
// local k opt search
start_time = high_resolution_clock::now();
improved_times = local_k_opt_search(config, context, max_k_opt_depth);
end_time = high_resolution_clock::now();
if (config.distance_type != DistanceType::Double) {
context.path_distance_double = calc_total_distance_double(config, context);
}
if (i % 100 == 0) { std::cout << std::setprecision(8) << "Phase #3 (local k'opt search). Total distance: " << context.path_distance_double << ", Improved times: " << improved_times << ", Time: " << duration_cast<milliseconds>(end_time - start_time).count() << " ms\n"; }
// changing the best path
if (
(config.distance_type == DistanceType::Double && context.path_distance_double < context.best_path_distance_double) ||
(config.distance_type == DistanceType::Int32 && context.path_distance_int32 < context.best_path_distance_int32) ||
(config.distance_type == DistanceType::Int64 && context.path_distance_int64 < context.best_path_distance_int64)
) {
store_path_as_best(config, context); // also updates best path distance
}
if (config.random_k_opt_depth_after_first_iteration) {
// random MCTS depth change
max_k_opt_depth = std::min(10 + (rand() % 80), config.cities_number / 2);
}
if (i % 100 == 0) { std::cout << '\n'; }
}
// final convertation (context.best_path to context.solution)
restore_best_path(config, context);
convert_path_to_solution(config, context);
end_total_time = high_resolution_clock::now();
std::cout << "Total elapsed time: " << static_cast<double>(duration_cast<milliseconds>(end_total_time - start_total_time).count()) / 1000 << " sec\n\n";
}
int main(int argc, char** argv) {
// reading configuration
std::cout << "Reading configuration...\n";
if (argc != 2) {
std::cerr << "Usage: The first and only argument should be the path to the config file.";
return 1;
}
std::ifstream config_file(argv[1]);
json config_raw; config_file >> config_raw;
Config config(config_raw);
std::cout << "Number of cities: " << config.cities_number << "\n\n";
// initialization & memory allocation
Context context(config);
// reading input data
std::cout << "Reading input data...\n";
read_input_data(config, context);
// solving
std::cout << "Solving...\n";
solve(config, context);
// printing the solution
std::ofstream output_file(config.output_path);
std::cout << "Final solution:\n";
for (int i = 0; i < config.cities_number; ++i) {
std::cout << context.solution[i] << ' ';
output_file << context.solution[i] << ' ';
}
std::cout << "\n\nFinal solution score: " << calc_total_distance_double(config, context) << '\n';
return 0;
}
|