added setting to reason again with restart of time

Author: dyumanaditya

docs/source/user_guide/8_advanced_usage.rst

@@ -20,8 +20,14 @@ PyReason allows you to reason over the graph multiple times. This can be useful
 and add facts that were not available before. To reason over the graph multiple times, you can set ``again=True`` in ``pr.reason(again=True)``.
 To specify additional facts or rules, you can add them as you normally would using ``pr.add_fact`` and ``pr.add_rule``.
 
+You can also clear the rules to use completely different ones with ``pr.clear_rules()``. This can be useful when you
+want to reason over the graph with a new set of rules.
+
+When reasoning multiple times, the time is reset to zero. Therefore any facts that are added should take this into account.
+It is also possible to continue incrementing the time by running ``pr.reason(again=True, restart=False)``
+
 .. note::
-    When reasoning multiple times, the time continues to increment. Therefore any facts that are added should take this into account.
+    When reasoning multiple times with ``restart=False``, the time continues to increment. Therefore any facts that are added should take this into account.
     The timestep parameter specifies how many additional timesteps to reason. For example, if the initial reasoning converges at
     timestep 5, and you want to reason for 3 more timesteps, you can set ``timestep=3`` in ``pr.reason(timestep=3, again=True)``.
     If you are specifying new facts, take this into account when setting their ``start_time`` and ``end_time``.

pyreason/pyreason.py

@@ -459,9 +459,21 @@ def reset():
     """Resets certain variables to None to be able to do pr.reason() multiple times in a program
     without memory blowing up
     """
-    global __node_facts, __edge_facts
+    global __node_facts, __edge_facts, __graph
+
+    # Facts
     __node_facts = None
     __edge_facts = None
+    if __program is not None:
+        __program.reset_facts()
+
+    # Graph
+    __graph = None
+    if __program is not None:
+        __program.reset_graph()
+
+    # Rules
+    reset_rules()
 
 
 def get_rules():
@@ -478,14 +490,8 @@ def reset_rules():
     """
     global __rules
     __rules = None
-
-
-def reset_graph():
-    """
-    Resets graph to none
-    """
-    global __graph
-    __graph = None
+    if __program is not None:
+        __program.reset_rules()
 
 
 def reset_settings():
@@ -633,15 +639,15 @@ def add_annotation_function(function: Callable) -> None:
     __annotation_functions.append(function)
 
 
-def reason(timesteps: int = -1, convergence_threshold: int = -1, convergence_bound_threshold: float = -1, queries: List[Query] = None, again: bool = False):
+def reason(timesteps: int = -1, convergence_threshold: int = -1, convergence_bound_threshold: float = -1, queries: List[Query] = None, again: bool = False, restart: bool = True):
     """Function to start the main reasoning process. Graph and rules must already be loaded.
 
     :param timesteps: Max number of timesteps to run. -1 specifies run till convergence. If reasoning again, this is the number of timesteps to reason for extra (no zero timestep), defaults to -1
     :param convergence_threshold: Maximum number of interpretations that have changed between timesteps or fixed point operations until considered convergent. Program will end at convergence. -1 => no changes, perfect convergence, defaults to -1
     :param convergence_bound_threshold: Maximum change in any interpretation (bounds) between timesteps or fixed point operations until considered convergent, defaults to -1
     :param queries: A list of PyReason query objects that can be used to filter the ruleset based on the query. Default is None
     :param again: Whether to reason again on an existing interpretation, defaults to False
-    :param facts: New facts to use during the next reasoning process when reasoning again. Other facts from file will be discarded, defaults to None
+    :param restart: Whether to restart the program time from 0 when reasoning again, defaults to True
     :return: The final interpretation after reasoning.
     """
     global settings, __timestamp
@@ -662,10 +668,10 @@ def reason(timesteps: int = -1, convergence_threshold: int = -1, convergence_bou
     else:
         if settings.memory_profile:
             start_mem = mp.memory_usage(max_usage=True)
-            mem_usage, interp = mp.memory_usage((_reason_again, [timesteps, convergence_threshold, convergence_bound_threshold]), max_usage=True, retval=True)
+            mem_usage, interp = mp.memory_usage((_reason_again, [timesteps, restart, convergence_threshold, convergence_bound_threshold]), max_usage=True, retval=True)
             print(f"\nProgram used {mem_usage-start_mem} MB of memory")
         else:
-            interp = _reason_again(timesteps, convergence_threshold, convergence_bound_threshold)
+            interp = _reason_again(timesteps, restart, convergence_threshold, convergence_bound_threshold)
 
     return interp
 
@@ -758,7 +764,7 @@ def _reason(timesteps, convergence_threshold, convergence_bound_threshold, queri
     return interpretation
 
 
-def _reason_again(timesteps, convergence_threshold, convergence_bound_threshold):
+def _reason_again(timesteps, restart, convergence_threshold, convergence_bound_threshold):
     # Globals
     global __graph, __rules, __node_facts, __edge_facts, __ipl, __specific_node_labels, __specific_edge_labels, __graphml_parser
     global settings, __timestamp, __program
@@ -772,7 +778,7 @@ def _reason_again(timesteps, convergence_threshold, convergence_bound_threshold)
     all_edge_facts.extend(numba.typed.List(__edge_facts))
 
     # Run Program and get final interpretation
-    interpretation = __program.reason_again(timesteps, convergence_threshold, convergence_bound_threshold, all_node_facts, all_edge_facts, settings.verbose)
+    interpretation = __program.reason_again(timesteps, restart, convergence_threshold, convergence_bound_threshold, all_node_facts, all_edge_facts, settings.verbose)
 
     return interpretation
 

pyreason/scripts/interpretation/interpretation.py

@@ -180,11 +180,11 @@ def _init_convergence(convergence_bound_threshold, convergence_threshold):
 			convergence_delta = convergence_bound_threshold
 		return convergence_mode, convergence_delta
 
-	def start_fp(self, tmax, facts_node, facts_edge, rules, verbose, convergence_threshold, convergence_bound_threshold, again=False):
+	def start_fp(self, tmax, facts_node, facts_edge, rules, verbose, convergence_threshold, convergence_bound_threshold, again=False, restart=True):
 		self.tmax = tmax
 		self._convergence_mode, self._convergence_delta = self._init_convergence(convergence_bound_threshold, convergence_threshold)
 		max_facts_time = self._init_facts(facts_node, facts_edge, self.facts_to_be_applied_node, self.facts_to_be_applied_edge, self.facts_to_be_applied_node_trace, self.facts_to_be_applied_edge_trace, self.atom_trace)
-		self._start_fp(rules, max_facts_time, verbose, again)
+		self._start_fp(rules, max_facts_time, verbose, again, restart)
 
 	@staticmethod
 	@numba.njit(cache=True)
@@ -208,9 +208,12 @@ def _init_facts(facts_node, facts_edge, facts_to_be_applied_node, facts_to_be_ap
 					facts_to_be_applied_edge_trace.append(fact.get_name())
 		return max_time
 
-	def _start_fp(self, rules, max_facts_time, verbose, again):
+	def _start_fp(self, rules, max_facts_time, verbose, again, restart):
 		if again:
 			self.num_ga.append(self.num_ga[-1])
+			if restart:
+				self.time = 0
+				self.prev_reasoning_data[0] = 0
 		fp_cnt, t = self.reason(self.interpretations_node, self.interpretations_edge, self.predicate_map_node, self.predicate_map_edge, self.tmax, self.prev_reasoning_data, rules, self.nodes, self.edges, self.neighbors, self.reverse_neighbors, self.rules_to_be_applied_node, self.rules_to_be_applied_edge, self.edges_to_be_added_node_rule, self.edges_to_be_added_edge_rule, self.rules_to_be_applied_node_trace, self.rules_to_be_applied_edge_trace, self.facts_to_be_applied_node, self.facts_to_be_applied_edge, self.facts_to_be_applied_node_trace, self.facts_to_be_applied_edge_trace, self.ipl, self.rule_trace_node, self.rule_trace_edge, self.rule_trace_node_atoms, self.rule_trace_edge_atoms, self.reverse_graph, self.atom_trace, self.save_graph_attributes_to_rule_trace, self.persistent, self.inconsistency_check, self.store_interpretation_changes, self.update_mode, self.allow_ground_rules, max_facts_time, self.annotation_functions, self._convergence_mode, self._convergence_delta, self.num_ga, verbose, again)
 		self.time = t - 1
 		# If we need to reason again, store the next timestep to start from

pyreason/scripts/interpretation/interpretation_parallel.py

@@ -180,11 +180,11 @@ def _init_convergence(convergence_bound_threshold, convergence_threshold):
 			convergence_delta = convergence_bound_threshold
 		return convergence_mode, convergence_delta
 
-	def start_fp(self, tmax, facts_node, facts_edge, rules, verbose, convergence_threshold, convergence_bound_threshold, again=False):
+	def start_fp(self, tmax, facts_node, facts_edge, rules, verbose, convergence_threshold, convergence_bound_threshold, again=False, restart=True):
 		self.tmax = tmax
 		self._convergence_mode, self._convergence_delta = self._init_convergence(convergence_bound_threshold, convergence_threshold)
 		max_facts_time = self._init_facts(facts_node, facts_edge, self.facts_to_be_applied_node, self.facts_to_be_applied_edge, self.facts_to_be_applied_node_trace, self.facts_to_be_applied_edge_trace, self.atom_trace)
-		self._start_fp(rules, max_facts_time, verbose, again)
+		self._start_fp(rules, max_facts_time, verbose, again, restart)
 
 	@staticmethod
 	@numba.njit(cache=True)
@@ -208,9 +208,12 @@ def _init_facts(facts_node, facts_edge, facts_to_be_applied_node, facts_to_be_ap
 					facts_to_be_applied_edge_trace.append(fact.get_name())
 		return max_time
 
-	def _start_fp(self, rules, max_facts_time, verbose, again):
+	def _start_fp(self, rules, max_facts_time, verbose, again, restart):
 		if again:
 			self.num_ga.append(self.num_ga[-1])
+			if restart:
+				self.time = 0
+				self.prev_reasoning_data[0] = 0
 		fp_cnt, t = self.reason(self.interpretations_node, self.interpretations_edge, self.predicate_map_node, self.predicate_map_edge, self.tmax, self.prev_reasoning_data, rules, self.nodes, self.edges, self.neighbors, self.reverse_neighbors, self.rules_to_be_applied_node, self.rules_to_be_applied_edge, self.edges_to_be_added_node_rule, self.edges_to_be_added_edge_rule, self.rules_to_be_applied_node_trace, self.rules_to_be_applied_edge_trace, self.facts_to_be_applied_node, self.facts_to_be_applied_edge, self.facts_to_be_applied_node_trace, self.facts_to_be_applied_edge_trace, self.ipl, self.rule_trace_node, self.rule_trace_edge, self.rule_trace_node_atoms, self.rule_trace_edge_atoms, self.reverse_graph, self.atom_trace, self.save_graph_attributes_to_rule_trace, self.persistent, self.inconsistency_check, self.store_interpretation_changes, self.update_mode, self.allow_ground_rules, max_facts_time, self.annotation_functions, self._convergence_mode, self._convergence_delta, self.num_ga, verbose, again)
 		self.time = t - 1
 		# If we need to reason again, store the next timestep to start from

pyreason/scripts/program/program.py

@@ -39,9 +39,23 @@ def reason(self, tmax, convergence_threshold, convergence_bound_threshold, verbo
 
 		return self.interp
 
-	def reason_again(self, tmax, convergence_threshold, convergence_bound_threshold, facts_node, facts_edge, verbose=True):
+	def reason_again(self, tmax, restart, convergence_threshold, convergence_bound_threshold, facts_node, facts_edge, verbose=True):
 		assert self.interp is not None, 'Call reason before calling reason again'
-		self._tmax = self.interp.time + tmax
-		self.interp.start_fp(self._tmax, facts_node, facts_edge, self._rules, verbose, convergence_threshold, convergence_bound_threshold, again=True)
+		if restart:
+			self._tmax = tmax
+		else:
+			self._tmax = self.interp.time + tmax
+		self.interp.start_fp(self._tmax, facts_node, facts_edge, self._rules, verbose, convergence_threshold, convergence_bound_threshold, again=True, restart=restart)
 
 		return self.interp
+
+	def reset_graph(self):
+		self._graph = None
+		self.interp = None
+
+	def reset_rules(self):
+		self._rules = None
+
+	def reset_facts(self):
+		self._facts_node = None
+		self._facts_edge = None

tests/test_reason_again.py

@@ -29,7 +29,7 @@ def test_reason_again():
     # Now reason again
     new_fact = pr.Fact('popular(Mary)', 'popular_fact2', 2, 4)
     pr.add_fact(new_fact)
-    interpretation = pr.reason(timesteps=3, again=True)
+    interpretation = pr.reason(timesteps=3, again=True, restart=False)
 
     # Display the changes in the interpretation for each timestep
     dataframes = pr.filter_and_sort_nodes(interpretation, ['popular'])