Add floor-event timing objective and addressee diagnostics

test_easycom_oracle_features.py

@@ -16,6 +16,7 @@ from prepare_easycom_oracle_features import (
     causal_history,
     oracle_person_rows,
     participant_activity,
+    participant_direct_addressee_activity,
 )
 
 
@@ -79,6 +80,79 @@ class OracleFeatureTests(unittest.TestCase):
             [0, 0, 0, 0, 0, 1, 0, 1],
         )
 
+    def test_direct_addressee_keeps_group_and_unknown_out_of_positive_channel(self) -> None:
+        rows = [
+            SimpleNamespace(
+                uid="direct",
+                participant_id=3,
+                target_of_speech=(2,),
+                dense_start_frame=0,
+                dense_end_frame_exclusive=8,
+            ),
+            SimpleNamespace(
+                uid="group",
+                participant_id=4,
+                target_of_speech=("Group",),
+                dense_start_frame=4,
+                dense_end_frame_exclusive=13,
+            ),
+            SimpleNamespace(
+                uid="unknown",
+                participant_id=5,
+                target_of_speech=("None",),
+                dense_start_frame=8,
+                dense_end_frame_exclusive=17,
+            ),
+        ]
+        directed, audit = participant_direct_addressee_activity(
+            rows, num_steps=5, wearer_id=2
+        )
+        self.assertEqual(directed[3].tolist(), [True, False, False, False, False])
+        self.assertNotIn(4, directed)
+        self.assertNotIn(5, directed)
+        self.assertEqual(
+            audit["target_of_speech_utterance_counts"],
+            {"direct_wearer": 1, "group": 1, "other": 0, "unknown": 1},
+        )
+        self.assertTrue(audit["target_of_speech_group_unknown_not_coerced"])
+
+    def test_addressee_oracle_has_capacity_matched_zero_control(self) -> None:
+        activity = {3: torch.tensor([1, 1, 0], dtype=torch.bool)}
+        addressed = {3: torch.tensor([1, 0, 0], dtype=torch.bool)}
+        visibility = {3: torch.ones(3, dtype=torch.bool)}
+        visible = [[3], [3], [3]]
+        records = [
+            [{"id": "3", "source_clip_index": 0, "source_time": row / 5}]
+            for row in range(3)
+        ]
+        control, control_offsets, _, _ = oracle_person_rows(
+            activity,
+            visibility,
+            visible,
+            records,
+            condition="aggregate-visible-address-control",
+            history_steps=2,
+            delay_steps=0,
+            seed=0,
+            direct_addressee_activity=addressed,
+        )
+        oracle, oracle_offsets, _, _ = oracle_person_rows(
+            activity,
+            visibility,
+            visible,
+            records,
+            condition="aggregate-visible-addressee",
+            history_steps=2,
+            delay_steps=0,
+            seed=0,
+            direct_addressee_activity=addressed,
+        )
+        self.assertEqual(control.shape, (3, 6))
+        self.assertTrue(torch.equal(control_offsets, oracle_offsets))
+        self.assertTrue(torch.equal(control[:, :4], oracle[:, :4]))
+        self.assertEqual(control[:, 4:].tolist(), [[0, 0], [0, 0], [0, 0]])
+        self.assertEqual(oracle[:, 4:].tolist(), [[0, 1], [1, 0], [0, 0]])
+
     def test_shuffled_id_preserves_every_lag_count_but_breaks_histories(self) -> None:
         activity = {
             3: torch.tensor([1, 1, 0, 0, 1, 1], dtype=torch.bool),