update heuristics architecture

Author: guilyx

README.md

@@ -104,15 +104,15 @@ da.plot_astar() # plots complexity statistics for all the problem.pddl/domain.pd
 
 da.plot_astar(problem="pddl-examples/flip/problem.pddl", domain="pddl-examples/flip/domain.pddl") # scatter complexity statistics for the provided pddl
 
-da.plot_astar(heuristic_key="zero") # use h=0 instead of goal_count for your computation
+da.plot_astar(heuristic_key="basic/zero") # use h=0 instead of goal_count for your computation
 
 da.plot_dfs() # same as astar
 
 da.comparative_data_plot() # Run all planners on the pddl-examples folder and plots them on the same figure, data is stored in a data.json file 
 
 da.comparative_data_plot(astar=False) # Exclude astar from the comparative plot
 
-da.comparative_data_plot(heuristic_key="zero") # use zero heuristic for h based planners
+da.comparative_data_plot(heuristic_key="basic/zero") # use zero heuristic for h based planners
 
 da.comparative_data_plot(collect_new_data=False) # uses data.json to plot the data
 ```

jupyddl/a_star.py

@@ -1,4 +1,3 @@
-from .heuristics import zero_heuristic
 from .node import Node
 import logging
 import math

jupyddl/automated_planner.py

@@ -2,7 +2,7 @@
 from .dfs import DepthFirstSearch
 from .dijkstra import DijkstraBestFirstSearch
 from .a_star import AStarBestFirstSearch
-from .heuristics import goal_count_heuristic, zero_heuristic
+from .heuristics import BasicHeuristic
 import coloredlogs
 import logging
 import julia
@@ -22,9 +22,10 @@ def __init__(self, domain_path, problem_path, log_level="DEBUG"):
         self.problem = self.pddl.load_problem(problem_path)
         self.initial_state = self.pddl.initialize(self.problem)
         self.goals = self.__flatten_goal()
-        self.available_heuristics = dict()
-        self.available_heuristics["goal_count"] = goal_count_heuristic
-        self.available_heuristics["zero"] = zero_heuristic
+        self.available_heuristics = [
+            "basic/zero",
+            "basic/goal_count"
+        ]
 
         # Logger
         self.__init_logger(log_level)
@@ -40,6 +41,8 @@ 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
 
@@ -53,7 +56,7 @@ def __init_logger(self, log_level):
         )
 
     def display_available_heuristics(self):
-        print(list(self.available_heuristics.keys()))
+        print(self.available_heuristics)
 
     def transition(self, state, action):
         return self.pddl.transition(self.domain, state, action, check=False)
@@ -125,8 +128,13 @@ def dijktra_best_first_search(self):
 
         return path, total_time, opened_nodes
 
-    def astar_best_first_search(self, heuristic=goal_count_heuristic):
-        astar = AStarBestFirstSearch(self, heuristic)
+    def astar_best_first_search(self, heuristic_key="basic/goal_count"):
+        if "basic" in heuristic_key:
+            heuristic = BasicHeuristic(self, heuristic_key)
+        else: 
+            logging.fatal("Not yet implemented")
+            exit()
+        astar = AStarBestFirstSearch(self, heuristic.compute)
         last_node, total_time, opened_nodes = astar.search()
         path = self.__retrace_path(last_node)
 

jupyddl/data_analyst.py

@@ -19,7 +19,7 @@
 class DataAnalyst:
     def __init__(self):
         logging.info("Instantiating data analyst...")
-        self.available_heuristics = ["goal_count", "zero"]
+        self.available_heuristics = ["basic/goal_count", "basic/zero"]
 
     def __get_all_pddl_from_data(self, max_pddl_instances=-1):
         tested_files = []
@@ -75,7 +75,7 @@ def __gather_data_astar(
         self,
         domain_path="",
         problem_path="",
-        heuristic_key="goal_count",
+        heuristic_key="basic/goal_count",
         max_pddl_instances=-1,
     ):
         has_multiple_files_tested = True
@@ -90,7 +90,7 @@ def __gather_data_astar(
                 apla = AutomatedPlanner(domain, problem)
                 if heuristic_key in apla.available_heuristics:
                     path, total_time, opened_nodes = apla.astar_best_first_search(
-                        heuristic=apla.available_heuristics[heuristic_key]
+                        heuristic_key=heuristic_key
                     )
                 else:
                     logging.critical(
@@ -112,7 +112,7 @@ def __gather_data_astar(
         apla = AutomatedPlanner(domain_path, problem_path)
         if heuristic_key in apla.available_heuristics:
             path, total_time, opened_nodes = apla.astar_best_first_search(
-                heuristic=apla.available_heuristics[heuristic_key]
+                heuristic_key=heuristic_key
             )
         else:
             logging.critical(
@@ -124,7 +124,7 @@ def __gather_data_astar(
         return [0], [0], has_multiple_files_tested
 
     def plot_astar(
-        self, heuristic_key="goal_count", domain="", problem="", max_pddl_instances=-1
+        self, heuristic_key="basic/goal_count", domain="", problem="", max_pddl_instances=-1
     ):
         if bool(not problem) != bool(not domain):
             logging.warning(
@@ -288,7 +288,7 @@ def plot_dijkstra(self, problem="", domain="", max_pddl_instances=-1):
 
     def __gather_data(
         self,
-        heuristic_key="goal_count",
+        heuristic_key="basic/goal_count",
         astar=True,
         bfs=True,
         dfs=True,
@@ -374,7 +374,7 @@ def comparative_data_plot(
         dijkstra=True,
         domain="",
         problem="",
-        heuristic_key="goal_count",
+        heuristic_key="basic/goal_count",
         collect_new_data=True,
         max_pddl_instances=-1,
     ):

jupyddl/dijkstra.py

@@ -1,11 +1,11 @@
-from .heuristics import zero_heuristic
 from .node import Node
 import logging
 import math
 from datetime import datetime as timestamp
 from time import time as now
 
-
+def zero_heuristic():
+    return 0
 class DijkstraBestFirstSearch:
     def __init__(self, automated_planner):
         self.automated_planner = automated_planner

jupyddl/heuristics.py

@@ -1,10 +1,60 @@
-def zero_heuristic(state, automated_planner):
-    return 0
+import logging
 
+class BasicHeuristic:
+    def __init__(self, automated_planner, heuristic_key):
+        self.automated_planner = automated_planner
+        self.heuristic_keys = {
+            "basic/zero": self.__zero_heuristic,
+            "basic/goal_count": self.__goal_count_heuristic
+        }
+        if heuristic_key not in list(self.heuristic_keys.keys()):
+            logging.warning("Heuristic key isn't registered, forcing it to [basic/goal_count]")
+            heuristic_key = "basic/goal_count"
 
-def goal_count_heuristic(state, automated_planner):
-    count = 0
-    for goal in automated_planner.goals:
-        if not automated_planner.state_has_term(state, goal):
-            count += 1
-    return count
+        self.current_h = heuristic_key
+
+    def compute(self, state):
+        return self.heuristic_keys[self.current_h](state)
+
+    def __zero_heuristic(self, state):
+        return 0
+
+    def __goal_count_heuristic(self, state):
+        count = 0
+        for goal in self.automated_planner.goals:
+            if not self.automated_planner.state_has_term(state, goal):
+                count += 1
+        return count
+
+
+class DeleteRelaxationHeuristic:
+    def __init__(self, automated_planner, heuristic_key):
+        self.automated_planner = automated_planner
+        self.heuristic_keys = {
+            "delete_relaxation/h_add": self.__h_add,
+            "delete_relaxation/h_max": self.__h_max
+        }
+        if heuristic_key not in list(self.heuristic_keys.keys()):
+            logging.warning("Heuristic key isn't registered, forcing it to [delete_relaxation/h_add]")
+            heuristic_key = "delete_relaxation/h_add"
+
+        self.current_h = heuristic_key
+
+    def compute(self, state):
+        return self.heuristic_keys[self.current_h](state)
+
+    def __pre_compute(self):
+        logging.fatal("Delete relaxation h_add is not yet implemented")
+        exit()
+
+    def __cache(self):
+        logging.fatal("Delete relaxation h_add is not yet implemented")
+        exit()
+
+    def __h_add(self, state):
+        logging.fatal("Delete relaxation h_add is not yet implemented")
+        exit()
+
+    def __h_max(self, state):
+        logging.fatal("Delete relaxation h_max is not yet implemented")
+        exit()

jupyddl/node.py

@@ -22,7 +22,7 @@ def __init__(
             self.g_cost = temp_cost
             if heuristic_based:
                 if heuristic:
-                    self.h_cost = heuristic(state, automated_planner)
+                    self.h_cost = heuristic(state)
                 else:
                     automated_planner.logger.warning(
                         "Heuristic function wasn't found, forcing it to return zero [Best practice: use the zero_heuristic function]"
@@ -38,7 +38,7 @@ def __init__(
                 self.g_cost = g_cost
             if heuristic_based:
                 if heuristic:
-                    self.h_cost = heuristic(state, automated_planner)
+                    self.h_cost = heuristic(state)
                 else:
                     automated_planner.logger.warning(
                         "Heuristic function wasn't found, forcing it to return zero [Best practice: use the zero_heuristic function]"

main.py

@@ -15,14 +15,15 @@ def main():
     apla_tbx = AutomatedPlanner(args.domain, args.problem)
     apla_tbx.logger.info("Starting the planning script")
     apla_tbx.logger.debug(
-        "Available heuristics: " + str(apla_tbx.available_heuristics.keys())
+        "Available heuristics: " + str(apla_tbx.available_heuristics)
     )
 
-    path, computation_time = apla_tbx.dijktra_best_first_search(time_it=True)
+    path, computation_time, _ = apla_tbx.dijktra_best_first_search()
     apla_tbx.logger.debug(apla_tbx.get_actions_from_path(path))
 
     apla_tbx.logger.debug("Computation time: %.2f seconds" % computation_time)
     apla_tbx.logger.info("Terminate with grace...")
+    return 0
 
 
 if __name__ == "__main__":

tests/test_astar.py

@@ -12,8 +12,8 @@ def test_astar_init():
     apla = AutomatedPlanner(
         "pddl-examples/flip/domain.pddl", "pddl-examples/flip/problem.pddl"
     )
-    astar = AStarBestFirstSearch(apla, apla.available_heuristics["goal_count"])
-    assert astar.init.h_cost == apla.available_heuristics["goal_count"](
+    astar = AStarBestFirstSearch(apla, apla.available_heuristics["basic/goal_count"])
+    assert astar.init.h_cost == apla.available_heuristics["basic/goal_count"](
         apla.initial_state, apla
     )
 
@@ -23,7 +23,7 @@ def test_astar_goal():
         "pddl-examples/flip/domain.pddl", "pddl-examples/flip/problem.pddl"
     )
     path, _, _ = apla.astar_best_first_search()
-    assert apla.available_heuristics["goal_count"](path[-1].state, apla) == 0
+    assert apla.available_heuristics["basic/goal_count"](path[-1].state, apla) == 0
 
 
 def test_astar_path_length():

tests/test_heuristics.py

@@ -18,13 +18,15 @@ def test_zero_heuristic():
     apla = AutomatedPlanner(
         "pddl-examples/flip/domain.pddl", "pddl-examples/flip/problem.pddl"
     )
-    heuristic = hs.zero_heuristic(apla.initial_state, apla)
-    assert heuristic == 0
+    heuristic = hs.BasicHeuristic(apla, "zero")
+    h = heuristic.compute(apla.initial_state)
+    assert h == 0
 
 
 def test_goal_count_heuristic():
     apla = AutomatedPlanner(
         "pddl-examples/flip/domain.pddl", "pddl-examples/flip/problem.pddl"
     )
-    heuristic = hs.goal_count_heuristic(apla.initial_state, apla)
-    assert heuristic == 1
+    heuristic = hs.BasicHeuristic(apla, "goal_count")
+    h = heuristic.compute(apla.initial_state)
+    assert h == 0