wip

Author: yichao-liang

predicators/approaches/pp_online_predicate_invention_approach.py

@@ -284,6 +284,7 @@ def _get_successors(
 
 def get_false_positive_states_from_seg_trajs(
     segmented_trajs: List[List[Segment]],
+    trajectories: List[LowLevelTrajectory],
     exogenous_processes: List[ExogenousProcess],
 ) -> Dict[_GroundExogenousProcess, List[State]]:
 
@@ -295,10 +296,12 @@ def get_false_positive_states_from_seg_trajs(
     # Cache for ground_exogenous_processes to avoid recomputation
     objects_to_ground_processes = {}
 
-    for segmented_traj in segmented_trajs:
-        # Checking each segmented trajectory
-        objects = frozenset(segmented_traj[0].trajectory.states[0])
+    for traj, segmented_traj in zip(trajectories, segmented_trajs):
+        scheduled_events: Dict[int, List[Tuple[_GroundExogenousProcess, 
+                                               int]]] = {}
+        t = 0 # Time counter in the trajectory
         # Only recompute if objects are different
+        objects = frozenset(segmented_traj[0].trajectory.states[0])
         if objects not in objects_to_ground_processes:
             ground_exogenous_processes, _ = task_plan_grounding(
                 set(),
@@ -307,34 +310,67 @@ def get_false_positive_states_from_seg_trajs(
                 allow_noops=True,
                 compute_reachable_atoms=False)
             objects_to_ground_processes[objects] = ground_exogenous_processes
+            assert all(
+                isinstance(g_exo_process, _GroundExogenousProcess)
+                for g_exo_process in ground_exogenous_processes), \
+                "Expected all processes to be ground exogenous processes."
         else:
             ground_exogenous_processes = objects_to_ground_processes[objects]
 
         # Pre-compute segment init_atoms for efficiency
         segment_init_atoms = [segment.init_atoms for segment in segmented_traj]
 
-        for g_exo_process in ground_exogenous_processes:
-            condition = g_exo_process.condition_at_start  # Cache reference
-            add_effects = g_exo_process.add_effects
-            delete_effects = g_exo_process.delete_effects
-
-            for i, segment in enumerate(segmented_traj):
-                satisfy_condition = condition.issubset(segment_init_atoms[i])
-                first_state_or_prev_state_doesnt_satisfy = i == 0 or \
-                    not condition.issubset(segment_init_atoms[i - 1])
-
-                if satisfy_condition and first_state_or_prev_state_doesnt_satisfy:
-                    false_positive_process_state[g_exo_process].append(
-                        # segment.trajectory.states[0])
-                        segment.init_atoms)
-
-                # Check for removal condition
-                if (add_effects.issubset(segment.add_effects)
-                        and delete_effects.issubset(segment.delete_effects)):
-                    if false_positive_process_state[g_exo_process]:
-                        # TODO: we don't really know which one to remove, pop
-                        # the first one is a bias.
-                        false_positive_process_state[g_exo_process].pop(0)
+        for i, segment in enumerate(segmented_traj):
+            # 1. Process effects scheduled for this step or earlier
+            relevant_events = [
+                (scheduled_time, proc_n_times)
+                for scheduled_time, proc_n_times in scheduled_events.items()
+                if scheduled_time <= t
+            ]
+            for scheduled_time, proc_n_times in relevant_events:
+                for g_exo_process, start_time in proc_n_times:
+                    condition_overall = g_exo_process.condition_overall
+                    condition_at_end = g_exo_process.condition_at_end
+                    add_effects = g_exo_process.add_effects
+                    delete_effects = g_exo_process.delete_effects
+
+                    if (all(condition_overall.issubset(s) for s in
+                        traj.states[start_time + 1:]) and
+                        condition_at_end.issubset(traj.states[scheduled_time])):
+
+                        false_positive_process_state[g_exo_process].append(
+                            segment.init_atoms)
+
+                        # Check for effects scheduled for this step.
+                        if (add_effects.issubset(traj.states[scheduled_time].add_effects) and 
+                            delete_effects.issubset(traj.states[scheduled_time].delete_effects)):
+                            if false_positive_process_state[g_exo_process]:
+                                false_positive_process_state[g_exo_process].pop(0)
+
+                # Delete the scheduled events that are no longer relevant
+                del scheduled_events[scheduled_time]
+
+            # 2. Schedule an effect to be checked later
+            for g_exo_process in ground_exogenous_processes:
+                condition_at_start = g_exo_process.condition_at_start
+                condition_overall = g_exo_process.condition_overall
+                add_effects = g_exo_process.add_effects
+                delete_effects = g_exo_process.delete_effects
+
+                satisfy_condition = condition_at_start.issubset(
+                                                    segment_init_atoms[i])
+                first_state_to_satisfy = i == 0 or \
+                    not condition_at_start.issubset(segment_init_atoms[i - 1])
+
+                if satisfy_condition and first_state_to_satisfy:
+                    delay = g_exo_process.delay_distribution.sample()
+                    schedued_time = t + delay
+                    if schedued_time not in scheduled_events:
+                        scheduled_events[schedued_time] = []
+                    scheduled_events[schedued_time].append((g_exo_process, i))
+            # e.g. if current 0, len is 5, the next timestep is 5.
+            t += len(segment.states)
+
     return false_positive_process_state
 
 

predicators/nsrt_learning/strips_learning/clustering_learner.py

@@ -477,6 +477,7 @@ def _learn_pnad_preconditions_sequential(self,
                                       parameters=new_params), pnad.datastore,
                     pnad.option_spec)
                 final_pnads.append(new_pnad)
+        breakpoint()
 
         return final_pnads
 
@@ -537,7 +538,8 @@ def _score_preconditions(self, exogenous_process: ExogenousProcess,
         exogenous_process.condition_overall = set(preconditions)
         false_positive_process_state =\
             self._get_false_positive_states_from_seg_trajs(
-                self._atom_change_segmented_trajs, [exogenous_process])
+                self._atom_change_segmented_trajs, 
+                self._trajectories, [exogenous_process])
         num_false_positives = 0
         for _, states in false_positive_process_state.items():
             num_false_positives += len(states)
@@ -695,7 +697,8 @@ def _get_top_consistent_conditions(self, initial_atom: Set[LiftedAtom],
 
                 false_positive_process_state = \
                     self._get_fp_states_from_seg_trajs(
-                        self._atom_change_segmented_trajs, [exogenous_process])
+                        self._atom_change_segmented_trajs, 
+                        self._trajectories, [exogenous_process])
                 num_false_positives = sum(
                     len(states)
                     for states in false_positive_process_state.values())

scripts/configs/mara_bench.yaml

@@ -76,8 +76,8 @@ APPROACHES:
       strips_learner: "llm"
       find_best_matching_pnad_skip_if_effect_not_subset: False
       # exogenous_process_learner: "cluster_and_llm_select"
-      # exogenous_process_learner: "cluster_and_search_process_learner"
-      exogenous_process_learner: "cluster_and_inverse_planning"
+      exogenous_process_learner: "cluster_and_search_process_learner"
+      # exogenous_process_learner: "cluster_and_inverse_planning"
       process_learner_check_false_positives: False
       # To have demos to stop when option terminates.
       terminate_on_goal_reached: False