v0.0.9 Added termination criterions and GJSolution from prototype (autumn 2024)

Author: CameleoGrey

greyjack/greyjack/agents/__init__.py

@@ -0,0 +1,48 @@
+
+import numpy as np
+
+class GJSolution():
+    def __init__(self, variable_values_dict, score):
+        self.variable_values_dict = variable_values_dict
+        for var_name in self.variable_values_dict.keys():
+            var_value = self.variable_values_dict[var_name]
+
+            if "float" in str(type(var_value)):
+                var_value = float( var_value )
+            if "int" in str(type(var_value)):
+                var_value = int( var_value )
+
+            self.variable_values_dict[var_name] = var_value
+
+
+        self.score = score
+
+    def __repr__(self):
+
+        solution_string = ""
+
+        for var_name in self.variable_values_dict.keys():
+            var_string = var_name + " = {}".format( self.variable_values_dict[var_name] )
+            solution_string += var_string + "\n"
+
+        solution_string += "Score: " + str(self.score) + "\n"
+
+        return solution_string
+    
+    def __eq__(self, other):
+        return self.score == other.score
+
+    def __ne__(self, other):
+        return self.score != other.score
+
+    def __le__(self, other):
+        return self.score <= other.score
+
+    def __ge__(self, other):
+        return self.score >= other.score
+
+    def __lt__(self, other):
+        return self.score < other.score
+
+    def __gt__(self, other):
+        return self.score > other.score

greyjack/greyjack/agents/base/GPSolution.py

@@ -0,0 +1,70 @@
+
+import numpy as np
+from greyjack.score_calculation.scores.SimpleScore import SimpleScore
+from greyjack.score_calculation.scores.HardSoftScore import HardSoftScore
+
+
+class Individual:
+
+    def __init__(self, variable_values=None, score=None):
+        self.variable_values = variable_values
+        self.score = score
+
+    def copy(self):
+        individual = Individual(self.variable_values.copy(), self.scopy())
+        return individual
+
+    def __lt__(self, other):
+        return self.score < other.score
+    
+    def as_list(self):
+        return [self.variable_values.tolist(), self.score.as_list()]
+    
+    @staticmethod
+    def from_list(list_individual):
+        # TODO: generalize to more level scores
+        score_len = len(list_individual[1])
+        if score_len == 1:
+            score_type = SimpleScore
+        elif score_len == 2:
+            score_type = HardSoftScore
+        else:
+            raise ("Can't define score type while inverse converting of list of individuals-lists")
+        
+        variable_array = np.array( list_individual[0], dtype=np.float64 )
+        score = score_type( *list_individual[1] )
+        individual = Individual( variable_array, score )
+
+        return individual
+
+    @staticmethod
+    def convert_individuals_to_lists(individuals_list):
+
+        list_of_lists = []
+        for individual in individuals_list:
+            list_of_lists.append( individual.as_list() )
+        
+        return list_of_lists
+    
+    @staticmethod
+    def convert_lists_to_individuals(list_of_lists):
+        
+        # TODO: generalize to more level scores
+        score_len = len(list_of_lists[0][1])
+        if score_len == 1:
+            score_type = SimpleScore
+        elif score_len == 2:
+            score_type = HardSoftScore
+        else:
+            raise ("Can't define score type while inverse converting of list of individuals-lists")
+
+        individuals_list = []
+        for list_individual in list_of_lists:
+            variable_array = np.array( list_individual[0], dtype=np.float64 )
+            score = score_type( *list_individual[1] )
+            individual = Individual( variable_array, score )
+            individuals_list.append( individual )
+        
+        return individuals_list
+
+

greyjack/greyjack/agents/base/Individual.py

@@ -0,0 +1,29 @@
+
+from greyjack.agents.termination_strategies.TerminationStrategy import TerminationStrategy
+
+class ScoreLimit(TerminationStrategy):
+    def __init__(self, score_to_compare):
+
+        self.score_to_compare = score_to_compare
+        self.current_best_score = None
+
+        pass
+
+    def update(self, agent):
+        
+        self.current_best_score = agent.current_top_individual.score
+
+        pass
+
+    def is_accomplish(self):
+
+        if self.current_best_score <= self.score_to_compare:
+            return True
+
+        return False
+    
+    def get_accomplish_rate(self):
+
+        accomplish_rate = self.current_best_sget_fitness_value() / (self.score_to_compare.get_fitness_value() + 1e-10)
+
+        return accomplish_rate

greyjack/greyjack/agents/base/__init__.py

@@ -0,0 +1,49 @@
+
+from greyjack.agents.termination_strategies.TerminationStrategy import TerminationStrategy
+from datetime import datetime
+
+class ScoreNoImprovement(TerminationStrategy):
+    def __init__(self, time_seconds_limit=15):
+
+        self.time_seconds_limit = time_seconds_limit
+        self.start_time = None
+        self.current_best_score = None
+        self.time_delta = None
+
+        pass
+
+    def update(self, agent):
+        
+        if self.start_time is None:
+            self.start_time = datetime.now()
+            self.time_delta = (self.start_time - self.start_time).seconds
+            self.current_best_score = agent.current_top_individual.score
+            return
+        
+        # to prevent updates from migrants
+        if self.is_accomplish():
+            return
+        
+        current_score = agent.current_top_individual.score
+
+        if current_score < self.current_best_score:
+            self.current_best_score = current_score
+            self.start_time = datetime.now()
+            self.time_delta = (self.start_time - self.start_time).seconds
+        else:
+            self.time_delta = (datetime.now() - self.start_time).seconds
+
+        pass
+
+    def is_accomplish(self):
+
+        if self.time_delta >= self.time_seconds_limit:
+            return True
+
+        return False
+    
+    def get_accomplish_rate(self):
+
+        accomplish_rate = float(self.time_delta) / float(self.time_seconds_limit)
+
+        return accomplish_rate

greyjack/greyjack/agents/termination_strategies/ScoreLimit.py

@@ -0,0 +1,27 @@
+
+from greyjack.agents.termination_strategies.TerminationStrategy import TerminationStrategy
+
+class StepsLimit(TerminationStrategy):
+    def __init__(self, step_count_limit=10000):
+
+        self.step_count_limit = step_count_limit
+        self.steps_made = 0
+
+        pass
+
+    def update(self, agent):
+        self.steps_made += 1
+        pass
+
+    def is_accomplish(self):
+
+        if self.steps_made > self.step_count_limit:
+            return True
+
+        return False
+    
+    def get_accomplish_rate(self):
+
+        accomplish_rate = float(self.steps_made) / float(self.step_count_limit)
+
+        return accomplish_rate

greyjack/greyjack/agents/termination_strategies/ScoreNoImprovement.py

@@ -0,0 +1,17 @@
+
+from abc import ABC, abstractmethod
+
+class TerminationStrategy(ABC):
+
+    @abstractmethod
+    def update(self, agent):
+        pass
+    
+    @abstractmethod
+    def is_accomplish(self):
+        pass
+    
+    # how far from start of termination is the prcoess of solving
+    @abstractmethod
+    def get_accomplish_rate(self):
+        pass

greyjack/greyjack/agents/termination_strategies/StepsLimit.py

@@ -0,0 +1,36 @@
+
+from greyjack.agents.termination_strategies.TerminationStrategy import TerminationStrategy
+from datetime import datetime
+
+class TimeSpentLimit(TerminationStrategy):
+    def __init__(self, time_seconds_limit=5*60):
+
+        self.time_seconds_limit = time_seconds_limit
+        self.start_time = None
+        self.time_delta = None
+
+        pass
+
+    def update(self, agent):
+        
+        if self.start_time is None:
+            self.start_time = datetime.now()
+            self.time_delta = (self.start_time - self.start_time).seconds
+            return
+
+        self.time_delta = (datetime.now() - self.start_time).seconds
+
+        pass
+
+    def is_accomplish(self):
+
+        if self.time_delta >= self.time_seconds_limit:
+            return True
+
+        return False
+    
+    def get_accomplish_rate(self):
+
+        accomplish_rate = float(self.time_delta) / float(self.time_seconds_limit)
+
+        return accomplish_rate

greyjack/greyjack/agents/termination_strategies/TerminationStrategy.py

@@ -0,0 +1,6 @@
+
+
+from greyjack.agents.termination_strategies.ScoreLimit import ScoreLimit
+from greyjack.agents.termination_strategies.StepsLimit import StepsLimit
+from greyjack.agents.termination_strategies.TimeSpentLimit import TimeSpentLimit
+from greyjack.agents.termination_strategies.ScoreNoImprovement import ScoreNoImprovement