experiment(optimize/i5-rework): fix age-discount guard regression

- Apply age discount only to cost matrix (not threshold check): raw IoU used for min-threshold gate, discount only biases solver assignment toward active tracks
- Tighten Optuna search range [0.0, 0.2] -> [0.0, 0.1]
- Fix pre-existing bug: optimize_tracking.py final re-eval now applies _apply_kalman_patch

---
Co-authored-by: Claude Code <noreply@anthropic.com>

Author: Borda

autotrack/optimize_tracking.py

@@ -857,6 +857,7 @@ def main(
     )
 
     best_params = study.best_params
+    _apply_kalman_patch(best_params, tracker)
     best_metrics = _run_eval(
         params=best_params,
         sequences=sequences,

autotrack/search_space.json

@@ -38,7 +38,7 @@
         "iou_age_weight": {
             "type": "float",
             "low": 0.0,
-            "high": 0.5
+            "high": 0.1
         },
         "high_conf_det_threshold": {
             "type": "float",

trackers/core/bytetrack/tracker.py

@@ -55,13 +55,17 @@ class ByteTrackTracker(BaseTracker):
             low-confidence association. Lower values are more permissive when
             reviving tracks from low-confidence detections.
         iou_age_weight: `float` specifying how much to discount IoU
-            similarity for lost tracks in stage-1 association. Each track's
-            IoU row is scaled by ``1 / (1 + iou_age_weight * lost_frames)``
-            where ``lost_frames = max(0, time_since_update - 1)``. This
-            makes the assignment prefer active tracks over stale predictions,
-            reducing identity switches. ``0`` disables the discount.
-            Only applied in stage 1; stage 2 is unaffected so that lost
-            tracks can still recover via low-confidence detections.
+            similarity for lost tracks in stage-1 assignment ranking.
+            Each lost track's IoU row is scaled by
+            ``1 / (1 + iou_age_weight * lost_frames)`` where
+            ``lost_frames = max(0, time_since_update - 1)``. The discount
+            biases the solver to prefer active tracks over stale
+            predictions (reducing identity switches) but only affects
+            ranking — the minimum-IoU threshold is checked against the
+            *raw* IoU so that valid matches are never rejected by the
+            discount alone. ``0`` disables the discount. Only applied in
+            stage 1; stage 2 is unaffected so that lost tracks can still
+            recover via low-confidence detections.
         high_conf_det_threshold: `float` specifying threshold for separating
             high and low confidence detections in the two-stage association.
     """
@@ -141,16 +145,25 @@ def update(
         # algorithm prefers active tracks over stale predictions.  This
         # reduces identity switches from a drifted prediction "stealing"
         # a detection that should go to the correct active track.
+        #
+        # The discount is applied only to the cost matrix used by the
+        # solver for ranking; the threshold check uses the *raw* IoU so
+        # that valid matches are never rejected by the discount alone.
+        # Only tracks that have been lost for at least 1 frame are
+        # discounted — freshly-seen tracks (time_since_update == 1 after
+        # predict, i.e. lost_frames == 0) are never penalised.
         if self.iou_age_weight > 0 and iou_matrix.size > 0:
             lost_frames = np.array(
                 [max(0, t.time_since_update - 1) for t in self.tracks],
                 dtype=np.float32,
             )
             discount = 1.0 / (1.0 + self.iou_age_weight * lost_frames)
-            iou_matrix = iou_matrix * discount[:, np.newaxis]
+            solver_iou = iou_matrix * discount[:, np.newaxis]
+        else:
+            solver_iou = iou_matrix
 
         matched, unmatched_tracks, unmatched_high = self._get_associated_indices(
-            iou_matrix, self.minimum_iou_threshold
+            solver_iou, self.minimum_iou_threshold, raw_similarity=iou_matrix
         )
 
         for row, col in matched:
@@ -219,32 +232,41 @@ def _get_associated_indices(
         self,
         similarity_matrix: np.ndarray,
         min_similarity_thresh: float,
+        raw_similarity: np.ndarray | None = None,
     ) -> tuple[list[tuple[int, int]], set[int], set[int]]:
-        """
-        Associate detections to tracks based on Similarity (IoU) using the
-        Jonker-Volgenant algorithm approach with no initialization instead of the
-        Hungarian algorithm as mentioned in the SORT paper, but it solves the
-        assignment problem in an optimal way.
+        """Associate detections to tracks based on similarity (IoU).
+
+        Uses the Jonker-Volgenant algorithm (via ``linear_sum_assignment``)
+        to solve the assignment optimally.
 
         Args:
-            similarity_matrix: Similarity matrix between tracks (rows) and detections (columns).
-            min_similarity_thresh: Minimum similarity threshold for a valid match.
+            similarity_matrix: Similarity matrix between tracks (rows) and
+                detections (columns).  Used by the solver for ranking.
+            min_similarity_thresh: Minimum similarity threshold for a valid
+                match.
+            raw_similarity: Optional unmodified similarity matrix.  When
+                provided, the threshold check uses this matrix instead of
+                ``similarity_matrix`` so that solver-side discounts (e.g.
+                the age discount) cannot reject otherwise valid matches.
 
         Returns:
-            Matched indices (list of (tracker_idx, detection_idx)), indices of
-                unmatched tracks, indices of unmatched detections.
-        """  # noqa: E501
+            Matched indices (list of (tracker_idx, detection_idx)), indices
+                of unmatched tracks, indices of unmatched detections.
+        """
         matched_indices = []
         n_tracks, n_detections = similarity_matrix.shape
         unmatched_tracks = set(range(n_tracks))
         unmatched_detections = set(range(n_detections))
 
+        # Use raw similarity for threshold gating when available
+        thresh_matrix = raw_similarity if raw_similarity is not None else similarity_matrix
+
         if n_tracks > 0 and n_detections > 0:
             row_indices, col_indices = linear_sum_assignment(
                 similarity_matrix, maximize=True
             )
             for row, col in zip(row_indices, col_indices):
-                if similarity_matrix[row, col] >= min_similarity_thresh:
+                if thresh_matrix[row, col] >= min_similarity_thresh:
                     matched_indices.append((row, col))
                     unmatched_tracks.remove(row)
                     unmatched_detections.remove(col)