v0.2.2 Wrapped LSHADE, some refactor

Author: CameleoGrey

README.md

@@ -44,9 +44,6 @@ maturin develop --release
 -  maturin will build the Rust part, get all Python dependencies (for solver itself, not examples) and install greyjack to your venv
 
 # RoadMap
-
-- 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)
 - Add more examples: Job-Shop, Pickup&Delivery, some continuous and MIP tasks, scheduling, etc
 - Composite termination criterion (for example: solving limit minutes N AND score not improving M seconds)

examples/pure_math/minlp/solve_minlp_gj.py

@@ -17,22 +17,35 @@
 from greyjack.agents.base.LoggingLevel import LoggingLevel
 from greyjack.agents.termination_strategies import *
 
-from examples.pure_math.minlp.gj_files.rsyn0840m import *
+from examples.pure_math.minlp.gj_files.sssd import *
 
 if __name__ == "__main__":
 
+    # for standard LP, QP problems fomulations better use classic solvers (they are specially made for them)
+    # one needs metaheuristics, when classic solvers struggle, too difficult or just impossible to use:
+    # (difficult functions, fast development, lack of expressiveness (explore OOP API of GreyJack Solver to 
+    # understand how to express problems by another, much more comfort and easy way), adaptability to new requirements, clarity of 
+    # processes during optimization, explainability, etc, etc)
+    # here I use metaheuristics on standard LP, QP problems by using MathModel API just for benchmarks
     math_model = build_math_model()
 
     #termination_strategy = StepsLimit(step_count_limit=1000)
     #termination_strategy = TimeSpentLimit(time_seconds_limit=60)
     termination_strategy = ScoreNoImprovement(time_seconds_limit=15)
     #termination_strategy = ScoreLimit(score_to_compare=[0, 0])
+
+    agent = LSHADE(population_size=128, history_archive_size=100, 
+                   p_best_rate=0.2, tabu_entity_rate=0.2, 
+                   mutation_rate_multiplier=1.0, move_probas=None,
+                   memory_pruning_rate=0.0, guarantee_of_change_size=0, 
+                   initial_f=0.5, initial_cr=0.02, initial_mutation_proba=0.5,
+                   migration_rate=0.00001, migration_frequency=100, termination_strategy=termination_strategy)
+    """agent = GeneticAlgorithm(population_size=256, crossover_probability=0.8, p_best_rate=0.5,
+                             tabu_entity_rate=0.8, mutation_rate_multiplier=1.0, 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 = TabuSearch(neighbours_count=1000, tabu_entity_rate=0.8, 
                        mutation_rate_multiplier=1.0, move_probas=[0.5, 0.5, 0.0, 0.0, 0.0, 0.0], 
                        compare_to_global_frequency=10, termination_strategy=termination_strategy)"""
-    agent = GeneticAlgorithm(population_size=256, crossover_probability=0.8, p_best_rate=0.5,
-                             tabu_entity_rate=0.8, mutation_rate_multiplier=1.0, 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=200, tabu_entity_rate=0.8, 
                            mutation_rate_multiplier=1.0, move_probas=[0.5, 0.5, 0.0, 0.0, 0.0, 0.0], 
                            compare_to_global_frequency=10000, termination_strategy=termination_strategy)"""
@@ -42,7 +55,7 @@
 
     solver = SolverPureMath(math_model, agent,
                             ParallelizationBackend.Multiprocessing, LoggingLevel.FreshOnly,
-                            n_jobs=10, score_precision=[6, 2])
+                            n_jobs=10, score_precision=[4, 2])
     solution = solver.solve()
     math_model.explain_solution( solution )
 

examples/pure_math/minlp/solve_minlp_scip.py

@@ -214,7 +214,7 @@
 sys.path.append(str(project_dir_path))
 
 from pyomo.environ import *
-from examples.pure_math.minlp.minlp_files.rsyn0840m import *
+from examples.pure_math.minlp.minlp_files.sssd import *
 
 solver = SolverFactory('scip', executable="D:\\Soft\\SCIPOptSuite 9.1.0\\bin\\scip.exe")
 solution = solver.solve(model)

greyjack/Cargo.lock

@@ -1,7 +1,7 @@
 [package]
 name = "greyjack"
-version = "0.2.1"
-edition = "2024"
+version = "0.2.2"
+edition = "2021"
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 [lib]
@@ -25,5 +25,5 @@ polars = { version = "0.46.0", features = ["lazy", "ndarray", "serde", "abs"] }
 [profile.release]
 #lto = true
 #codegen-units = 1
-debug = true
-opt-level = 3
+#debug = true
+#opt-level = 3

greyjack/Cargo.toml

@@ -44,9 +44,6 @@ maturin develop --release
 -  maturin will build the Rust part, get all Python dependencies (for solver itself, not examples) and install greyjack to your venv
 
 # RoadMap
-
-- 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)
 - Add more examples: Job-Shop, Pickup&Delivery, some continuous and MIP tasks, scheduling, etc
 - Composite termination criterion (for example: solving limit minutes N AND score not improving M seconds)

greyjack/README.md

@@ -0,0 +1,86 @@
+
+from greyjack.agents.base.Agent import Agent
+from greyjack.agents.metaheuristic_bases.LSHADEBase import LSHADEBase
+from greyjack.score_calculation.score_requesters.OOPScoreRequester import OOPScoreRequester
+from greyjack.score_calculation.score_requesters.PureMathScoreRequester import PureMathScoreRequester
+from greyjack.cotwin.CotwinBase import CotwinBase
+from greyjack.pure_math.MathModel import MathModel
+
+class LSHADE(Agent):
+
+    """
+    Classic Tanabe-Fukunaga version of LSHADE (https://metahack.org/CEC2014-Tanabe-Fukunaga.pdf) 
+    with my own modifications to make it better work in common (not only for continuous tasks, but also for MIP).
+    For pure integer tasks works much badder than Tabu, GenAlg, LateAcc. Don't use LSHADE for purely integer tasks.
+    Later will be modified further. From 2014 there were a lot of modifications invented by researchers.
+
+    WARNING! Don't use this metaheuristic with already initialized values (it will stuck due to sampling from history mechanism)!
+    """
+
+    def __init__(
+        self, population_size=128, history_archive_size=100, 
+        p_best_rate=0.2, tabu_entity_rate=0.2, 
+        mutation_rate_multiplier=1.0, move_probas=None,
+        memory_pruning_rate=0.0, guarantee_of_change_size=1.0, 
+        initial_f=0.5, initial_cr=0.02, initial_mutation_proba=0.5,
+        migration_rate=0.00001, migration_frequency=10, termination_strategy=None
+    ):
+        
+        super().__init__(migration_rate, migration_frequency, termination_strategy, compare_to_global_frequency=1)
+
+        self.population_size = population_size
+        self.history_archive_size = history_archive_size
+        self.p_best_rate = p_best_rate
+        self.memory_pruning_rate = memory_pruning_rate
+        self.guarantee_of_change_size = guarantee_of_change_size
+        self.initial_f = initial_f
+        self.initial_cr = initial_cr
+        self.initial_mutation_proba = initial_mutation_proba
+
+        self.tabu_entity_rate = tabu_entity_rate
+        self.mutation_rate_multiplier = mutation_rate_multiplier
+        self.move_probas = move_probas
+
+        self.is_win_from_comparing_with_global = False
+
+    def _build_metaheuristic_base(self):
+        
+        # when I use issubclass() solver dies silently, so check specific attributes
+        if hasattr(self.cotwin, "planning_entities"):
+            self.score_requester = OOPScoreRequester(self.cotwin)
+            score_variant = self.cotwin.score_calculator.score_variant
+        elif isinstance(self.cotwin, MathModel):
+            self.score_requester = PureMathScoreRequester(self.cotwin)
+            score_variant = self.cotwin.score_variant
+            self.cotwin.score_calculator.is_incremental = False
+        else:
+            raise Exception("Cotwin must be either subclass of CotwinBase, either be instance of MathModel")
+
+        semantic_groups_dict = self.score_requester.variables_manager.semantic_groups_map.copy()
+        discrete_ids = self.score_requester.variables_manager.discrete_ids
+
+        self.metaheuristic_base = LSHADEBase.new(
+            score_variant,
+            self.score_requester.variables_manager,
+
+            self.population_size, 
+            self.history_archive_size, 
+            self.p_best_rate, 
+            self.memory_pruning_rate, 
+            self.guarantee_of_change_size, 
+            self.initial_f, 
+            self.initial_cr, 
+            self.initial_mutation_proba,
+
+            self.tabu_entity_rate,
+            semantic_groups_dict,
+            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/LSHADE.py

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

greyjack/greyjack/agents/__init__.py

@@ -297,13 +297,13 @@ def _send_updates_universal(self):
                    "round_robin_status_dict": self.round_robin_status_dict,
                    "request_type": "put_updates", 
                    "migrants": migrants}
-        if self.metaheuristic_base.metaheuristic_name == "LSHADE":
+        """if self.metaheuristic_base.metaheuristic_name == "LSHADE":
             if len(self.history_archive) > 0:
                 rand_id = random.randint(0, len(self.history_archive) - 1)
                 request["history_archive"] = self.history_archive[rand_id].as_list()
                 #request["history_archive"] = self.history_archive[-1]
             else:
-                request["history_archive"] = None
+                request["history_archive"] = None"""
 
         request_serialized = pickle.dumps(request)
         try:
@@ -338,14 +338,14 @@ def _get_updates_universal(self):
         self.agent_to_agent_socket_receiver.send(pickle.dumps("Successfully received updates"))
         updates_reply = pickle.loads( updates_reply )
 
-        if self.metaheuristic_base.metaheuristic_name == "LSHADE":
+        """if self.metaheuristic_base.metaheuristic_name == "LSHADE":
             history_migrant = updates_reply["history_archive"]
             if (history_migrant is not None and len(self.history_archive) > 0):
                 history_migrant = self.individual_type.from_list(history_migrant)
                 rand_id = random.randint(0, len(self.history_archive) - 1)
                 #if updates_reply["history_archive"] < self.history_archive[-1]:
                 if history_migrant < self.history_archive[rand_id]:
-                    self.history_archive[rand_id] = history_migrant
+                    self.history_archive[rand_id] = history_migrant"""
 
         migrants = updates_reply["migrants"]
         migrants = self.individual_type.convert_lists_to_individuals(migrants)
@@ -398,13 +398,13 @@ def _send_updates_linux(self):
                    "round_robin_status_dict": self.round_robin_status_dict,
                    "request_type": "put_updates", 
                    "migrants": migrants}
-        if self.metaheuristic_base.metaheuristic_name == "LSHADE":
+        """if self.metaheuristic_base.metaheuristic_name == "LSHADE":
             if len(self.history_archive) > 0:
                 rand_id = random.randint(0, len(self.history_archive) - 1)
                 request["history_archive"] = self.history_archive[rand_id].as_list()
                 #request["history_archive"] = self.history_archive[-1]
             else:
-                request["history_archive"] = None
+                request["history_archive"] = None"""
 
         try:
             self.agent_to_agent_pipe_sender.send( request )
@@ -426,14 +426,14 @@ def _get_updates_linux(self):
             return
         self.agent_to_agent_pipe_receiver.send("Successfully received updates")
 
-        if self.metaheuristic_base.metaheuristic_name == "LSHADE":
+        """if self.metaheuristic_base.metaheuristic_name == "LSHADE":
             history_migrant = updates_reply["history_archive"]
             if (history_migrant is not None and len(self.history_archive) > 0):
                 history_migrant = self.individual_type.from_list(history_migrant)
                 rand_id = random.randint(0, len(self.history_archive) - 1)
                 #if updates_reply["history_archive"] < self.history_archive[-1]:
                 if history_migrant < self.history_archive[rand_id]:
-                    self.history_archive[rand_id] = history_migrant
+                    self.history_archive[rand_id] = history_migrant"""
 
         migrants = updates_reply["migrants"]
         migrants = self.individual_type.convert_lists_to_individuals(migrants)

greyjack/greyjack/agents/base/Agent.py

@@ -0,0 +1,22 @@
+
+from greyjack.greyjack import LSHADESimple, LSHADEHardSoft, LSHADEHardMediumSoft
+from greyjack.score_calculation.scores.ScoreVariants import ScoreVariants
+
+class LSHADEBase:
+    def new(score_variant, variables_manager_py, population_size, history_archive_size, p_best_rate, memory_pruning_rate, guarantee_of_change_size, 
+            initial_f, initial_cr, initial_mutation_proba, tabu_entity_rate, semantic_groups_dict,
+            mutation_rate_multiplier, move_probas, discrete_ids):
+        if score_variant == ScoreVariants.SimpleScore:
+            return LSHADESimple(variables_manager_py, population_size, history_archive_size, p_best_rate, memory_pruning_rate, guarantee_of_change_size, 
+                                initial_f, initial_cr, initial_mutation_proba, tabu_entity_rate, semantic_groups_dict,
+                                mutation_rate_multiplier, move_probas, discrete_ids)
+        if score_variant == ScoreVariants.HardSoftScore:
+            return LSHADEHardSoft(variables_manager_py, population_size, history_archive_size, p_best_rate, memory_pruning_rate, guarantee_of_change_size, 
+                                initial_f, initial_cr, initial_mutation_proba, tabu_entity_rate, semantic_groups_dict,
+                                mutation_rate_multiplier, move_probas, discrete_ids)
+        if score_variant == ScoreVariants.HardMediumSoftScore:
+            return LSHADEHardMediumSoft(variables_manager_py, population_size, history_archive_size, p_best_rate, memory_pruning_rate, guarantee_of_change_size, 
+                                initial_f, initial_cr, initial_mutation_proba, tabu_entity_rate, semantic_groups_dict,
+                                mutation_rate_multiplier, move_probas, discrete_ids)
+        
+        raise Exception("score_variant unrecognized")