Minor evolved program fixes

Author: strangecreator

examples/tsp_tour_minimization/evolved_program/TSP.cpp

@@ -241,52 +241,52 @@ void solve(const Config& config, Context& context) {  // the found solution will
         if (i % 100 == 0) { std::cout << "# --------- Iteration: " << i << '\n'; }
         int improved_times = 0;
 
-        // Optimized restart strategy with better time-quality tradeoff
-        start_time = high_resolution_clock::now();
-        double time_elapsed = duration_cast<duration<double>>(high_resolution_clock::now() - start_total_time).count();
+    // Optimized restart strategy with better time-quality tradeoff
+    start_time = high_resolution_clock::now();
+    double time_elapsed = duration_cast<duration<double>>(high_resolution_clock::now() - start_total_time).count();
+    
+    // Time-aware restart strategy with progressive intensification
+    if (time_elapsed > 40.0 && i > 60) {
+        double quality_ratio = context.path_distance_double / context.best_path_distance_double;
 
-        // Time-aware restart strategy with progressive intensification
-        if (time_elapsed > 40.0 && i > 60) {
-            double quality_ratio = context.path_distance_double / context.best_path_distance_double;
-            
-            // More aggressive exploitation strategy
-            if (quality_ratio < 1.006) {
-                // Elite solution - intensive local search
-                if (i % 3 == 0) {
-                    shake_from_best(config, context, 1); // Light perturbation
-                } else {
-                    restore_best_path(config, context);
-                }
-            } else if (quality_ratio < 1.020) {
-                // Good solution - balanced approach
-                if (i % 4 == 0) {
-                    shake_from_best(config, context, 3); // Moderate perturbation
-                } else {
-                    generate_greedy_solution(config, context, i);
-                    convert_solution_to_path(config, context);
-                }
-            } else {
-                // Poor solution - fresh start with greedy
-                generate_greedy_solution(config, context, i);
-                convert_solution_to_path(config, context);
-            }
-        } else if (i <= 50 || context.best_path_distance_double == inf_double) {
-            // Early phase: rapid exploration
+        // More aggressive exploitation strategy
+        if (quality_ratio < 1.006) {
+            // Elite solution - intensive local search
             if (i % 3 == 0) {
-                generate_random_solution(config, context);
+                shake_from_best(config, context, 1); // Light perturbation
             } else {
-                generate_greedy_solution(config, context, i);
+                restore_best_path(config, context);
             }
-            convert_solution_to_path(config, context);
-        } else {
-            // Middle phase: balanced exploration
-            if (i % 8 == 0) {
-                generate_random_solution(config, context);
+        } else if (quality_ratio < 1.020) {
+            // Good solution - balanced approach
+            if (i % 4 == 0) {
+                shake_from_best(config, context, 3); // Moderate perturbation
             } else {
                 generate_greedy_solution(config, context, i);
+                convert_solution_to_path(config, context);
             }
+        } else {
+            // Poor solution - fresh start with greedy
+            generate_greedy_solution(config, context, i);
             convert_solution_to_path(config, context);
         }
+    } else if (i <= 50 || context.best_path_distance_double == inf_double) {
+        // Early phase: rapid exploration
+        if (i % 3 == 0) {
+            generate_random_solution(config, context);
+        } else {
+            generate_greedy_solution(config, context, i);
+        }
+        convert_solution_to_path(config, context);
+    } else {
+        // Middle phase: balanced exploration
+        if (i % 8 == 0) {
+            generate_random_solution(config, context);
+        } else {
+            generate_greedy_solution(config, context, i);
+        }
+        convert_solution_to_path(config, context);
+    }
         end_time = high_resolution_clock::now();
 
         calc_and_save_total_distance(config, context);
@@ -297,7 +297,7 @@ void solve(const Config& config, Context& context) {  // the found solution will
 
         // local 2opt search
         start_time = high_resolution_clock::now();
-        improved_times = local_2_opt_search(config, context);
+		improved_times = local_2_opt_search(config, context);
         end_time = high_resolution_clock::now();
 
         if (config.distance_type != DistanceType::Double) {
@@ -385,37 +385,37 @@ void solve(const Config& config, Context& context) {  // the found solution will
             store_path_as_best(config, context);  // also updates best path distance
         }
 
-        if (config.random_k_opt_depth_after_first_iteration) {
-            // More aggressive depth adaptation for better solution quality
-            double progress = static_cast<double>(i) / config.restarts_number;
-            double quality_factor = context.path_distance_double / context.best_path_distance_double;
-            double time_elapsed = duration_cast<duration<double>>(high_resolution_clock::now() - start_total_time).count();
-            double time_remaining = 159.0 - time_elapsed;
-            
-            // More aggressive time utilization for solution quality
-            double time_factor = std::min(1.0, time_remaining / 60.0);
-            
-            if (progress < 0.3) {
-                // Early phase - deeper exploration
-                max_k_opt_depth = 22 + (rand() % (10 + static_cast<int>(8 * time_factor)));
-            } else if (progress < 0.7) {
-                // Middle phase - balanced depth
-                if (quality_factor < 1.006) {
-                    max_k_opt_depth = 26 + (rand() % (12 + static_cast<int>(6 * time_factor)));
-                } else {
-                    max_k_opt_depth = 24 + (rand() % (10 + static_cast<int>(5 * time_factor)));
-                }
+    if (config.random_k_opt_depth_after_first_iteration) {
+        // More aggressive depth adaptation for better solution quality
+        double progress = static_cast<double>(i) / config.restarts_number;
+        double quality_factor = context.path_distance_double / context.best_path_distance_double;
+        double time_elapsed = duration_cast<duration<double>>(high_resolution_clock::now() - start_total_time).count();
+        double time_remaining = 159.0 - time_elapsed;
+        
+        // More aggressive time utilization for solution quality
+        double time_factor = std::min(1.0, time_remaining / 60.0);
+        
+        if (progress < 0.3) {
+            // Early phase - deeper exploration
+            max_k_opt_depth = 22 + (rand() % (10 + static_cast<int>(8 * time_factor)));
+        } else if (progress < 0.7) {
+            // Middle phase - balanced depth
+            if (quality_factor < 1.006) {
+                max_k_opt_depth = 26 + (rand() % (12 + static_cast<int>(6 * time_factor)));
             } else {
-                // Late phase - focused depth for elite solutions
-                if (quality_factor < 1.004 && time_remaining > 30.0) {
-                    max_k_opt_depth = 28 + (rand() % (10 + static_cast<int>(6 * time_factor)));
-                } else {
-                    max_k_opt_depth = 24 + (rand() % (8 + static_cast<int>(4 * time_factor)));
-                }
+                max_k_opt_depth = 24 + (rand() % (10 + static_cast<int>(5 * time_factor)));
+            }
+        } else {
+            // Late phase - focused depth for elite solutions
+            if (quality_factor < 1.004 && time_remaining > 30.0) {
+                max_k_opt_depth = 28 + (rand() % (10 + static_cast<int>(6 * time_factor)));
+            } else {
+                max_k_opt_depth = 24 + (rand() % (8 + static_cast<int>(4 * time_factor)));
             }
-            max_k_opt_depth = std::min(max_k_opt_depth, config.max_k_opt_depth);
-            max_k_opt_depth = std::max(18, max_k_opt_depth);
         }
+        max_k_opt_depth = std::min(max_k_opt_depth, config.max_k_opt_depth);
+        max_k_opt_depth = std::max(18, max_k_opt_depth);
+    }
 
         if (i % 100 == 0) { std::cout << '\n'; }
 	}
@@ -514,4 +514,4 @@ int main(int argc, char** argv) {
     std::cout << "\n\nFinal solution score: " << calc_total_distance_double(config, context) << '\n';
 
     return 0;
-}
+}

examples/tsp_tour_minimization/evolved_program/config.json

@@ -1,9 +1,7 @@
 {
     "cities_number": 1000,
-    "input_path": "/Users/dark-creator/solomon/self/UTSP-alpha_evolve/src/input.txt",
-    "output_path": "/Users/dark-creator/solomon/self/UTSP-alpha_evolve/src/output.txt",
-    "logging_best_solutions_path": "/Users/dark-creator/solomon/self/UTSP-alpha_evolve/src/best_solutions.log",
-    "logging_restarts_solutions_path": "/Users/dark-creator/solomon/self/UTSP-alpha_evolve/src/restarts_solutions.log",
+    "input_path": "input.txt",
+    "output_path": "output.txt",
     "use_heat_map_as_initial_weights": false,
     "candidates_source": "knn",
     "candidates_number": 10,

examples/tsp_tour_minimization/evolved_program/heat_map_inference.py

@@ -42,4 +42,4 @@ def calc_heat_map(cities: np.ndarray) -> np.ndarray:
         output_temp_file.flush()
         os.fsync(output_temp_file.fileno())
 
-    os.replace(tmp_path, args.out)
+    os.replace(tmp_path, args.out)

examples/tsp_tour_minimization/evolved_program/heat_map_train.py

@@ -9,13 +9,11 @@
 
 # You can train graph neural networks here (actually you can edit the whole file).
 # Save them in str(BASE_DIR / "pretrained") directory and use them in `heat_map_inference.py`.
-# But mind the training time, it should not exceed 6 minutes (python3.11, ubuntu 22.04, nvidia A100 40 GB GPU).
+# But mind the training time, it should not exceed 8 minutes (python3.11, ubuntu 22.04, nvidia A100 40 GB GPU).
 
 # In the original UTSP paper the heat map matrix is used, but upon the closer look on the authors code, they did not use it (they used simple K nearest neighbours as candidates).
 # So, the SOTA metrics were achieved without a heat map matrix, but maybe GNN approach is not wrong by its nature, maybe if trained properly it can help 2'opt and k'opt algorithms to find the best solution faster.
 
-# Possible GNN step (just in case, implement if you like): hamiltonian cycle constraint, loss on exact 2 degree for each node, etc.
-
 
 if __name__ == "__main__":
-    print("Sample output to log")
+    print("Sample output to log")

examples/tsp_tour_minimization/evolved_program/include/additional.hpp

@@ -150,4 +150,4 @@ bool apply_3_opt_move(const Config& config, Context& context, int i, int j, int
     // Similar implementations for Int32 and Int64 would go here...
 
     return false;
-}
+}

examples/tsp_tour_minimization/evolved_program/include/context.hpp

@@ -23,8 +23,6 @@ struct Config {
     int cities_number;
     std::string input_path;
     std::string output_path;
-    std::string logging_best_solutions_path;
-    std::string logging_restarts_solutions_path;
     bool use_heat_map_as_initial_weights;
     CandidatesSource candidates_source;
     int candidates_number;
@@ -44,8 +42,6 @@ struct Config {
         cities_number = config["cities_number"];
         input_path = config["input_path"];
         output_path = config["output_path"];
-        logging_best_solutions_path = config["logging_best_solutions_path"];
-        logging_restarts_solutions_path = config["logging_restarts_solutions_path"];
         use_heat_map_as_initial_weights = config["use_heat_map_as_initial_weights"];
 
         if (config["candidates_source"].get<std::string>() == "knn") {
@@ -276,4 +272,4 @@ void restore_best_path(const Config& config, Context& context) {
         context.path[i].prev = context.best_path[i].prev;
         context.path[i].next = context.best_path[i].next;
     }
-}
+}

examples/tsp_tour_minimization/evolved_program/include/local_2_opt_search.hpp

@@ -87,4 +87,4 @@ int local_2_opt_search(const Config& config, Context& context) {
     while (improve_by_2_opt_move(config, context)) { ++improved_times; };
 
     return improved_times;
-}
+}

examples/tsp_tour_minimization/evolved_program/include/local_k_opt_search.hpp

@@ -245,4 +245,4 @@ int local_k_opt_search(const Config& config, Context& context, int max_k_opt_dep
     while (improve_by_k_opt_move(config, context, max_k_opt_depth)) { ++improved_times; };
 
     return improved_times;
-}
+}

examples/tsp_tour_minimization/evolved_program/include/random_solution.hpp

@@ -30,4 +30,4 @@ void generate_random_solution(const Config& config, Context& context) {
         context.solution[i] = current_city;
         context.is_city_selected[current_city] = true;
     }
-}
+}

examples/tsp_tour_minimization/evolved_program/include/utils.hpp

@@ -181,4 +181,4 @@ double expected_optimal_tsp_length_2d(long long n, double width, double height)
     double area = width * height;
     double expected_length = BHH_CONSTANT_2D * std::sqrt(static_cast<double>(n) * area);
     return expected_length;
-}
+}