Merge pull request #198 from AmoghSInamdar/addAI

Add AI support and bug fixes

Author: ndittren

logictools/AI/astar_heuristics.py

@@ -5,10 +5,11 @@
 from Levenshtein import distance
 import numpy as np
 
-from logictools.AI.neural_embedding_heuristic import NeuralEmbeddingHeuristic
+from logictools.AI.neural_heuristic.neural_embedding_heuristic import NeuralEmbeddingHeuristic
 
 
-# all heuristics expect Tuple<expr: str, law:str> as inputs. Change typing to a StepNode : {expr: str, law: str} object
+# all heuristics expect Tuple<expr: str, law:str> as inputs. Change typing
+# to a StepNode : {expr: str, law: str} object
 
 def random_weight(n1, n2):
     return random() * 10
@@ -19,23 +20,28 @@ def levenshtein_distance(n1, n2):
 
 
 def len_distance(n1, n2):
-    return abs(len(n1[0])-len(n2[0]))
+    return abs(len(n1[0]) - len(n2[0]))
 
 
 def unitary_distance(n1, n2):
     return 1
 
 
 def variable_mismatch(n1, n2):            # vars in n1 but not in n2 and vice versa
-    cfunc = lambda x: 97 <= ord(x) <= 122 and x != 'v'
+    def cfunc(x): return 97 <= ord(x) <= 122 and x != 'v'
     n1v, n2v = set(filter(cfunc, n1[0])), set(filter(cfunc, n2[0]))
     return len((n1v | n2v) - (n1v & n2v))
 
 
 class RuleDists:
 
     def __init__(self):
-        self.all_dists = list(filter(lambda r: not r[0].startswith("__"), inspect.getmembers(self, predicate=inspect.ismethod)))
+        self.all_dists = list(
+            filter(
+                lambda r: not r[0].startswith("__"),
+                inspect.getmembers(
+                    self,
+                    predicate=inspect.ismethod)))
         self.all_dists = [r[1] for r in self.all_dists]
 
     def start_dist(self, n1, n2, d=1):
@@ -123,7 +129,8 @@ def load(self, weight_file):
             for l in lines[2:]:
                 try:
                     heur, val, file = l.split(": ")
-                    self.heuristics.append(getattr(NeuralEmbeddingHeuristic(file[:-1], is_state_dict=True), heur))
+                    self.heuristics.append(
+                        getattr(NeuralEmbeddingHeuristic(file[:-1], is_state_dict=True), heur))
                 except ValueError:
                     heur, val = l.split(": ")
                     if heur in globals():
@@ -134,10 +141,11 @@ def load(self, weight_file):
 
     def save(self, out_file):
         with open(out_file, "w") as f:
-            f.write(str(self.params)+"\n\n")
+            f.write(str(self.params) + "\n\n")
             for i, h in enumerate(self.heuristics):
                 if self.model_files[i]:
-                    f.write(f"{h.__name__}: {self.weights[i]}: {self.model_files[i]}\n")
+                    f.write(
+                        f"{h.__name__}: {self.weights[i]}: {self.model_files[i]}\n")
                 else:
                     f.write(f"{h.__name__}: {self.weights[i]}\n")
 
@@ -147,4 +155,3 @@ def save(self, out_file):
     gh = GeneHeuristic()
     gh.load("astar_heuristic_weights.txt")
     print(gh.gene_meta_dist(n1, n2))
-

logictools/AI/astar_search.py

@@ -42,7 +42,8 @@ def __init__(self, data, fscore=inf, gscore=inf):
         def __lt__(self, other):
             return self.fscore < other.fscore
 
-    class NodeDict(dict):  # can't replace with defaultdict because it doesn't accept args in lambda :(
+    class NodeDict(
+            dict):  # can't replace with defaultdict because it doesn't accept args in lambda :(
 
         def __missing__(self, key):
             value = SearchNode(key)
@@ -56,7 +57,9 @@ def __missing__(self, key):
         return True, [start]
 
     search_dict = NodeDict()
-    start_node = search_dict[start] = SearchNode(start, fscore=goal_heuristic(start, goal, *args, **kwargs), gscore=.0)
+    start_node = search_dict[start] = SearchNode(
+        start, fscore=goal_heuristic(
+            start, goal, *args, **kwargs), gscore=.0)
     start_node.depth = 0
     open_set = []
     heappush(open_set, start_node)
@@ -77,15 +80,18 @@ def __missing__(self, key):
                 current_node = current_node.prev
             return True, list(reversed(rev_sol))
 
-        for neighbor in map(lambda n: search_dict[n], frontier_func(current_node.data)):
+        for neighbor in map(
+                lambda n: search_dict[n], frontier_func(current_node.data)):
             if neighbor.completed:
                 continue
-            tentative_gscore = current_node.gscore + neighbor_dist(current_node.data, neighbor.data)
+            tentative_gscore = current_node.gscore + \
+                neighbor_dist(current_node.data, neighbor.data)
             if tentative_gscore < neighbor.gscore:
                 neighbor.prev = current_node
                 neighbor.depth = current_node.depth + 1
                 neighbor.gscore = tentative_gscore
-                neighbor.fscore = tentative_gscore + goal_heuristic(neighbor.data, goal)
+                neighbor.fscore = tentative_gscore + \
+                    goal_heuristic(neighbor.data, goal)
                 if neighbor.out_of_openset:
                     neighbor.out_of_openset = False
                     heappush(open_set, neighbor)
@@ -112,18 +118,35 @@ def __missing__(self, key):
         questions = json.load(f)['questions']
 
     import logictools.expression_parser as ep
+
     def frontier_func(x):
-        fr = ep.get_frontier(x[0], simplify_paren=True, include_paren=False, allowed_ops=lrt.search_operations)
+        fr = ep.get_frontier(
+            x[0],
+            simplify_paren=True,
+            include_paren=False,
+            allowed_ops=lrt.search_operations)
         print(fr)
         return fr
+
     def goal_func(x, target):
         return x[0] == target[0]
 
     for q in questions[4:5]:
         q["premise"] = "(qvp)^(qv~q)"
-        gp = astar_search(q['premise'], q['target'], levenshtein_distance, frontier_func, goal_func)
+        gp = astar_search(
+            q['premise'],
+            q['target'],
+            levenshtein_distance,
+            frontier_func,
+            goal_func)
         print(gp)
         gh = GeneHeuristic()
         gh.load("astar_heuristic_weights.txt")
-        gp2 = astar_search("~(pvq)", "~p^~q", gh.gene_meta_dist, frontier_func, goal_func, max_timeout=1)
+        gp2 = astar_search(
+            "~(pvq)",
+            "~p^~q",
+            gh.gene_meta_dist,
+            frontier_func,
+            goal_func,
+            max_timeout=1)
         print(gp2)

logictools/AI/evaluate_astar_heuristic.py

@@ -14,7 +14,8 @@ def get_questions():
     return questions
 
 
-def evaluate_against_question_bank(heuristic, results_file="heuristic_test_results.txt", max_timeout=5):
+def evaluate_against_question_bank(
+        heuristic, results_file="heuristic_test_results.txt", max_timeout=5):
     with open(results_file, "w") as rf:
         est = asctime(localtime())
         rf.write(
@@ -23,7 +24,10 @@ def evaluate_against_question_bank(heuristic, results_file="heuristic_test_resul
         )
 
     def frontier_func(x):
-        fr = get_frontier(x[0], include_paren=False, allowed_ops=search_operations)
+        fr = get_frontier(
+            x[0],
+            include_paren=False,
+            allowed_ops=search_operations)
         return fr
 
     def goal_func(x, target):
@@ -35,19 +39,29 @@ def goal_func(x, target):
         start = q['premise']
         goal = q['target']
         start_time = time()
-        is_solved, result = astar_search(start, goal, heuristic, frontier_func, goal_func, max_timeout=max_timeout)
+        is_solved, result = astar_search(
+            start, goal, heuristic, frontier_func, goal_func, max_timeout=max_timeout)
         end_time = time()
         with open(results_file, "a") as rf:
-            info_str = "{}. Premise: {}, Target: {}. ".format(i + 1, start, goal)
+            info_str = "{}. Premise: {}, Target: {}. ".format(
+                i + 1, start, goal)
             if is_solved:
                 solve_time = end_time - start_time
-                rf.write(info_str + f"Solved in {solve_time:.4f} seconds. Solution: {result}\n.")
-                print(info_str + f"Solved in {solve_time:.4f} seconds. Solution: {result}")
+                rf.write(
+                    info_str +
+                    f"Solved in {solve_time:.4f} seconds. Solution: {result}\n.")
+                print(
+                    info_str +
+                    f"Solved in {solve_time:.4f} seconds. Solution: {result}")
                 num_solved += 1
             else:
                 if result:
-                    rf.write(info_str + f" Timeout occurred. Path to best node: {result}\n.")
-                    print(info_str + f" Timeout occurred. Path to best node: {result}")
+                    rf.write(
+                        info_str +
+                        f" Timeout occurred. Path to best node: {result}\n.")
+                    print(
+                        info_str +
+                        f" Timeout occurred. Path to best node: {result}")
                 else:
                     rf.write(info_str + " Error occurred.")
                     print(info_str + " Error occurred.")
@@ -56,8 +70,26 @@ def goal_func(x, target):
         print("\nSolved {}/{} questions.".format(num_solved, len(questions)))
 
 
+def frontier_func(x):
+    fr = get_frontier(x[0], include_paren=False, allowed_ops=search_operations)
+    return fr
+
+
+def goal_func(x, target):
+    return x[0] == target[0]
+
+
+def get_heuristic_score(heuristic, questions, max_timeout=5):
+    return sum([is_solved for is_solved, result in
+                [astar_search(q["premise"], q["target"], heuristic, frontier_func, goal_func, max_timeout=max_timeout)
+                 for q in questions]])
+
+
 if __name__ == "__main__":
     gh = GeneHeuristic()
     gh.load("astar_heuristic_weights.txt")
-    evaluate_against_question_bank(gh.gene_meta_dist)
+    # evaluate_against_question_bank(gh.gene_meta_dist)
 
+    questions = get_questions()
+    score = get_heuristic_score(gh.gene_meta_dist, questions, max_timeout=5)
+    print(f"Score: {score}")