scipplan 0.1.0a0__py2.py3-none-any.whl

scipplan/plan_model.py

@@ -0,0 +1,257 @@
+from .config import Config
+from .variables import Variable, VarType
+from .parse_model import ParseModel as PM, EvalParams
+from .helpers import list_accessible_files
+
+import math
+import os
+
+from pyscipopt.scip import Model
+from pkg_resources import parse_version
+from importlib.metadata import version
+
+if parse_version(version("pyscipopt")) >= parse_version("4.3.0"):
+    from pyscipopt import quicksum, exp, log, sqrt, sin, cos
+    allow_trig_funcs = True
+else:
+    from pyscipopt import quicksum, exp, log, sqrt 
+    allow_trig_funcs = False
+
+class PlanModel:
+    def __init__(self, config: Config) -> None:
+        self.config: Config = config
+        self.var_names: set[str] = set()
+        
+        self.model = Model(f"{config.domain}_{config.instance}_{config.horizon}")
+        
+        # Translation -> line_num -> horizon -> aux
+        self.aux_vars: dict[str, list[list[list]]] = {}
+        
+        self.constants = self.encode_constants()
+        self.variables = self.encode_pvariables()
+        self.translations = self.encode_constraints()
+        
+        self.rewards = self.encode_reward()
+        
+        # Encode bounds on Dt
+        for h in range(self.config.horizon):
+            dt_var = self.variables[(self.config.dt_var, h)].model_var
+            self.model.addCons(dt_var >= 0.0, f"dt_{h}_lower_bound")
+            self.model.addCons(dt_var <= self.config.bigM, f"dt_{h}_upper_bound")   
+    
+
+        
+    def encode_constants(self) -> dict[str, float]:
+        constants = {}
+        translation = "constants"
+        config_vals = {
+            # Since horizon can be incremented without this value being updated, it will be removed for the time being
+            # "config_horizon": self.config.horizon,
+            "config_epsilon": self.config.epsilon,
+            "config_gap": self.config.gap,
+            "config_bigM": self.config.bigM
+        }
+    
+            
+        with open(self.get_file_path(translation)) as f:
+            for line in f.readlines():
+                if line.strip() == "":
+                    continue
+                
+                var, val = line.strip().split("=")
+                var, val = var.strip(), val.strip()
+                
+                val = val if val not in config_vals else config_vals[val]
+                
+                try:
+                    val = float(val)
+                except ValueError:
+                    raise ValueError("Constants can only be floats, please reconfigure: ")
+                
+                constants[var] = val
+                self.var_names.add(var)
+                
+        constants["bigM"] = self.config.bigM
+        self.var_names.add("bigM")
+        return constants
+                
+        
+    def encode_pvariables(self) -> dict[tuple[str, int], Variable]:
+        variables: dict[tuple[str, int], Variable] = {}
+        for t in range(self.config.horizon):
+            for constant, val in self.constants.items():
+                variables[(constant, t)] = Variable.create_var(self.model, constant, "constant", t, self.constants)
+                var_type = variables[(constant, t)].var_type
+                
+        translation = "pvariables"
+        with open(self.get_file_path(translation)) as f:
+            for line in f.readlines():
+                
+                var = line.rstrip("\n").strip()
+                if var == "":
+                    continue
+                vtype, name = var.split(": ")
+                vtype, name = vtype.strip(), name.strip()
+                
+                self.var_names.add(name)
+                
+                for t in range(self.config.horizon):
+                    variables[(name, t)] = Variable.create_var(self.model, name, vtype, t, self.constants)
+                    var_type = variables[(name, t)].var_type
+                if var_type is VarType.STATE:
+                    variables[(name, self.config.horizon)] = Variable.create_var(self.model, name, vtype, self.config.horizon, self.constants)
+                    
+        return variables
+                
+         
+         
+    def encode_constraints(self) -> dict[str, list[str]]:
+        translation_names = [
+            "initials",
+            "instantaneous_constraints",
+            "temporal_constraints",
+            "goals",
+            "transitions"
+        ]
+        translations: dict[str, list[str]] = {}
+        for translation in translation_names:
+            translations[translation] = []
+            
+            with open(self.get_file_path(translation)) as f:
+                for line in f.readlines():
+                    expr = line.rstrip("\n").strip()
+                    # If line is empty don't append
+                    if expr == "":
+                        continue
+                    
+                    translations[translation].append(expr)
+            
+        # Encode constraints into model
+        for cons_idx, (translation, constraints) in enumerate(translations.items()):
+            for idx, constraint in enumerate(constraints):
+                if translation == "initials":
+                    exprs = PM(self.get_parser_params(horizon=0, add_aux_vars=True)).evaluate(constraint, horizon=0, expr_name=f"{translation}_{idx}_0")
+                    
+                    if self.aux_vars.get(translation) is None: self.aux_vars[translation] = [None] * len(constraints)
+                    if self.aux_vars[translation][idx] is None: self.aux_vars[translation][idx] = [None] * self.config.horizon
+                    self.aux_vars[translation][idx][0] = exprs.aux_vars
+
+                    for eqtn_idx, eqtn in enumerate(exprs):
+                        self.model.addCons(eqtn, f"{translation}_{idx}_{eqtn_idx}")
+                        
+                elif translation == "goals":
+                    # horizon - 1 is because the final action time is horizon - 1
+                    exprs = PM(self.get_parser_params(horizon=self.config.horizon - 1, is_goal=True, add_aux_vars=True)).evaluate(constraint, horizon=self.config.horizon - 1, expr_name=f"{translation}_{idx}_{self.config.horizon - 1}")
+                    
+                    if self.aux_vars.get(translation) is None: self.aux_vars[translation] = [None] * len(constraints)
+                    if self.aux_vars[translation][idx] is None: self.aux_vars[translation][idx] = [None] * self.config.horizon
+                    self.aux_vars[translation][idx][self.config.horizon - 1] = exprs.aux_vars
+                    
+                    for eqtn_idx, eqtn in enumerate(exprs):
+                        self.model.addCons(eqtn, f"{translation}_{idx}_{eqtn_idx}")
+                else:
+                    for t in range(self.config.horizon):
+                        exprs = PM(self.get_parser_params(horizon=t, add_aux_vars=True)).evaluate(constraint, horizon=t, expr_name=f"{translation}_{idx}_{t}")
+                        
+                        if self.aux_vars.get(translation) is None: self.aux_vars[translation] = [None] * len(constraints)
+                        if self.aux_vars[translation][idx] is None: self.aux_vars[translation][idx] = [None] * self.config.horizon
+                        self.aux_vars[translation][idx][t] = exprs.aux_vars
+                        
+                        for eqtn_idx, eqtn in enumerate(exprs):
+                            self.model.addCons(eqtn, f"{translation}_{idx}_{eqtn_idx}")
+                    
+        return translations
+    
+    def encode_reward(self):
+        objectives = [None] * self.config.horizon
+        translation = "reward"
+        with open(self.get_file_path(translation)) as f:
+            reward = f.readline().rstrip("\n")
+            for t in range(self.config.horizon):
+                objectives[t] = self.model.addVar(f"Obj_{t}", vtype="C", lb=None, ub=None)
+                # For the sake of similarity the reward is similar to constraint parsing, however, only one reward function is allowed
+                exprs = PM(self.get_parser_params(t)).evaluate(reward)
+                for expr_idx, expr in enumerate(exprs):
+                    self.model.addCons(objectives[t] == expr, f"Obj_{t}_{expr_idx}")
+                
+            self.model.setObjective(quicksum(objectives), "maximize")
+            
+        return objectives
+            
+            
+
+    def get_parser_params(self, horizon: int, is_goal: bool = False, add_aux_vars: bool = False) -> EvalParams:
+        functions = {
+            "exp": exp, 
+            "log": log, 
+            "sqrt": sqrt, 
+        }
+        if allow_trig_funcs:
+            functions["sin"] = sin 
+            functions["cos"] = cos 
+            
+        variables = {}
+        operators = {}
+        if is_goal:
+            for name in self.var_names:
+                var = self.variables[(name, horizon)]
+                if var.var_type is VarType.STATE:
+                    var = self.variables[(name, horizon + 1)]
+                variables[var.name] = var.model_var
+        else:
+            for name in self.var_names:
+                var = self.variables[(name, horizon)]
+                variables[var.name] = var.model_var
+                if var.var_type is VarType.STATE:
+                    var = self.variables[(name, horizon + 1)]
+                    variables[f"{var.name}_dash"] = var.model_var
+            
+        return EvalParams.as_parser(variables, functions, operators, self.model, add_aux_vars)
+    
+
+    def get_calc_params(self, horizon, dt) -> EvalParams:
+        functions = {
+            "exp": math.exp, 
+            "log": math.log, 
+            "sqrt": math.sqrt, 
+        }
+        if allow_trig_funcs:
+            functions["sin"] = math.sin 
+            functions["cos"] = math.cos
+        
+        variables = {}
+        operators = {}
+        for name in self.var_names:
+            var = self.variables[(name, horizon)]
+            if var.var_type is VarType.CONSTANT:
+                variables[var.name] = var.model_var
+            else:
+                variables[var.name] = self.model.getVal(var.model_var)
+                
+                if var.var_type is VarType.STATE:
+                    var = self.variables[(name, horizon + 1)]
+                    variables[f"{var.name}_dash"] = self.model.getVal(var.model_var)
+        
+        variables[self.config.dt_var] = dt
+        
+        
+        return EvalParams.as_calculator(variables, functions, operators, self.model)
+    
+    
+    def get_file_path(self, translation: str) -> str:
+        path = f"{translation}_{self.config.domain}_{self.config.instance}.txt"
+        
+        usr_files_path = os.path.join("./", "translation")
+        usr_files = list_accessible_files(usr_files_path)
+        
+        pkg_files_path = os.path.join(os.path.dirname(__file__), "translation")
+        pkg_files = list_accessible_files(pkg_files_path)
+        
+        
+        if path in usr_files:
+            return os.path.join(usr_files_path, path)
+        elif path in pkg_files:
+            return os.path.join(pkg_files_path, path)
+        else:
+            raise Exception("Unkown file name, please enter a configuration for a valid domain instance in translation: ")
+        

scipplan/scipplan.py

@@ -0,0 +1,196 @@
+from __future__ import annotations
+
+import time
+
+from .config import Config
+from .plan_model import PlanModel
+from .variables import VarType
+from .zero_crossing import ZeroCrossing
+from .parse_model import ParseModel as PM
+from .helpers import InfeasibilityError, iterate, write_to_csv
+
+from importlib.metadata import version
+from pyscipopt.scip import Model
+
+class SCIPPlan:
+    """
+    SCIPPlan is a planner which optimises mixed integer non-linear programming problems over hybrid domains
+    
+    In order to use SCIPPlan you must pass in as input a Config object which contains the configuration of the problem.
+    Then you may either use the optimize or solve methods.
+    
+    The optimize method attempts to optimise the problem for the provided horizon. 
+    If there are no feasible solutions, then the optimize method will raise InfeasibilityError.
+    
+    The solve method attempts to solve the problem starting with the provided horizon.
+    If there are no feasible solutions for the current horizon then the configs horizon will be incremented.
+    After which the solve method will attempt to optimize the problem again.
+    """
+
+    def __init__(self, config: Config) -> None:
+        self.config = config
+        self.plan = PlanModel(self.config)
+        self.scip_model = self.plan.model
+        
+        self.scip_model.setRealParam("limits/gap", self.config.gap)
+        
+        if config.show_output is False:
+            self.scip_model.hideOutput()
+        
+        self.results_table = []
+        self.new_constraints = []
+        
+        self.state_actions = []
+               
+
+    def optimize(self):
+        iteration = 0
+        
+        while True:
+            self.scip_model.optimize()
+            
+            if len(self.scip_model.getSols()) == 0:
+                raise InfeasibilityError
+
+            zero_cross = self.check_violated_constraints(iteration)
+                
+            self.save_values(iteration)
+            
+            if zero_cross.is_violated is False:
+                return None
+            
+            self.new_constraints.append({
+                "interval_start": zero_cross.start,
+                "interval_end": zero_cross.end,
+                "dt_interval": zero_cross.dt_interval,
+                "zero_crossing_coefficient": zero_cross.coef,
+                "new_dt_val": zero_cross.new_dt_val,
+                "horizon": zero_cross.horizon,
+                "iteration": zero_cross.iteration
+            })
+            
+            if self.config.show_output is True:
+                print("\n\n")
+                print("New Constraints: \n")
+                for new_constraint in self.new_constraints:
+                    print(new_constraint, end="\n\n")
+                print("\n\n")
+            
+            self.scip_model.freeTransform()
+            
+            for idx, constraint in enumerate(self.plan.translations["temporal_constraints"]):
+                t = zero_cross.horizon
+                aux_vars = self.plan.aux_vars["temporal_constraints"][idx][t]
+                params = self.plan.get_parser_params(horizon=t)
+                params.variables[self.config.dt_var] *= zero_cross.coef
+                exprs = PM(params).evaluate(constraint, aux_vars=aux_vars)
+                for eqtn_idx, eqtn in enumerate(exprs):
+                    self.plan.model.addCons(eqtn, f"{constraint}_{idx}_{eqtn_idx}")
+            
+            iteration += 1
+
+    
+    def check_violated_constraints(self, iteration: int) -> ZeroCrossing:
+        is_violated = False
+        cross_interval = [-1.0 * self.config.epsilon, -1.0 * self.config.epsilon]
+        
+        for h in range(self.config.horizon):
+            dt = self.scip_model.getVal(self.plan.variables[(self.config.dt_var, h)].model_var)
+            
+            for constraint in self.plan.translations["temporal_constraints"]:
+                is_violated = False
+                
+                for time in iterate(0, dt, self.config.epsilon):
+                    pm = PM(self.plan.get_calc_params(horizon=h, dt=time))
+                    exprs = pm.evaluate(constraint)
+                    
+                    for eqtn_idx, constraint_eval in enumerate(exprs):
+                        if constraint_eval is False:
+                            if not is_violated:
+                                # Set interval start when first part of zero crossing is found
+                                is_violated = True
+                                cross_interval[0] = time
+                            
+                            # Keep updating end point until end of zero crossing or end of dt interval
+                            cross_interval[1] = time
+                        
+                if is_violated and (constraint_eval is True or time + self.config.epsilon > dt):
+                    return ZeroCrossing(
+                        is_violated=True,
+                        horizon=h,
+                        iteration=iteration,
+                        start=cross_interval[0],
+                        end=cross_interval[1],
+                        dt_interval=dt,
+                    )
+        
+        return ZeroCrossing(is_violated=False)
+        
+    
+     
+    @classmethod
+    def solve(cls, config: Config) -> tuple[SCIPPlan, float]:
+        while True:
+            model = SCIPPlan(config)
+            start_time = time.time()
+            try:
+                print(f"Encoding the problem over horizon h={config.horizon}.")
+                print("Solving the problem.")
+                model.optimize()
+                                
+                solve_time = (time.time() - start_time)
+                # print(f"Total Time: {solve_time: .3f} seconds")
+                print("Problem solved. \n")
+                return model, solve_time 
+                    
+            
+            except InfeasibilityError:
+                # print("Problem is infeasible for the given horizon.")
+                print(f"Horizon of h={model.config.horizon} is infeasible, incrementing to h={model.config.horizon + 1}")
+                config.increment_horizon()
+                if config.show_output is True:
+                    print(f"Horizon Time: {(time.time() - start_time): .3f} seconds")
+        
+
+    def save_values(self, iteration: int):
+        for (name, h), var in self.plan.variables.items():
+            self.results_table.append(var.to_dict() | {"iteration": iteration})           
+    
+
+def main():    
+    print(f"SCIP Version: {Model().version()}")
+    print(f"PySCIPOpt Version: {version('pyscipopt')}\n")
+    config = Config.get_config()
+    print(config)
+  
+    plan, solve_time = SCIPPlan.solve(config)  
+    
+    if config.save_sols is True:
+        write_to_csv("new_constraints", plan.new_constraints, config)
+        write_to_csv("results", plan.results_table, config)
+        print("Solutions saved: \n")
+        
+        
+    print("Plan: ")
+    
+    # Get action variable names
+    action_names = [
+        var_name for var_name in plan.plan.var_names 
+        if plan.plan.variables[(var_name, 0)].var_type is VarType.ACTION
+        ]
+    
+    action_names = sorted(action_names)
+    
+    for step in range(plan.config.horizon):
+        for action_name in action_names:
+            if action_name == config.dt_var:
+                continue
+            print(f"{action_name} at step {step} by value {plan.scip_model.getVal(plan.plan.variables[(action_name, step)].model_var):.3f}")
+        
+        print(f"Dt at step {step} by value {plan.scip_model.getVal(plan.plan.variables[('Dt', step)].model_var):.3f} \n")
+    
+    print(f"Total reward: {(plan.scip_model.getObjVal()):.3f}")
+    print(f"Total time: {solve_time:.3f}")
+
+if __name__ == "__main__":
+    main()

scipplan/translation/constants_infection_1.txt

@@ -0,0 +1,17 @@
+b1 = 0.2
+b2 = 0.1
+c = 0.15
+N = 2000.0
+D = 150.0
+
+Makespan = 180.0
+
+Epsilon = 1.0
+
+Duration = 100.0
+DurationMin = 30.0
+DurationMax = 90.0
+
+Percentage = 0.8
+
+InitialInfected = 50.0

scipplan/translation/constants_navigation_1.txt

@@ -0,0 +1,2 @@
+Epsilon = config_epsilon
+bigM = config_bigM

scipplan/translation/constants_navigation_2.txt

@@ -0,0 +1,2 @@
+bigM = config_bigM
+Epsilon = config_epsilon

scipplan/translation/constants_navigation_3.txt

@@ -0,0 +1 @@
+Epsilon = config_epsilon

scipplan/translation/constants_pandemic_1.txt

@@ -0,0 +1,17 @@
+b1 = 0.2
+b2 = 0.1
+c = 0.15
+N = 2000.0
+D = 150.0
+
+Makespan = 180.0
+
+Epsilon = 1.0
+
+Duration = 100.0
+DurationMin = 30.0
+DurationMax = 90.0
+
+Percentage = 0.8
+
+InitialInfected = 50.0

scipplan/translation/goals_infection_1.txt

@@ -0,0 +1,3 @@
+Removed >= N * Percentage
+
+TotalTime == Makespan

scipplan/translation/goals_navigation_1.txt

@@ -0,0 +1,2 @@
+Location_x == 8.0
+Location_y == 8.0

scipplan/translation/goals_navigation_2.txt

@@ -0,0 +1,2 @@
+Location_x == 8.0
+Location_y == 8.0

scipplan/translation/goals_navigation_3.txt

@@ -0,0 +1,2 @@
+Location_x == 8.0
+Location_y == 8.0

scipplan/translation/goals_pandemic_1.txt

@@ -0,0 +1,3 @@
+Removed >= N * Percentage
+
+TotalTime == Makespan

scipplan/translation/initials_infection_1.txt

@@ -0,0 +1,5 @@
+Susceptible == N - InitialInfected
+Infected == InitialInfected
+Removed == 0.0
+
+TotalTime == 0.0

scipplan/translation/initials_navigation_1.txt

@@ -0,0 +1,4 @@
+Location_x == 0.0
+Location_y == 0.0
+Speed_x == 0.0
+Speed_y == 0.0

scipplan/translation/initials_navigation_2.txt

@@ -0,0 +1,4 @@
+Location_x == 0.0
+Location_y == 0.0
+Speed_x == 0.0
+Speed_y == 0.0

scipplan/translation/initials_navigation_3.txt

@@ -0,0 +1,4 @@
+Location_x == 0.0
+Location_y == 0.0
+Speed_x == 0.0
+Speed_y == 0.0

scipplan/translation/initials_pandemic_1.txt

@@ -0,0 +1,5 @@
+Susceptible == N - InitialInfected
+Infected == InitialInfected
+Removed == 0.0
+
+TotalTime == 0.0

scipplan/translation/instantaneous_constraints_infection_1.txt

@@ -0,0 +1,12 @@
+b - b1 + Lockdown >= 0.0
+b - b1 - Lockdown <= 0.0
+
+b - b2 + (1 - Lockdown) >= 0.0
+b - b2 - (1 - Lockdown) <= 0.0
+
+
+b <= b1
+b >= b2
+
+Dt >= DurationMin
+Dt <= DurationMax

scipplan/translation/instantaneous_constraints_navigation_1.txt

@@ -0,0 +1,9 @@
+Location_x <= 10.0
+Location_y <= 10.0
+Location_x >= 0.0
+Location_y >= 0.0
+Accelerate_x <= 0.5
+Accelerate_y <= 0.5
+Accelerate_x >= -0.5
+Accelerate_y >= -0.5
+(Location_x <= 4.0) or (Location_x >= 6.0) or (Location_y <= 4.0) or (Location_y >= 6.0)

scipplan/translation/instantaneous_constraints_navigation_2.txt

@@ -0,0 +1,10 @@
+Location_x <= 10.0
+Location_y <= 10.0
+Location_x >= 0.0
+Location_y >= 0.0
+Accelerate_x <= 0.5
+Accelerate_y <= 0.5
+Accelerate_x >= -0.5
+Accelerate_y >= -0.5
+(Location_x <= 2.0) or (Location_x >= 4.0) or (Location_y <= 1.0) or (Location_y >= 5.0)
+(Location_x <= 5.0) or (Location_x >= 7.0) or (Location_y <= 5.0) or (Location_y >= 9.0)

scipplan/translation/instantaneous_constraints_navigation_3.txt

@@ -0,0 +1,11 @@
+Location_x <= 10.0
+Location_y <= 10.0
+Location_x >= 0.0
+Location_y >= 0.0
+Accelerate_x <= 0.5
+Accelerate_y <= 0.5
+Accelerate_x >= -0.5
+Accelerate_y >= -0.5
+(Location_x <= 2.0) or (Location_x >= 4.0) or (Location_y <= 1.0) or (Location_y >= 9.0)
+(Location_x <= 4.0) or (Location_x >= 7.0) or (Location_y <= 7.0) or (Location_y >= 9.0)
+(Location_x <= 4.0) or (Location_x >= 9.0) or (Location_y <= 2.0) or (Location_y >= 6.0)

scipplan/translation/instantaneous_constraints_pandemic_1.txt

@@ -0,0 +1,12 @@
+b - b1 + Lockdown >= 0.0
+b - b1 - Lockdown <= 0.0
+
+b - b2 + (1 - Lockdown) >= 0.0
+b - b2 - (1 - Lockdown) <= 0.0
+
+
+b <= b1
+b >= b2
+
+Dt >= DurationMin
+Dt <= DurationMax

scipplan/translation/pvariables_infection_1.txt

@@ -0,0 +1,12 @@
+state_continuous: Susceptible
+state_continuous: Infected
+state_continuous: Removed
+
+state_continuous: TotalTime
+
+action_boolean: Lockdown
+action_continuous: Dt
+
+auxiliary_continuous: b
+
+ 

scipplan/translation/pvariables_navigation_1.txt

@@ -0,0 +1,8 @@
+action_continuous: Accelerate_x
+action_continuous: Accelerate_y
+action_continuous: Dt
+action_boolean: Mode
+state_continuous: Location_x
+state_continuous: Location_y
+state_continuous: Speed_x
+state_continuous: Speed_y

scipplan/translation/pvariables_navigation_2.txt

@@ -0,0 +1,8 @@
+action_continuous: Accelerate_x
+action_continuous: Accelerate_y
+action_continuous: Dt
+state_continuous: Location_x
+state_continuous: Location_y
+state_continuous: Speed_x
+state_continuous: Speed_y
+action_boolean: Mode

scipplan/translation/pvariables_navigation_3.txt

@@ -0,0 +1,8 @@
+action_continuous: Accelerate_x
+action_continuous: Accelerate_y
+action_boolean: Mode
+action_continuous: Dt
+state_continuous: Location_x
+state_continuous: Location_y
+state_continuous: Speed_x
+state_continuous: Speed_y

scipplan/translation/pvariables_pandemic_1.txt

@@ -0,0 +1,12 @@
+state_continuous: Susceptible
+state_continuous: Infected
+state_continuous: Removed
+
+state_continuous: TotalTime
+
+action_boolean: Lockdown
+action_continuous: Dt
+
+auxiliary_continuous: b
+
+ 

scipplan/translation/reward_infection_1.txt

@@ -0,0 +1 @@
+-1.0 * Lockdown * Dt