v0.2.5 New example (Employee Scheduling), boiler plate code for OOP approach, little fixes

Author: CameleoGrey

.gitignore

@@ -2,6 +2,7 @@
 /.vscode
 /greyjack/target
 /data
+/examples/object_oriented/project_job_shop
 
 # Byte-compiled / optimized / DLL files
 __pycache__/

examples/object_oriented/boiler_plate_code/__init__.py

@@ -0,0 +1,7 @@
+
+
+from greyjack.cotwin.CotwinBase import CotwinBase
+
+class Cotwin(CotwinBase):
+    def __init__(self):
+        super().__init__()

examples/object_oriented/boiler_plate_code/cotwin/Cotwin.py

@@ -0,0 +1,35 @@
+
+
+
+from greyjack.persistence.CotwinBuilderBase import CotwinBuilderBase
+from greyjack.variables.GJInteger import GJInteger
+from examples.object_oriented.boiler_plate_code.cotwin.Cotwin import Cotwin
+from examples.object_oriented.boiler_plate_code.score.IncrementalScoreCalculator import IncrementalScoreCalculator
+from examples.object_oriented.boiler_plate_code.score.PlainScoreCalculator import PlainScoreCalculator
+
+
+class CotwinBuilder(CotwinBuilderBase):
+    def __init__(self, use_incremental_score_calculator, use_greed_init):
+        self.use_incremental_score_calculator = use_incremental_score_calculator
+        self.use_greed_init = use_greed_init
+        pass
+
+    def build_cotwin(self, domain, is_already_initialized):
+
+        cotwin = Cotwin()
+
+        cotwin.add_planning_entities_list(self._build_some_planning_entities(domain, is_already_initialized), "some_planning_entities")
+        #cotwin.add_problem_facts_list(self._build_some_problem_facts(domain), "some_problem_facts")
+
+        if self.use_incremental_score_calculator:
+            score_calculator = IncrementalScoreCalculator()
+        else:
+            score_calculator = PlainScoreCalculator()
+
+        cotwin.set_score_calculator( score_calculator )
+
+        return cotwin
+
+
+
+

examples/object_oriented/boiler_plate_code/cotwin/__init__.py

@@ -0,0 +1,22 @@
+
+import random
+
+from greyjack.persistence.DomainBuilderBase import DomainBuilderBase
+
+class DomainBuilder(DomainBuilderBase):
+
+    def __init__(self, random_seed=45):
+        super().__init__()
+
+        self.random_seed = random_seed
+
+    def build_domain_from_scratch(self):
+        return domain
+    
+    def build_from_solution(self, solution, initial_domain=None):
+        return domain
+
+    def build_from_domain(self, domain):
+        return super().build_from_domain(domain)
+
+

examples/object_oriented/boiler_plate_code/domain/__init__.py

@@ -0,0 +1,5 @@
+
+
+
+from greyjack.persistence.DomainBuilderBase import DomainBuilderBase
+from greyjack.persistence.CotwinBuilderBase import CotwinBuilderBase

examples/object_oriented/boiler_plate_code/persistence/CotwinBuilder.py

@@ -0,0 +1,20 @@
+
+from greyjack.score_calculation.score_calculators.IncrementalScoreCalculator import IncrementalScoreCalculator
+from greyjack.score_calculation.scores.SimpleScore import SimpleScore
+from greyjack.score_calculation.scores.ScoreVariants import ScoreVariants
+import polars as pl
+import numpy as np
+import numba
+from numba import jit, int64, float64, vectorize
+
+
+class IncrementalScoreCalculator(IncrementalScoreCalculator):
+    def __init__(self):
+        super().__init__()
+        self.score_variant = ScoreVariants.SimpleScore
+        self.add_constraint("some_constraint_function", self.some_constraint_function)
+        pass
+
+    def some_constraint_function(self, planning_entity_dfs, problem_fact_dfs, delta_dfs):
+
+        return scores

examples/object_oriented/boiler_plate_code/persistence/DomainBuilder.py

@@ -0,0 +1,22 @@
+
+
+from greyjack.score_calculation.score_calculators.PlainScoreCalculator import PlainScoreCalculator
+from greyjack.score_calculation.scores.SimpleScore import SimpleScore
+from greyjack.score_calculation.scores.ScoreVariants import ScoreVariants
+import polars as pl
+
+
+class PlainScoreCalculator(PlainScoreCalculator):
+    def __init__(self):
+
+        super().__init__()
+
+        self.score_variant = ScoreVariants.SimpleScore
+
+        self.add_constraint("some_constraint_function", self.some_constraint_function)
+
+        pass
+    
+    def some_constraint_function(self, planning_entity_dfs, problem_fact_dfs):
+
+        return scores

examples/object_oriented/boiler_plate_code/persistence/__init__.py

@@ -0,0 +1,51 @@
+from pathlib import Path
+import os
+import sys
+
+# To launch normally from console
+script_dir_path = Path(os.path.dirname(os.path.realpath(__file__)))
+project_dir_id = script_dir_path.parts.index("greyjack-solver-python")
+project_dir_path = Path(*script_dir_path.parts[:project_dir_id+1])
+sys.path.append(str(project_dir_path))
+
+from examples.object_oriented.boiler_plate_code.persistence.DomainBuilder import DomainBuilder
+from examples.object_oriented.boiler_plate_code.persistence.CotwinBuilder import CotwinBuilder
+from greyjack.agents.termination_strategies import *
+from greyjack.agents import *
+from greyjack.SolverOOP import SolverOOP
+from greyjack.agents.base.LoggingLevel import LoggingLevel
+from greyjack.agents.base.ParallelizationBackend import ParallelizationBackend
+from greyjack.agents import *
+
+if __name__ == "__main__":
+
+    # build domain model
+    domain_builder = DomainBuilder(random_seed=45)
+    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 = ScoreLimit(score_to_compare=[0])
+    agent = TabuSearch(neighbours_count=20, tabu_entity_rate=0.0, 
+                       mutation_rate_multiplier=None, move_probas=[0.5, 0.5, 0, 0, 0, 0], 
+                       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.5, 0.5, 0, 0, 0, 0],
+                             migration_rate=0.00001, migration_frequency=1, termination_strategy=termination_strategy)"""
+    """agent = LateAcceptance(late_acceptance_size=10, tabu_entity_rate=0.0, 
+                           mutation_rate_multiplier=None, move_probas=[0.5, 0.5, 0, 0, 0, 0], 
+                           compare_to_global_frequency=1, 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.5, 0.5, 0, 0, 0, 0], 
+                               migration_frequency=10, compare_to_global_frequency=10, termination_strategy=termination_strategy)"""
+
+    solver = SolverOOP(domain_builder, cotwin_builder, agent, 
+                    ParallelizationBackend.Multiprocessing, LoggingLevel.FreshOnly,
+                    n_jobs=10, score_precision=[0])
+    solution = solver.solve()
+    
+    domain = domain_builder.build_from_solution(solution)
+    print(domain)
+
+    print( "done" )

examples/object_oriented/boiler_plate_code/score/IncrementalScoreCalculator.py

@@ -43,11 +43,12 @@ def _build_planning_processes(self, domain_model):
 
         cot_processes = []
         n_computers = len(domain_model.computers)
+        m_processes = len(domain_model.processes)
 
         if self.use_greed_init:
             initial_computer_ids = self._build_greed_initial_computer_ids(domain_model)
         else:
-            initial_computer_ids = n_computers * [None]
+            initial_computer_ids = m_processes * [None]
 
 
         for i, process in enumerate(domain_model.processes):

examples/object_oriented/boiler_plate_code/score/PlainScoreCalculator.py

@@ -42,7 +42,7 @@
     """agent = GeneticAlgorithm(population_size=128, crossover_probability=0.5, p_best_rate=0.2,
                              tabu_entity_rate=0.2, 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=5, tabu_entity_rate=0.8, 
+    """agent = LateAcceptance(late_acceptance_size=10, tabu_entity_rate=0.8, 
                            mutation_rate_multiplier=None, compare_to_global_frequency=10, 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], cooling_rate=0.9999, tabu_entity_rate=0.8, 

examples/object_oriented/boiler_plate_code/score/__init__.py

@@ -0,0 +1,16 @@
+
+
+
+
+class CotEmployee():
+
+    def __init__(self, id, name, skills, unavailable_dates, undesired_dates, desired_dates):
+
+        self.employee_id = id
+        self.name = name
+        self.skills = skills
+        self.unavailable_dates = unavailable_dates
+        self.undesired_dates = undesired_dates
+        self.desired_dates = desired_dates
+
+        pass

examples/object_oriented/boiler_plate_code/scripts/__init__.py

@@ -0,0 +1,15 @@
+
+
+class CotShift():
+
+    def __init__(self, id, start, end, location, required_skill, employee):
+
+        self.shift_id = id
+        self.start = start
+        self.end = end
+        self.start_date = self.start.date()
+        self.location = location
+        self.required_skill = required_skill
+        self.employee_id = employee
+
+        pass

examples/object_oriented/boiler_plate_code/scripts/solve_task.py

@@ -0,0 +1,7 @@
+
+
+from greyjack.cotwin.CotwinBase import CotwinBase
+
+class Cotwin(CotwinBase):
+    def __init__(self):
+        super().__init__()

examples/object_oriented/cloud_balancing/persistence/CotwinBuilder.py

@@ -0,0 +1,24 @@
+
+
+
+
+class Employee():
+
+    def __init__(self, name, skills):
+
+        self.name = name
+        self.skills = skills
+        self.unavailable_dates = []
+        self.undesired_dates = []
+        self.desired_dates = []
+
+        pass
+
+    def __str__(self):
+        
+        employee_info = "{} ({}) | Unavailable dates {} | Undesired dates {} | Desired dates {}".format(self.name, self.skills, 
+                                                                                                        self.unavailable_dates, self.undesired_dates, 
+                                                                                                        self.desired_dates)
+
+        
+        return employee_info

examples/object_oriented/cloud_balancing/scripts/solve_cloud_balancing.py

@@ -0,0 +1,33 @@
+
+
+import numpy as np
+
+class EmployeeSchedule():
+
+    def __init__(self, employees, shifts):
+
+        self.employees = employees
+        self.shifts = shifts
+
+        pass
+
+    def print_schedule(self):
+
+        for shift in self.shifts:
+            shift_assignment_info = str(shift) + " --> " + str(self.employees[shift.employee])
+            print(shift_assignment_info)
+
+    def print_metrics(self):
+
+        unfairness_penalty = 0
+        m_employees = len(self.employees)
+        shifts_counts = np.zeros((m_employees,), np.int64)
+        for shift in self.shifts:
+            shifts_counts[shift.employee] += 1
+        unfairness_penalty += np.sqrt(np.sum(np.square(shifts_counts - shifts_counts.mean())))
+
+        for i in range(m_employees):
+            print("{} shifts count: {}".format(self.employees[i].name, shifts_counts[i]))
+        print("Mean shifts count: {}".format(shifts_counts.mean()))
+        print("Load balance coefficient: {}".format(unfairness_penalty))
+

examples/object_oriented/employee_scheduling/__init__.py

@@ -0,0 +1,20 @@
+
+
+class Shift():
+
+    def __init__(self, id, start, end, location, required_skill):
+
+        self.id = id
+        self.start = start
+        self.end = end
+        self.location = location
+        self.required_skill = required_skill
+        self.employee = None
+
+        pass
+
+    def __str__(self):
+        
+        shift_info = "{}: {} - {} ({})".format(self.id, self.start, self.end, self.required_skill)
+
+        return shift_info

examples/object_oriented/employee_scheduling/cotwin/CotEmployee.py

@@ -0,0 +1,5 @@
+
+
+from .Employee import Employee
+from .EmployeeSchedule import EmployeeSchedule
+from .Shift import Shift