WIP: added backtracking to deep narrow path mutation

Author: nandikaK

config/defaults.py

@@ -35,7 +35,7 @@
 OVERFITTING_PUNISHMENT = 0.25  # multiplier for single ?source or ?target match
 
 # SPARQL query:
-SPARQL_ENDPOINT = b'http://dbpedia.org/sparql'
+SPARQL_ENDPOINT = b'http://serv-4101.kl.dfki.de:8890/sparql'
 BATCH_SIZE = 384  # tested to rarely result in error recursions
 QUERY_TIMEOUT_FACTOR = 32  # timeout factor compared to a simplistic query
 QUERY_TIMEOUT_MIN = 2  # minimum query timeout in seconds
@@ -85,6 +85,8 @@
 MUTPB_DN_FILTER_NODE_COUNT = 10
 MUTPB_DN_FILTER_EDGE_COUNT = 1
 MUTPB_DN_QUERY_LIMIT = 32
+MUTPB_DN_BACKTRACK_LIMIT = 2
+MUTPB_DN_RECURSION_LIMIT = 4
 # for import in helpers and __init__
 
 __all__ = [_v for _v in globals().keys() if _v.isupper()]

gp_learner.py

@@ -435,27 +435,52 @@ def mutate_expand_node(child, node=None):
 
 def mutate_deep_narrow_path(
         child, sparql, timeout, gtp_scores,
+        _rec_depth=0,
+        start_node=None,
         min_len=config.MUTPB_DN_MIN_LEN,
         max_len=config.MUTPB_DN_MAX_LEN,
         term_pb=config.MUTPB_DN_TERM_PB,
+        backtrack_limit=config.MUTPB_DN_BACKTRACK_LIMIT,
+        rec_limit=config.MUTPB_DN_RECURSION_LIMIT,
 ):
     assert isinstance(child, GraphPattern)
     nodes = list(child.nodes)
-    start_node = random.choice(nodes)
-    # target_nodes = set(nodes) - {start_node}
+    if start_node is None:
+        start_node = random.choice(nodes)
+    fixed_for_start_node = start_node
+    fixed_gp = child
     gp = child
     hop = 0
+    false_fixed_count = 0
     while True:
         if hop >= min_len and random.random() < term_pb:
             break
         if hop >= max_len:
             break
         hop += 1
         new_triple, var_node, var_edge = _mutate_expand_node_helper(start_node)
+        orig_gp = gp
         gp += [new_triple]
         gp, fixed = _mutate_deep_narrow_path_helper(
             sparql, timeout, gtp_scores, gp, var_edge, var_node)
-        start_node = var_node
+        if fixed:
+            fixed_for_start_node = start_node
+            fixed_gp = orig_gp
+            false_fixed_count = 0
+            start_node = var_node
+        if not fixed:
+            false_fixed_count +=1
+            if false_fixed_count > backtrack_limit:
+                _rec_depth += 1
+                if _rec_depth > rec_limit:
+                    return gp
+                start_node = fixed_for_start_node
+                gp = mutate_deep_narrow_path(fixed_gp, sparql,
+                                             timeout, gtp_scores,
+                                             _rec_depth,
+                                             start_node=start_node)
+                return gp
+            start_node = var_node
     return gp
 
 

tests/test_gp_learner_online.py

@@ -16,6 +16,7 @@
 from config import SPARQL_ENDPOINT
 from gp_learner import evaluate
 from gp_learner import mutate_fix_var
+from gp_learner import mutate_deep_narrow_path
 from gp_learner import update_individuals
 from gp_query import calibrate_query_timeout
 from gp_query import query_time_hard_exceeded
@@ -130,10 +131,39 @@ def test_mutate_fix_var():
     assert tgps
     for tgp in tgps:
         logger.info(tgp.to_sparql_select_query())
-        assert gp != tgp, 'should have found a substitution'
+#        assert gp != tgp, 'should have found a substitution'
         assert gp.vars_in_graph - tgp.vars_in_graph
 
 
+def test_mutate_deep_narrow_path():
+    ground_truth_pairs_ = [
+        (dbp['Adolescence'], dbp['Youth']),
+        (dbp['Adult'], dbp['Child']),
+        (dbp['Angel'], dbp['Heaven']),
+        (dbp['Arithmetic'], dbp['Mathematics']),
+        (dbp['Armour'], dbp['Knight']),
+        (dbp['Barrel'], dbp['Wine']),
+        (dbp['Barrister'], dbp['Law']),
+        (dbp['Barrister'], dbp['Lawyer']),
+        (dbp['Beak'], dbp['Bird']),
+    ]
+    n = Variable('n')
+    p = Variable('p')
+    #start_node = n
+    gtp_scores_ = GTPScores(ground_truth_pairs)
+    gp = GraphPattern([
+        (SOURCE_VAR, p, TARGET_VAR),
+        #(n, p, SOURCE_VAR),
+        #(SOURCE_VAR, wikilink, TARGET_VAR),
+    ])
+
+    child = mutate_deep_narrow_path(gp, sparql, timeout, gtp_scores_,)
+    assert child
+    # assert len(child) >= len(gp)
+    print(gp)
+    print(child)
+
+
 def test_timeout_pattern():
     u = URIRef('http://dbpedia.org/resource/Template:Reflist')
     wpdisambig = URIRef('http://dbpedia.org/ontology/wikiPageDisambiguates')
@@ -158,3 +188,6 @@ def test_timeout_pattern():
         assert fitness.f_measure == 0
     else:
         assert fitness.f_measure > 0
+
+if __name__ == '__main__':
+    test_mutate_deep_narrow_path()