add delete relaxation heuristics

Author: guilyx

jupyddl/data_analyst.py

@@ -19,7 +19,7 @@
 class DataAnalyst:
     def __init__(self):
         logging.info("Instantiating data analyst...")
-        self.available_heuristics = ["basic/goal_count", "basic/zero"]
+        self.available_heuristics = ["basic/goal_count", "basic/zero", "delete_relaxation/h_add", "delete_relaxation/h_max"]
 
     def __get_all_pddl_from_data(self, max_pddl_instances=-1):
         tested_files = []
@@ -84,7 +84,7 @@ def __gather_data_astar(
             for problem, domain in self.__get_all_pddl_from_data(
                 max_pddl_instances=max_pddl_instances
             ):
-                logging.debug("Loading new PDDL instance planned with A*...")
+                logging.debug("Loading new PDDL instance planned with A* [ " + heuristic_key + " ]")
                 logging.debug("Domain: " + domain)
                 logging.debug("Problem: " + problem)
                 apla = AutomatedPlanner(domain, problem)

jupyddl/heuristics.py

@@ -58,24 +58,29 @@ def compute(self, state):
         goals = self.automated_planner.goals
         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)):
             facts, state = self.automated_planner.pddl.get_facts_and_state(fact_costs, types)
             if self.automated_planner.satisfies(goals, state):
-                costs = [fact_costs[g] for g in goals]
+                costs = []
+                fact_costs_str = dict( [(str(k), val) for k, val in fact_costs.items()] )
+                for g in goals:
+                    if str(g) in fact_costs_str:
+                        costs.append(fact_costs_str[str(g)])
                 costs.insert(0, 0)
                 return self.heuristic_keys[self.current_h](costs)
 
             for ax in self.cache.axioms:
-                fact_costs = self.automated_planner.pddl.compute_costs_one_step_derivatiion(
+                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.preconds, self.cache.additions, self.current_h
+                    fact_costs, act, domain, self.cache.additions, self.current_h
                 )
         return float("inf")
 
@@ -84,14 +89,13 @@ def __pre_compute(self):
             return
         domain = self.automated_planner.domain
         domain, axioms = self.automated_planner.pddl.compute_hsp_axioms(domain)
-        preconditions = dict()
+        # preconditions = dict()
         additions = dict()
+        self.automated_planner.pddl.cache_global_preconditions(domain)
         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.preconds = self.automated_planner.pddl.g_preconditions
         self.cache.domain = domain
         self.cache.axioms = axioms
         self.has_been_precomputed = True

pddl-examples

@@ -6,24 +6,32 @@
 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
 
-
-def test_astar_init():
+def test_astar_basic():
     apla = AutomatedPlanner(
         "pddl-examples/flip/domain.pddl", "pddl-examples/flip/problem.pddl"
     )
-    astar = AStarBestFirstSearch(apla, apla.available_heuristics["basic/goal_count"])
-    assert astar.init.h_cost == apla.available_heuristics["basic/goal_count"](
-        apla.initial_state, apla
-    )
+    heuristic = BasicHeuristic(apla, "basic/goal_count")
+    astar = AStarBestFirstSearch(apla, heuristic.compute)
+    assert astar.init.h_cost == heuristic.compute(apla.initial_state)
 
+def test_astar_delete_relaxation():
+    apla = AutomatedPlanner(
+        "pddl-examples/flip/domain.pddl", "pddl-examples/flip/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/flip/domain.pddl", "pddl-examples/flip/problem.pddl"
     )
-    path, _, _ = apla.astar_best_first_search()
-    assert apla.available_heuristics["basic/goal_count"](path[-1].state, apla) == 0
+    heuristic = BasicHeuristic(apla, "basic/goal_count")
+    astar = AStarBestFirstSearch(apla, heuristic.compute)
+    path, _, _ = astar.search()
+    assert heuristic.compute(path[-1].state) == 0
 
 
 def test_astar_path_length():

tests/test_astar.py

@@ -2,13 +2,14 @@
 from jupyddl.dijkstra import DijkstraBestFirstSearch
 from jupyddl.a_star import AStarBestFirstSearch
 from jupyddl.bfs import BreadthFirstSearch
+from jupyddl.heuristics import BasicHeuristic, DeleteRelaxationHeuristic
 from jupyddl.dfs import DepthFirstSearch
 from os import path
 import coloredlogs
 import sys
 
 
-def test_searchDFS():
+def test_search_dfs():
     apla = AutomatedPlanner(
         "pddl-examples/dinner/domain.pddl", "pddl-examples/dinner/problem.pddl"
     )
@@ -17,7 +18,7 @@ def test_searchDFS():
     assert res[1] != 0  # Path, computation time, opened nodes
 
 
-def test_searchBFS():
+def test_search_bfs():
     apla = AutomatedPlanner(
         "pddl-examples/flip/domain.pddl", "pddl-examples/flip/problem.pddl"
     )
@@ -26,7 +27,7 @@ def test_searchBFS():
     assert res[1] != 0
 
 
-def test_searchDijkstra():
+def test_search_dijkstra():
     apla = AutomatedPlanner(
         "pddl-examples/dinner/domain.pddl", "pddl-examples/dinner/problem.pddl"
     )
@@ -36,11 +37,23 @@ def test_searchDijkstra():
     assert res[-1] > 0  # Assert that it visited some nodes
 
 
-def test_searchAStar():
+def test_search_astar_basic():
     apla = AutomatedPlanner(
         "pddl-examples/dinner/domain.pddl", "pddl-examples/dinner/problem.pddl"
     )
-    astar = AStarBestFirstSearch(apla, apla.available_heuristics["basic/goal_count"])
+    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
+
+def test_search_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)
+    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
+

tests/test_search.py

@@ -0,0 +1,18 @@
+# -*- 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_delete_relaxation():
+    apla = AutomatedPlanner(
+        "pddl-examples/tsp/domain.pddl", "pddl-examples/tsp/problem.pddl"
+    )
+    heuristic = DeleteRelaxationHeuristic(apla, "delete_relaxation/h_max")
+    astar = AStarBestFirstSearch(apla, heuristic.compute)   
+    astar.search()
+    assert astar.init.h_cost == heuristic.compute(apla.initial_state)