Merge pull request #83 from APLA-Toolbox/safe-hsp-heuristics

Safer HSP Heuristics

Author: guilyx

jupyddl/automated_planner.py

@@ -64,7 +64,14 @@ def transition(self, state, action):
         return self.pddl.transition(self.domain, state, action, check=False)
 
     def available_actions(self, state):
-        return self.pddl.available(state, self.domain)
+        try:
+            return self.pddl.available(state, self.domain)
+        except (RuntimeError, TypeError, NameError):
+            self.logger.warning(
+                "Runtime, Type or Name error occured when fetching available action from state"
+                + str(state)
+            )
+            return []
 
     def satisfies(self, asserted_state, state):
         return self.pddl.satisfy(asserted_state, state, self.domain)[0]
@@ -137,7 +144,7 @@ def astar_best_first_search(self, heuristic_key="basic/goal_count"):
             heuristic = DeleteRelaxationHeuristic(self, heuristic_key)
         else:
             logging.fatal("Not yet implemented")
-            exit()
+            return [], 0, 0
         astar = AStarBestFirstSearch(self, heuristic.compute)
         last_node, total_time, opened_nodes = astar.search()
         path = self.__retrace_path(last_node)

jupyddl/data_analyst.py

@@ -367,10 +367,7 @@ def comparative_astar_heuristic_plot(
                 times_y.append(data[node_opened])
 
             ax.plot(
-                nodes_sorted,
-                times_y,
-                "-o",
-                label=h,
+                nodes_sorted, times_y, "-o", label=h,
             )
 
         plt.title("A* heuristics complexity comparison")
@@ -442,10 +439,7 @@ def comparative_data_plot(
             for node_opened in nodes_sorted:
                 times_y.append(data[node_opened])
             ax.plot(
-                nodes_sorted,
-                times_y,
-                "-o",
-                label=planner,
+                nodes_sorted, times_y, "-o", label=planner,
             )
         plt.title("Planners complexity comparison")
         plt.legend(loc="upper left")

jupyddl/heuristics.py

@@ -64,10 +64,7 @@ def compute(self, state):
         types = state.types
         facts = state.facts
         fact_costs = self.automated_planner.pddl.init_facts_costs(facts)
-        while not (
-            len(fact_costs) == self.automated_planner.pddl.length(facts)
-            and self.__facts_eq(fact_costs, facts)
-        ):
+        while True:
             facts, state = self.automated_planner.pddl.get_facts_and_state(
                 fact_costs, types
             )
@@ -81,19 +78,21 @@ def compute(self, state):
                 return self.heuristic_keys[self.current_h](costs)
 
             for ax in self.cache.axioms:
-                fact_costs = (
-                    self.automated_planner.pddl.compute_costs_one_step_derivation(
-                        facts, fact_costs, ax, self.current_h
-                    )
+                fact_costs = self.automated_planner.pddl.compute_costs_one_step_derivation(
+                    facts, fact_costs, ax, self.current_h
                 )
 
             actions = self.automated_planner.available_actions(state)
-            if not actions:
-                break
             for act in actions:
                 fact_costs = self.automated_planner.pddl.compute_cost_action_effect(
                     fact_costs, act, domain, self.cache.additions, self.current_h
                 )
+
+            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):
@@ -121,7 +120,8 @@ 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 (f in facts_dict.keys()):
+            if not (str(f) in fact_costs_str.keys()):
                 return False
         return True

pddl-examples

@@ -44,3 +44,40 @@ def test_state_assertion():
         "pddl-examples/dinner/domain.pddl", "pddl-examples/dinner/problem.pddl"
     )
     assert not apla.satisfies(apla.problem.goal, apla.initial_state)
+
+def test_bfs():
+    apla = AutomatedPlanner(
+        "pddl-examples/dinner/domain.pddl", "pddl-examples/dinner/problem.pddl"
+    )
+    path, _, _ = apla.breadth_first_search()
+    plan = apla.get_actions_from_path(path)
+    plan_state = apla.get_state_def_from_path(path)
+    assert plan and plan_state
+
+def test_dfs():
+    apla = AutomatedPlanner(
+        "pddl-examples/dinner/domain.pddl", "pddl-examples/dinner/problem.pddl"
+    )
+    path, _, _ = apla.depth_first_search()
+    plan = apla.get_actions_from_path(path)
+    plan_state = apla.get_state_def_from_path(path)
+    assert plan and plan_state
+
+def test_dij():
+    apla = AutomatedPlanner(
+        "pddl-examples/dinner/domain.pddl", "pddl-examples/dinner/problem.pddl"
+    )
+    path, _, _ = apla.dijktra_best_first_search()
+    plan = apla.get_actions_from_path(path)
+    plan_state = apla.get_state_def_from_path(path)
+    assert plan and plan_state
+
+
+def test_astar():
+    apla = AutomatedPlanner(
+        "pddl-examples/dinner/domain.pddl", "pddl-examples/dinner/problem.pddl"
+    )
+    path, _, _ = apla.astar_best_first_search()
+    plan = apla.get_actions_from_path(path)
+    plan_state = apla.get_state_def_from_path(path)
+    assert plan and plan_state

tests/test_automated_planner.py

@@ -6,7 +6,7 @@
 sys.path.append(path.dirname(path.dirname(path.abspath(__file__))))
 from jupyddl.automated_planner import AutomatedPlanner
 from jupyddl.a_star import AStarBestFirstSearch
-from jupyddl.heuristics import DeleteRelaxationHeuristic, BasicHeuristic
+from jupyddl.heuristics import BasicHeuristic
 
 
 def test_astar_basic():
@@ -18,15 +18,6 @@ def test_astar_basic():
     assert astar.init.h_cost == heuristic.compute(apla.initial_state)
 
 
-def test_astar_delete_relaxation():
-    apla = AutomatedPlanner(
-        "pddl-examples/dinner/domain.pddl", "pddl-examples/dinner/problem.pddl"
-    )
-    heuristic = DeleteRelaxationHeuristic(apla, "delete_relaxation/h_max")
-    astar = AStarBestFirstSearch(apla, heuristic.compute)
-    assert astar.init.h_cost == heuristic.compute(apla.initial_state)
-
-
 def test_astar_goal():
     apla = AutomatedPlanner(
         "pddl-examples/dinner/domain.pddl", "pddl-examples/dinner/problem.pddl"
@@ -43,3 +34,19 @@ def test_astar_path_length():
     )
     path, _, _ = apla.astar_best_first_search()
     assert len(path) > 0
+
+
+def test_astar_path_no_path():
+    apla = AutomatedPlanner(
+        "pddl-examples/vehicle/domain.pddl", "pddl-examples/vehicle/problem.pddl"
+    )
+    path, _, _ = apla.astar_best_first_search()
+    assert len(path) == 0
+
+
+def test_astar_path_no_heuristic():
+    apla = AutomatedPlanner(
+        "pddl-examples/flip/domain.pddl", "pddl-examples/flip/problem.pddl"
+    )
+    p, t, c = apla.astar_best_first_search(heuristic_key="idontexist")
+    assert not p and not t and not c

tests/test_astar.py tests/test_basic_astar.pytests/test_astar.py renamed to tests/test_basic_astar.py

@@ -1,5 +1,5 @@
 from jupyddl.automated_planner import AutomatedPlanner
-from jupyddl.dijkstra import DijkstraBestFirstSearch
+from jupyddl.dijkstra import DijkstraBestFirstSearch, zero_heuristic
 from jupyddl.a_star import AStarBestFirstSearch
 from jupyddl.bfs import BreadthFirstSearch
 from jupyddl.heuristics import BasicHeuristic, DeleteRelaxationHeuristic
@@ -37,6 +37,33 @@ def test_search_dijkstra():
     assert res[-1] > 0  # Assert that it visited some nodes
 
 
+def test_search_dijkstra_no_path():
+    apla = AutomatedPlanner(
+        "pddl-examples/vehicle/domain.pddl", "pddl-examples/vehicle/problem.pddl"
+    )
+    dijk = DijkstraBestFirstSearch(apla)
+    res = dijk.search()  # Goal, computation_time, opened_nodes(in this order)
+    assert not res[0]
+
+
+def test_search_dfs_no_path():
+    apla = AutomatedPlanner(
+        "pddl-examples/vehicle/domain.pddl", "pddl-examples/vehicle/problem.pddl"
+    )
+    dfs = DepthFirstSearch(apla)
+    res = dfs.search()  # Goal, computation_time, opened_nodes(in this order)
+    assert not res[0]
+
+
+def test_search_bfs_no_path():
+    apla = AutomatedPlanner(
+        "pddl-examples/vehicle/domain.pddl", "pddl-examples/vehicle/problem.pddl"
+    )
+    bfs = BreadthFirstSearch(apla)
+    res = bfs.search()  # Goal, computation_time, opened_nodes(in this order)
+    assert not res[0]
+
+
 def test_search_astar_basic():
     apla = AutomatedPlanner(
         "pddl-examples/dinner/domain.pddl", "pddl-examples/dinner/problem.pddl"
@@ -48,12 +75,16 @@ def test_search_astar_basic():
     assert res[-1] > 0  # Assert that it visited at least one node
 
 
-def test_search_astar_delete_relaxation():
+def test_search_astar_basic_no_path():
     apla = AutomatedPlanner(
-        "pddl-examples/dinner/domain.pddl", "pddl-examples/dinner/problem.pddl"
+        "pddl-examples/vehicle/domain.pddl", "pddl-examples/vehicle/problem.pddl"
     )
-    heuristic = DeleteRelaxationHeuristic(apla, "delete_relaxation/h_max")
+    heuristic = BasicHeuristic(apla, "basic/goal_count")
     astar = AStarBestFirstSearch(apla, heuristic.compute)
     res = astar.search()  # Goal, computation_time, opened_nodes(in this order)
-    assert res[1] != 0  # Assert that it took time to compute
-    assert res[-1] > 0  # Assert that it visited at least one node
+    assert not res[0]
+
+
+def test_zero_heuristic():
+    assert zero_heuristic() == 0
+    

tests/test_search.py tests/test_basic_search.pytests/test_search.py renamed to tests/test_basic_search.py

@@ -18,6 +18,7 @@ def test_zero_heuristic():
     apla = AutomatedPlanner(
         "pddl-examples/dinner/domain.pddl", "pddl-examples/dinner/problem.pddl"
     )
+    apla.display_available_heuristics()
     heuristic = hs.BasicHeuristic(apla, "basic/zero")
     h = heuristic.compute(apla.initial_state)
     assert h == 0
@@ -27,6 +28,7 @@ def test_goal_count_heuristic():
     apla = AutomatedPlanner(
         "pddl-examples/dinner/domain.pddl", "pddl-examples/dinner/problem.pddl"
     )
+    apla.display_available_heuristics()
     heuristic = hs.BasicHeuristic(apla, "basic/goal_count")
     h = heuristic.compute(apla.initial_state)
     assert h != 0
@@ -36,6 +38,7 @@ def test_delete_relaxation_add_heuristic():
     apla = AutomatedPlanner(
         "pddl-examples/tsp/domain.pddl", "pddl-examples/tsp/problem.pddl"
     )
+    apla.display_available_heuristics()
     heuristic = hs.DeleteRelaxationHeuristic(apla, "delete_relaxation/h_max")
     h = heuristic.compute(apla.initial_state)
     assert h != 0

tests/test_heuristics.py

@@ -0,0 +1,45 @@
+# -*- coding: utf-8 -*-
+
+import sys
+from os import path
+
+sys.path.append(path.dirname(path.dirname(path.abspath(__file__))))
+from jupyddl.automated_planner import AutomatedPlanner
+from jupyddl.a_star import AStarBestFirstSearch
+from jupyddl.heuristics import DeleteRelaxationHeuristic
+
+
+def test_astar_hmax():
+    apla = AutomatedPlanner(
+        "pddl-examples/dinner/domain.pddl", "pddl-examples/dinner/problem.pddl"
+    )
+    heuristic = DeleteRelaxationHeuristic(apla, "delete_relaxation/h_max")
+    astar = AStarBestFirstSearch(apla, heuristic.compute)
+    assert astar.init.h_cost == heuristic.compute(apla.initial_state)
+
+
+def test_astar_hadd():
+    apla = AutomatedPlanner(
+        "pddl-examples/dinner/domain.pddl", "pddl-examples/dinner/problem.pddl"
+    )
+    heuristic = DeleteRelaxationHeuristic(apla, "delete_relaxation/h_max")
+    astar = AStarBestFirstSearch(apla, heuristic.compute)
+    assert astar.init.h_cost == heuristic.compute(apla.initial_state)
+
+
+def test_astar_hmax_sensible_domain():
+    apla = AutomatedPlanner(
+        "pddl-examples/grid/domain.pddl", "pddl-examples/grid/problem.pddl"
+    )
+    heuristic = DeleteRelaxationHeuristic(apla, "delete_relaxation/h_max")
+    astar = AStarBestFirstSearch(apla, heuristic.compute)
+    assert astar.init.h_cost == heuristic.compute(apla.initial_state)
+
+
+def test_astar_hadd_sensible_domain():
+    apla = AutomatedPlanner(
+        "pddl-examples/grid/domain.pddl", "pddl-examples/grid/problem.pddl"
+    )
+    heuristic = DeleteRelaxationHeuristic(apla, "delete_relaxation/h_max")
+    astar = AStarBestFirstSearch(apla, heuristic.compute)
+    assert astar.init.h_cost == heuristic.compute(apla.initial_state)

tests/test_hsp_astar.py

@@ -0,0 +1,38 @@
+# -*- coding: utf-8 -*-
+
+import sys
+from os import path
+
+sys.path.append(path.dirname(path.dirname(path.abspath(__file__))))
+from jupyddl.automated_planner import AutomatedPlanner
+from jupyddl.node import Node
+
+
+def test_node_equality_cost():
+    apla = AutomatedPlanner(
+        "pddl-examples/tsp/domain.pddl", "pddl-examples/tsp/problem.pddl"
+    )
+    actions = apla.available_actions(apla.initial_state)
+    next_state = apla.transition(apla.initial_state, actions[0])
+    next_node = Node(next_state, apla, heuristic_based=True)
+    next_node_v2 = Node(next_state, apla)
+
+    assertion = next_node_v2 < next_node
+    assertion2 = next_node < next_node_v2
+
+    assert assertion and assertion2
+
+
+def test_node_equality_no_cost():
+    apla = AutomatedPlanner(
+        "pddl-examples/dinner/domain.pddl", "pddl-examples/dinner/problem.pddl"
+    )
+    actions = apla.available_actions(apla.initial_state)
+    next_state = apla.transition(apla.initial_state, actions[0])
+    next_node = Node(next_state, apla, heuristic_based=True)
+    next_node_v2 = Node(next_state, apla)
+
+    assertion = next_node_v2 < next_node
+    assertion2 = next_node < next_node_v2
+
+    assert assertion and assertion2