add critical path to data analysis

Author: guilyx

README.md

@@ -21,6 +21,7 @@ A Python wrapper using JuliaPy for the PDDL.jl parser package and implementing i
 - A*
     - Goal Count Heuristic
     - Delete Relaxation Heuristics (Hmax, Hadd)
+    - Critical Path Heuristic
 
 # Dependencies
 

jupyddl/automated_planner.py

@@ -4,7 +4,7 @@
 from .a_star import AStarBestFirstSearch
 from .greedy_best_first import GreedyBestFirstSearch
 from .metrics import Metrics
-from .heuristics import BasicHeuristic, DeleteRelaxationHeuristic
+from .heuristics import BasicHeuristic, DeleteRelaxationHeuristic, CriticalPathHeuristic
 import coloredlogs
 import logging
 import julia
@@ -27,10 +27,9 @@ def __init__(self, domain_path, problem_path, log_level="DEBUG"):
         self.initial_state = self.pddl.initialize(self.problem)
         self.goals = self.__flatten_goal()
         self.available_heuristics = [
-            "basic/zero",
-            "basic/goal_count",
-            "delete_relaxation/h_add",
-            "delete_relaxation/h_max",
+            "basic/zero", "basic/goal_count",
+            "delete_relaxation/h_add", "delete_relaxation/h_max",
+            "critical_path/1", "critical_path/2", "critical_path/3",
         ]
 
         # Logger
@@ -158,6 +157,8 @@ def astar_best_first_search(
             heuristic = BasicHeuristic(self, heuristic_key)
         elif "delete_relaxation" in heuristic_key:
             heuristic = DeleteRelaxationHeuristic(self, heuristic_key)
+        elif "critical_path" in heuristic_key:
+            heuristic = CriticalPathHeuristic(self, int(heuristic_key[-1]))
         else:
             logging.fatal("Not yet implemented")
             return [], Metrics()
@@ -178,6 +179,8 @@ def greedy_best_first_search(
             heuristic = BasicHeuristic(self, "basic/goal_count")
         elif "delete_relaxation" in heuristic_key:
             heuristic = DeleteRelaxationHeuristic(self, heuristic_key)
+        elif "critical_path" in heuristic_key:
+            heuristic = CriticalPathHeuristic(self, int(heuristic_key[-1]))
         else:
             logging.fatal("Not yet implemented")
             return [], Metrics()

jupyddl/data_analyst.py

@@ -642,6 +642,8 @@ def plot_metrics(self):
         metrics_dict["A* [Goal_Count]"] = []
         metrics_dict["A* [H_Add]"] = []
         metrics_dict["A* [H_Max]"] = []
+        metrics_dict["A* [Critical_Path (H2)]"] = []
+        metrics_dict["A* [Critical_Path (H3)]"] = []
         logging.debug("Computation of all metrics for all domains registered...")
         for problem, domain in self.__get_all_pddl_from_data():
             logging.debug("Loading new PDDL instance planned with Dijkstra...")
@@ -660,20 +662,28 @@ def plot_metrics(self):
             _, metrics_dfs = apla.depth_first_search(
                 node_bound=metrics_bfs.n_opened * 2
             )
+            _, metrics_cp2 = apla.astar_best_first_search(
+                heuristic_key="critical_path/2"
+            )
+            _, metrics_cp3 = apla.astar_best_first_search(
+                heuristic_key="critical_path/3"
+            )
             metrics_dict["A* [Zero]"].append(metrics_dij)
             metrics_dict["DFS"].append(metrics_dfs)
             metrics_dict["BFS"].append(metrics_bfs)
             metrics_dict["A* [Goal_Count]"].append(metrics_agc)
             metrics_dict["A* [H_Add]"].append(metrics_ahadd)
             metrics_dict["A* [H_Max]"].append(metrics_ahmax)
+            metrics_dict["A* [Critical_Path (H2)]"].append(metrics_cp2)
+            metrics_dict["A* [Critical_Path (H3)]"].append(metrics_cp3)
 
         plot_dict = dict()
 
         for key, val in metrics_dict.items():
             plot_dict[key] = dict()
             plot_dict[key]["Search Runtime (s)"] = [m.runtime for m in val]
-            plot_dict[key]["Heuristics Average Runtime (s)"] = [
-                m.get_average_heuristic_runtime() for m in val
+            plot_dict[key]["Total Heuristics Runtime (s)"] = [
+                sum(m.heuristic_runtimes) for m in val
             ]
             plot_dict[key]["Number of Expanded Nodes"] = [m.n_expended for m in val]
             plot_dict[key]["Number of Opened Nodes"] = [m.n_opened for m in val]

jupyddl/heuristics.py

@@ -29,7 +29,6 @@ def __goal_count_heuristic(self, state):
                 count += 1
         return count
 
-
 class DeleteRelaxationHeuristic:
     def __init__(self, automated_planner, heuristic_key):
         class DRHCache:
@@ -127,3 +126,109 @@ def __facts_eq(self, facts_dict, facts_set):
             if not (str(f) in fact_costs_str.keys()):
                 return False
         return True
+
+class CriticalPathHeuristic:
+    def __init__(self, automated_planner, critical_path_level=1):
+        class CPCache:
+            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 = CPCache()
+        if critical_path_level > 3:
+            logging.warning("Critical Path level is only implemented until 3, forcing it to 3.")
+            self.critical_path_level = 3
+        if critical_path_level < 1:
+            logging.warning("Critical Path level has to be at least 1, forcing it to 1.")
+            self.critical_path_level = 1
+        else:
+            self.critical_path_level = critical_path_level
+        self.has_been_precomputed = False
+        self.__pre_compute()
+        # return self.heuristic_keys[self.current_h](state)
+
+    def compute(self, state):
+        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 = self.automated_planner.pddl.init_facts_costs(facts)
+        while True:
+            facts, state = self.automated_planner.pddl.get_facts_and_state(
+                fact_costs, types
+            )
+            if self.automated_planner.satisfies(goals, state):
+                costs = []
+                fact_costs_str = dict([(str(k), val) for k, val in fact_costs.items()])
+                if self.critical_path_level == 1:
+                    for g in goals:
+                        if str(g) in fact_costs_str:
+                            costs.append(fact_costs_str[str(g)])
+                if self.critical_path_level == 2:
+                    pairs_of_goals = [(g1, g2) for g1 in goals for g2 in goals if g1 != g2]
+                    for gs in pairs_of_goals:
+                        if str(gs[0]) in fact_costs_str and str(gs[1]) in fact_costs_str:
+                            costs.append(fact_costs_str[str(gs[0])] + fact_costs_str[str(gs[1])])
+                if self.critical_path_level == 3:
+                    triplets_of_goals = [(g1, g2, g3) for g1 in goals for g2 in goals for g3 in goals if g1 != g2 and g1 != g3 and g2 != g3]
+                    for gs in triplets_of_goals:
+                        if str(gs[0]) in fact_costs_str and str(gs[1]) in fact_costs_str and str(gs[2]) in fact_costs_str:
+                            costs.append(fact_costs_str[str(gs[0])] + fact_costs_str[str(gs[1])] + fact_costs_str[str(gs[2])])
+                costs.insert(0, 0)
+                return max(costs)
+
+            for ax in self.cache.axioms:
+                fact_costs = (
+                    self.automated_planner.pddl.compute_costs_one_step_derivation(
+                        facts, fact_costs, ax, "max"
+                    )
+                )
+
+            actions = self.automated_planner.available_actions(state)
+            for act in actions:
+                fact_costs = self.automated_planner.pddl.compute_cost_action_effect(
+                    fact_costs, act, domain, self.cache.additions, "max"
+                )
+
+            if len(fact_costs) == self.automated_planner.pddl.length(
+                facts
+            ) and self.__facts_eq(fact_costs, facts):
+                break
+
+        return float("inf")
+
+    def __pre_compute(self):
+        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()
+        self.automated_planner.pddl.cache_global_preconditions(domain)
+        for name, definition in domain.actions.items():
+            additions[name] = self.automated_planner.pddl.effect_diff(
+                definition.effect
+            ).add
+        self.cache.additions = additions
+        self.cache.preconds = self.automated_planner.pddl.g_preconditions
+        self.cache.domain = domain
+        self.cache.axioms = axioms
+        self.has_been_precomputed = True
+
+    def __h_add(self, costs):
+        return sum(costs)
+
+    def __h_max(self, costs):
+        return max(costs)
+
+    def __facts_eq(self, facts_dict, facts_set):
+        fact_costs_str = dict([(str(k), val) for k, val in facts_dict.items()])
+        for f in facts_set:
+            if not (str(f) in fact_costs_str.keys()):
+                return False
+        return True

jupyddl/metrics.py

@@ -17,12 +17,12 @@ def get_average_heuristic_runtime(self):
 
     def __str__(self):
         if self.heuristic_runtimes:
-            av = self.get_average_heuristic_runtime()
-            w = av / sum(self.heuristic_runtimes) * 100
+            av = sum(self.heuristic_runtimes)
+            w = sum(self.heuristic_runtimes) / self.runtime * 100
         else:
             av = 0
             w = 0
-        return "Expanded %d state(s).\nOpened %d state(s).\nReopened %d state(s).\nEvaluated %d state(s).\nGenerated %d state(s).\nDead ends: %d state(s).\nRuntime: %.2fs.\nAverage heuristic runtime: %.2fs\nComputational weight of heuristic in the search: %.2f%%" % (
+        return "Expanded %d state(s).\nOpened %d state(s).\nReopened %d state(s).\nEvaluated %d state(s).\nGenerated %d state(s).\nDead ends: %d state(s).\nRuntime: %.2fs.\nTotal heuristic runtime: %.2fs\nComputational weight of heuristic in the search: %.2f%%" % (
             self.n_expended,
             self.n_opened,
             self.n_reopened,

tests/test_automated_planner.py

@@ -2,7 +2,6 @@
 
 import sys
 from os import path
-
 sys.path.append(path.dirname(path.dirname(path.abspath(__file__))))
 from jupyddl.automated_planner import AutomatedPlanner