je sais pas

Author: guilyx

jupyddl/automated_planner.py

@@ -13,11 +13,12 @@
 
 logging.getLogger("julia").setLevel(logging.WARNING)
 
-
 class AutomatedPlanner:
     def __init__(self, domain_path, problem_path, log_level="DEBUG"):
         # Planning Tool
         self.pddl = PDDL
+        self.domain_path = domain_path
+        self.problem_path = problem_path
         self.domain = self.pddl.load_domain(domain_path)
         self.problem = self.pddl.load_problem(problem_path)
         self.initial_state = self.pddl.initialize(self.problem)
@@ -41,7 +42,6 @@ def __run_julia_once(self):
         actions = self.available_actions(self.initial_state)
         self.transition(self.initial_state, actions[0])
 
-    def __rela
 
     def __init_logger(self, log_level):
         import os

jupyddl/heuristics.py

@@ -29,7 +29,15 @@ def __goal_count_heuristic(self, state):
 
 class DeleteRelaxationHeuristic:
     def __init__(self, automated_planner, heuristic_key):
+        class DRHCache:
+            def __init__(self, domain=None, axioms=None, preconds=None, additions=None):
+                self.domain = domain 
+                self.axioms = axioms
+                self.preconds = preconds
+                self.additions = additions
+        
         self.automated_planner = automated_planner
+        self.cache = DRHCache()
         self.heuristic_keys = {
             "delete_relaxation/h_add": self.__h_add,
             "delete_relaxation/h_max": self.__h_max
@@ -39,22 +47,56 @@ def __init__(self, automated_planner, heuristic_key):
             heuristic_key = "delete_relaxation/h_add"
 
         self.current_h = heuristic_key
+        self.has_been_precomputed = False
+        self.__pre_compute()
+        # return self.heuristic_keys[self.current_h](state)
 
-    def compute(self, state):
-        return self.heuristic_keys[self.current_h](state)
+    def compute(self, state, goals):
+        if not self.has_been_precomputed:
+            self.__pre_compute()
+        domain = self.cache.domain
+        goals = self.automated_planner.goals
+        types = state.types 
+        facts = state.facts 
+
+        fact_costs = dict([(f, 0) for f in facts])
+        while not(len(fact_costs) == len(facts) and self.__facts_eq(fact_costs, facts)):
+            facts_set = self.automated_planner.pddl.Set(self.automated_planner.pddl.keys(fact_costs))
+            state = self.automated_planner.pddl.create_state(types, facts_set)
+            if self.automated_planner.satisfies(goals, state):
+                costs = [fact_costs[g] for g in goals]
+                costs.insert(0, 0)
+                return self.heuristic_keys[self.current_h](costs)
+            
+            for ax in self.cache.axioms:
+                pass
 
     def __pre_compute(self):
-        logging.fatal("Delete relaxation h_add is not yet implemented")
-        exit()
+        if self.has_been_precomputed:
+            return
+        domain = self.automated_planner.domain
+        domain, axioms = self.automated_planner.pddl.compute_hsp_axioms(domain)
+        preconditions = dict()
+        additions = dict()
+        for name, definition in domain.actions.items():
+            precond = self.automated_planner.pddl.filter_negative_preconds(definition)
+            preconditions[name] = precond
+            additions[name] = self.automated_planner.pddl.effect_diff(definition.effect).add
+        self.cache.additions = additions
+        self.cache.preconds = preconditions
+        self.cache.domain = domain
+        self.cache.axioms = axioms
+        
+
+    def __h_add(self, costs):
+        return sum(costs)
 
-    def __cache(self):
-        logging.fatal("Delete relaxation h_add is not yet implemented")
-        exit()
+    def __h_max(self, costs):
+        return max(costs)
 
-    def __h_add(self, state):
-        logging.fatal("Delete relaxation h_add is not yet implemented")
-        exit()
+    def __facts_eq(self, facts_dict, facts_set):
+        for f in facts_set:
+            if not(f in facts_dict.keys()):
+                return False
+        return True
 
-    def __h_max(self, state):
-        logging.fatal("Delete relaxation h_max is not yet implemented")
-        exit()