v0.1.2 Simulated Annealing

Author: CameleoGrey

README.md

@@ -14,7 +14,7 @@ There are 2 editions of GreyJack Solver:
 - Python edition
 - [Rust edition](https://github.com/CameleoGrey/greyjack-solver-rust)
 
-# Key Features of GreyJack Solver (Rust version)
+# Key Features of GreyJack Solver
 
 - **Unmatched Comfort, Expressiveness, Flexibility and speed of developing** Designed to express almost any optimization problem with maximum comfortability and clarity.
 - **Universality** Supports a wide range of constraint problems, including continuous, integer, and mixed-integer challenges. Additionally, thanks to Polars, you can optimize virtually any process that can be represented as table data.
@@ -24,7 +24,7 @@ There are 2 editions of GreyJack Solver:
 - **Support for Population and Local Search Algorithms** GreyJack Solver supports a wide range of metaheuristics, including population-based and local search algorithms, with highly flexible settings. You can easily find, select, and configure the approach that best fits your problem, delivering optimal results.
 - **Easy Integration**  The observer mechanism (see examples) simplifies integration, making it straightforward to incorporate GreyJack Solver into your existing workflows..
 
-# Get started with GreyJack Solver in Rust
+# Get started with GreyJack Solver
 
 ```
 pip install greyjack
@@ -45,7 +45,6 @@ maturin develop --release
 
 # RoadMap
 
-- SimulatedAnnealing
 - API for modelling pure math problems (classic solvers like)
 - Modern variations (modifications) of LSHADE (Differential evolution algorithms often appear in articles as sota approaches)
 - CMA, probably its modern variants, adaptations for tasks with integer and categorical variables (often appears in articles as sota approach)

examples/object_oriented/nqueens/score/PlainScoreCalculatorNQueens.py

@@ -39,7 +39,7 @@ def all_different(self, planning_entity_dfs, problem_fact_dfs):
             )
             .with_columns((pl.col("row_conflicts_count") + pl.col("desc_conflicts_count") + pl.col("asc_conflicts_count")).alias("sum_conflicts"))
             .sort("sample_id")
-            .collect()
+            .collect() # you can use engine="gpu" on Linux or by WSL
         )
 
         scores = same_row_id_counts["sum_conflicts"].to_list()

examples/object_oriented/nqueens/scripts/solve_nqueens.py

@@ -15,32 +15,33 @@
 from greyjack.Solver import Solver
 from greyjack.agents.base.LoggingLevel import LoggingLevel
 from greyjack.agents.base.ParallelizationBackend import ParallelizationBackend
-from greyjack.agents.TabuSearch import TabuSearch
-from greyjack.agents.GeneticAlgorithm import GeneticAlgorithm
-from greyjack.agents.LateAcceptance import LateAcceptance
+from greyjack.agents import *
 
 if __name__ == "__main__":
 
     # build domain model
-    domain_builder = DomainBuilderNQueens(1024, random_seed=45)
+    domain_builder = DomainBuilderNQueens(10000, random_seed=45)
     cotwin_builder = CotwinBuilderNQueens(use_incremental_score_calculator=True)
 
     #termination_strategy = StepsLimit(step_count_limit=1000)
-    #termination_strategy = TimeSpentLimit(time_seconds_limit=60)
+    termination_strategy = TimeSpentLimit(time_seconds_limit=60)
     #termination_strategy = ScoreNoImprovement(time_seconds_limit=15)
-    termination_strategy = ScoreLimit(score_to_compare=[0])
+    #termination_strategy = ScoreLimit(score_to_compare=[0])
     agent = TabuSearch(neighbours_count=20, tabu_entity_rate=0.0, 
                        mutation_rate_multiplier=None, move_probas=[0, 1, 0, 0, 0, 0], 
                        compare_to_global=True, migration_frequency=10, termination_strategy=termination_strategy)
     """agent = GeneticAlgorithm(population_size=128, crossover_probability=0.5, p_best_rate=0.05,
                              tabu_entity_rate=0.0, mutation_rate_multiplier=1.0, move_probas=[0, 1, 0, 0, 0, 0],
                              migration_rate=0.00001, migration_frequency=1, termination_strategy=termination_strategy)"""
-    """agent = LateAcceptance(late_acceptance_size=1, tabu_entity_rate=0.0, 
+    """agent = LateAcceptance(late_acceptance_size=10, tabu_entity_rate=0.0, 
                            mutation_rate_multiplier=None, move_probas=[0, 1, 0, 0, 0, 0], 
                            termination_strategy=termination_strategy)"""
+    """agent = SimulatedAnnealing(initial_temperature=[1.0], cooling_rate=0.9999, tabu_entity_rate=0.0, 
+                               mutation_rate_multiplier=None, move_probas=[0, 1, 0, 0, 0, 0], 
+                               compare_to_global=True, migration_frequency=10, termination_strategy=termination_strategy)"""
 
     solver = Solver(domain_builder, cotwin_builder, agent, 
-                    ParallelizationBackend.Multiprocessing, LoggingLevel.Info,
+                    ParallelizationBackend.Multiprocessing, LoggingLevel.FreshOnly,
                     n_jobs=10, score_precision=[0])
     solution = solver.solve()
     #print( "Cotwin solution looks that: " )

examples/object_oriented/tsp/score/PlainScoreCalculatorTSP.py

@@ -5,6 +5,7 @@
 from greyjack.score_calculation.scores.ScoreVariants import ScoreVariants
 import polars as pl
 from numba import jit
+#from numba import cuda # there is possibility to write some constraints on gpu outside Polars engine
 
 class PlainScoreCalculatorTSP( PlainScoreCalculator ):
 
@@ -27,12 +28,13 @@ def no_duplicating_stops_constraint(self, planning_entity_dfs, problem_fact_dfs)
 
         duplicate_counts = (
             path_stops_df
+            .lazy()
             .group_by("sample_id")
             .agg((pl.col("location_list_id").count() - pl.col("location_list_id").n_unique()).alias("duplicates_count"))
             .group_by("sample_id")
             .agg(pl.col("duplicates_count").sum())
             .sort("sample_id")
-
+            .collect() # you can use engine="gpu" on Linux or by WSL
         )
 
         scores = duplicate_counts["duplicates_count"].to_list()
@@ -100,6 +102,7 @@ def minimize_distance(self, planning_entity_dfs, problem_fact_dfs):
     # instead rewriting on Rust (to not increase complexity of project and still take huge performance boost)
     @staticmethod
     @jit(nopython=True, cache=True)
+    #@cuda.jit()
     def compute_path_distances(data_matrix, distance_matrix):
 
         unique_sample_ids = np.unique(data_matrix[:, 0])

examples/object_oriented/tsp/scripts/solve_tsp.py

@@ -37,10 +37,10 @@
     cotwin_builder = CotwinBuilder(use_incremental_score_calculator=True)
 
     #termination_strategy = StepsLimit(step_count_limit=1000)
-    #termination_strategy = TimeSpentLimit(time_seconds_limit=60)
-    termination_strategy = ScoreNoImprovement(time_seconds_limit=15)
+    termination_strategy = TimeSpentLimit(time_seconds_limit=60)
+    #termination_strategy = ScoreNoImprovement(time_seconds_limit=15)
     #termination_strategy = ScoreLimit(score_to_compare=[0])
-    agent = TabuSearch(neighbours_count=128, tabu_entity_rate=0.2, 
+    agent = TabuSearch(neighbours_count=128, tabu_entity_rate=0.5, 
                        mutation_rate_multiplier=None, move_probas=[0.0, 0.2, 0.2, 0.2, 0.2, 0.2],
                        compare_to_global=False, migration_frequency=10, termination_strategy=termination_strategy)
     """agent = GeneticAlgorithm(population_size=128, crossover_probability=0.5, p_best_rate=0.05,
@@ -49,9 +49,12 @@
     """agent = LateAcceptance(late_acceptance_size=64, tabu_entity_rate=0.2, 
                            mutation_rate_multiplier=None, move_probas=[0.0, 0.2, 0.2, 0.2, 0.2, 0.2], 
                            termination_strategy=termination_strategy)"""
+    """agent = SimulatedAnnealing(initial_temperature=[1.0, 1.0], cooling_rate=0.9999, tabu_entity_rate=0.2, 
+                               mutation_rate_multiplier=None, move_probas=[0, 0.2, 0.2, 0.2, 0.2, 0.2], 
+                               compare_to_global=True, migration_frequency=10, termination_strategy=termination_strategy)"""
 
     solver = Solver(domain_builder, cotwin_builder, agent, 
-                    ParallelizationBackend.Multiprocessing, LoggingLevel.FreshOnly,
+                    ParallelizationBackend.Multiprocessing, LoggingLevel.Info,
                     n_jobs=10, score_precision=[0, 0])
     solution = solver.solve()
 

examples/object_oriented/vrp/score/PlainScoreCalculatorVRP.py

@@ -5,6 +5,7 @@
 from greyjack.score_calculation.scores.ScoreVariants import ScoreVariants
 import polars as pl
 from numba import jit
+#from numba import cuda # there is possibility to write some constraints on gpu outside Polars engine
 
 class PlainScoreCalculatorVRP(PlainScoreCalculator):
 
@@ -30,10 +31,13 @@ def build_common_df(self, planning_entity_dfs, problem_fact_dfs):
 
         customers_df = customers_df.rename({"customer_vec_id": "customer_id"})
         common_df = (planning_stops_df
-                      .with_row_index("index", offset=None)
-                      .join(vehicle_df, on="vehicle_id", how="inner")
-                      .join(customers_df, on="customer_id", how="inner")
-                      .sort(["sample_id", "vehicle_id", "index"], descending=[False, False, False]))
+                    .lazy()
+                    .with_row_index("index", offset=None)
+                    .join(vehicle_df.lazy(), on="vehicle_id", how="inner")
+                    .join(customers_df.lazy(), on="customer_id", how="inner")
+                    .sort(["sample_id", "vehicle_id", "index"], descending=[False, False, False])
+                    .collect() # you can use engine="gpu" on Linux or by WSL
+                    )
 
         self.utility_objects["common_df"] = common_df
 
@@ -45,11 +49,13 @@ def no_duplicating_stops_constraint(self, planning_entity_dfs, problem_fact_dfs)
 
         duplicate_counts = (
             path_stops_df
+            .lazy()
             .group_by("sample_id")
             .agg((pl.col("customer_id").count() - pl.col("customer_id").n_unique()).alias("duplicates_count"))
             .group_by("sample_id")
             .agg(pl.col("duplicates_count").sum())
             .sort("sample_id")
+            .collect() # you can use engine="gpu" on Linux or by WSL
         )
 
         scores = duplicate_counts["duplicates_count"].to_numpy()
@@ -64,13 +70,15 @@ def capacity_constraint(self, planning_entity_dfs, problem_fact_dfs):
 
         capacity_penalties = (
             common_df
+            .lazy()
             .group_by(["sample_id", "vehicle_id"])
             .agg(pl.col("demand").sum().alias("sum_trip_demand"))
-            .join(vehicle_df, on="vehicle_id", how="inner")
+            .join(vehicle_df.lazy(), on="vehicle_id", how="inner")
             .with_columns((pl.col("capacity") - pl.col("sum_trip_demand")).alias("capacity_difference"))
             .filter(pl.col("capacity_difference") < 0)
             .group_by("sample_id")
             .agg(pl.col("capacity_difference").abs().sum().alias("capacity_constraint_penalty"))
+            .collect() # you can use engine="gpu" on Linux or by WSL
         )
 
         bad_sample_ids = capacity_penalties["sample_id"].to_list()

examples/object_oriented/vrp/scripts/solve_vrp.py

@@ -41,18 +41,21 @@
     cotwin_builder = CotwinBuilder(use_incremental_score_calculator=True, use_greed_init=True)
 
     #termination_strategy = StepsLimit(step_count_limit=1000)
-    #termination_strategy = TimeSpentLimit(time_seconds_limit=60)
-    termination_strategy = ScoreNoImprovement(time_seconds_limit=15)
+    termination_strategy = TimeSpentLimit(time_seconds_limit=60)
+    #termination_strategy = ScoreNoImprovement(time_seconds_limit=15)
     #termination_strategy = ScoreLimit(score_to_compare=[0])
-    agent = TabuSearch(neighbours_count=128, tabu_entity_rate=0.0, 
+    agent = TabuSearch(neighbours_count=128, tabu_entity_rate=0.8, 
                        mutation_rate_multiplier=None, move_probas=[0.5, 0.5, 0.0, 0.0, 0.0, 0.0],
-                       compare_to_global=False, migration_frequency=10, termination_strategy=termination_strategy)
+                       compare_to_global=True, migration_frequency=10, termination_strategy=termination_strategy)
     """agent = GeneticAlgorithm(population_size=512, crossover_probability=0.5, p_best_rate=0.2,
                              tabu_entity_rate=0.0, mutation_rate_multiplier=None, move_probas=[0.5, 0.5, 0.0, 0.0, 0.0, 0.0],
                              migration_rate=0.00001, migration_frequency=10, termination_strategy=termination_strategy)"""
-    """agent = LateAcceptance(late_acceptance_size=64, tabu_entity_rate=0.05, 
+    """agent = LateAcceptance(late_acceptance_size=32, tabu_entity_rate=0.8, 
                            mutation_rate_multiplier=None, move_probas=[0.5, 0.5, 0.0, 0.0, 0.0, 0.0], 
                            termination_strategy=termination_strategy)"""
+    """agent = SimulatedAnnealing(initial_temperature=[1.0, 1.0, 1.0], cooling_rate=0.9999, tabu_entity_rate=0.0, 
+                               mutation_rate_multiplier=None, move_probas=[0.5, 0.5, 0.0, 0.0, 0.0, 0.0], 
+                               compare_to_global=True, migration_frequency=10, termination_strategy=termination_strategy)"""
 
     solver = Solver(domain_builder, cotwin_builder, agent, 
                     ParallelizationBackend.Multiprocessing, LoggingLevel.FreshOnly,

greyjack/Cargo.lock

@@ -1,7 +1,7 @@
 [package]
 name = "greyjack"
-version = "0.1.1"
-edition = "2021"
+version = "0.1.2"
+edition = "2024"
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 [lib]
@@ -22,8 +22,8 @@ polars = { version = "0.46.0", features = ["lazy", "ndarray", "serde", "abs"] }
 # if you build lib from source code
 # uncomment to gain max performance (increases calculation speed about 5-10%, 
 # but also increases build time ~20x times)
-[profile.release]
-lto = true
-codegen-units = 1
-debug = true
-opt-level = 3
+#[profile.release]
+#lto = true
+#codegen-units = 1
+#debug = true
+#opt-level = 3

greyjack/Cargo.toml

@@ -14,7 +14,7 @@ There are 2 editions of GreyJack Solver:
 - Python edition
 - [Rust edition](https://github.com/CameleoGrey/greyjack-solver-rust)
 
-# Key Features of GreyJack Solver (Rust version)
+# Key Features of GreyJack Solver
 
 - **Unmatched Comfort, Expressiveness, Flexibility and speed of developing** Designed to express almost any optimization problem with maximum comfortability and clarity.
 - **Universality** Supports a wide range of constraint problems, including continuous, integer, and mixed-integer challenges. Additionally, thanks to Polars, you can optimize virtually any process that can be represented as table data.
@@ -24,7 +24,7 @@ There are 2 editions of GreyJack Solver:
 - **Support for Population and Local Search Algorithms** GreyJack Solver supports a wide range of metaheuristics, including population-based and local search algorithms, with highly flexible settings. You can easily find, select, and configure the approach that best fits your problem, delivering optimal results.
 - **Easy Integration**  The observer mechanism (see examples) simplifies integration, making it straightforward to incorporate GreyJack Solver into your existing workflows..
 
-# Get started with GreyJack Solver in Rust
+# Get started with GreyJack Solver
 
 ```
 pip install greyjack
@@ -45,7 +45,6 @@ maturin develop --release
 
 # RoadMap
 
-- SimulatedAnnealing
 - API for modelling pure math problems (classic solvers like)
 - Modern variations (modifications) of LSHADE (Differential evolution algorithms often appear in articles as sota approaches)
 - CMA, probably its modern variants, adaptations for tasks with integer and categorical variables (often appears in articles as sota approach)

greyjack/README.md

@@ -165,7 +165,7 @@ def solve(self):
             steps_count += 1
             new_best_string = "New best score!" if new_best_flag else ""
             if self.logging_level == LoggingLevel.FreshOnly and new_best_flag:
-                self.logger.info(f"Solutions received: {steps_count} Best score: {self.global_top_individual.score}, Solving time: {total_time:.6f} {new_best_string}")
+                self.logger.info(f"Agent: {agent_id:4} Step {local_step} Best score: {self.global_top_individual.score}, Solving time: {total_time:.6f} {new_best_string}")
 
             if len(self.observers) >= 1:
                 self._notify_observers(self.global_top_individual)

greyjack/greyjack/Solver.py

@@ -0,0 +1,62 @@
+
+from greyjack.agents.base.Agent import Agent
+from greyjack.agents.metaheuristic_bases.SimulatedAnnealingBase import SimulatedAnnealingBase
+from greyjack.score_calculation.score_requesters.OOPScoreRequester import OOPScoreRequester
+
+
+class SimulatedAnnealing(Agent):
+    def __init__(
+        self,
+        initial_temperature,
+        cooling_rate,
+        tabu_entity_rate,
+        mutation_rate_multiplier=None,
+        move_probas=None,
+        compare_to_global=False,
+        migration_frequency=None,
+        termination_strategy=None,
+    ):  
+        
+        super().__init__(1.0, migration_frequency, termination_strategy)
+
+        self.population_size = 1
+        self.initial_temperature = initial_temperature
+        self.cooling_rate = cooling_rate
+        self.tabu_entity_rate = tabu_entity_rate
+        self.mutation_rate_multiplier = mutation_rate_multiplier
+        self.move_probas = move_probas
+
+        # If true - stucks more often in local minimums, but converges much faster
+        # may be useful in multiple stages solving
+        self.is_win_from_comparing_with_global = compare_to_global
+
+    def _build_metaheuristic_base(self):
+        self.score_requester = OOPScoreRequester(self.cotwin)
+        semantic_groups_dict = self.score_requester.variables_manager.semantic_groups_map.copy()
+        discrete_ids = self.score_requester.variables_manager.discrete_ids.copy()
+
+        """
+        new(score_variant, variables_manager_py, 
+            initial_temperature, tabu_entity_rate, 
+            semantic_groups_dict, cooling_rate=None, 
+            mutation_rate_multiplier=None, 
+            move_probas=None, discrete_ids=None):
+        """
+
+        self.metaheuristic_base = SimulatedAnnealingBase.new(
+            self.cotwin.score_calculator.score_variant,
+            self.score_requester.variables_manager,
+            self.initial_temperature,
+            self.tabu_entity_rate,
+            semantic_groups_dict,
+            self.cooling_rate,
+            self.mutation_rate_multiplier,
+            self.move_probas.copy() if self.move_probas else None,
+            discrete_ids,
+        )
+
+        # to remove redundant clonning
+        self.metaheuristic_name = self.metaheuristic_base.metaheuristic_name
+        self.metaheuristic_kind = self.metaheuristic_base.metaheuristic_kind
+
+        return self

greyjack/greyjack/agents/SimulatedAnnealing.py

@@ -2,4 +2,5 @@
 
 from greyjack.agents.TabuSearch import TabuSearch
 from greyjack.agents.GeneticAlgorithm import GeneticAlgorithm
-from greyjack.agents.LateAcceptance import LateAcceptance
+from greyjack.agents.LateAcceptance import LateAcceptance
+from greyjack.agents.SimulatedAnnealing import SimulatedAnnealing

greyjack/greyjack/agents/__init__.py

@@ -117,7 +117,7 @@ def _build_cotwin(self):
 
     def _define_individual_type(self):
         self.score_variant = self.cotwin.score_calculator.score_variant
-        self.individual_type = Individual.get_related_individual_type(self.cotwin.score_calculator.score_variant)
+        self.individual_type = Individual.get_related_individual_type(self.score_variant)
 
     # implements by concrete metaheuristics
     def _build_metaheuristic_base(self):