Use single 30-frame ASL upload inference

signspeak/asl/asl_detector.py

@@ -48,25 +48,11 @@ class ASLDetector:
 
         try:
             interpreter = self._load_interpreter()
-            window_results = []
-            for window_index, window_keypoints in enumerate(self._keypoint_windows(keypoints)):
-                output = self._predict(interpreter, window_keypoints)
-                probs = self._softmax_if_needed(np.asarray(output).reshape(-1))
-                top_idx = int(np.argmax(probs))
-                window_results.append(
-                    {
-                        "window_index": window_index,
-                        "probs": probs,
-                        "top_idx": top_idx,
-                        "confidence": float(probs[top_idx]),
-                    }
-                )
-
-            best = max(window_results, key=lambda item: item["confidence"])
-            probs = best["probs"]
-            top_idx = int(best["top_idx"])
+            output = self._predict(interpreter, keypoints.astype(np.float32))
+            probs = self._softmax_if_needed(np.asarray(output).reshape(-1))
+            top_idx = int(np.argmax(probs))
             top_prediction = self._label_for_index(top_idx)
-            confidence = float(best["confidence"])
+            confidence = float(probs[top_idx])
             accepted = confidence >= self.confidence_threshold
 
             base.update(
@@ -77,8 +63,6 @@ class ASLDetector:
                     "confidence": confidence,
                     "confidence_threshold": self.confidence_threshold,
                     "top_predictions": self._top_predictions(probs),
-                    "windows_analyzed": len(window_results),
-                    "best_window_index": int(best["window_index"]),
                 }
             )
             return base
@@ -129,24 +113,6 @@ class ASLDetector:
             return "outputs"
         return next(iter(prediction))
 
-    def _keypoint_windows(self, keypoints: np.ndarray, window_size: int = 30, max_windows: int = 5) -> list[np.ndarray]:
-        frame_count = int(keypoints.shape[0])
-        if frame_count <= window_size:
-            return [keypoints.astype(np.float32)]
-
-        max_start = frame_count - window_size
-        if max_windows <= 1:
-            starts = [max_start // 2]
-        else:
-            starts = np.linspace(0, max_start, num=min(max_windows, max_start + 1), dtype=int).tolist()
-
-        unique_starts = []
-        for start in starts:
-            if start not in unique_starts:
-                unique_starts.append(int(start))
-
-        return [keypoints[start : start + window_size].astype(np.float32) for start in unique_starts]
-
     def _prepare_input(self, keypoints: np.ndarray, input_detail: dict[str, Any]) -> np.ndarray:
         shape = input_detail.get("shape")
         dtype = input_detail.get("dtype", np.float32)

signspeak/asl/pipeline.py

@@ -12,7 +12,7 @@ from .video_utils import sample_video_frames, sample_video_frames_for_emotion
 
 def process_asl_video(video_path: str | Path) -> dict[str, Any]:
     path = Path(video_path)
-    asl_frames = sample_video_frames(path, target_frames=90)
+    asl_frames = sample_video_frames(path, target_frames=30)
     emotion_frames = sample_video_frames_for_emotion(path, target_frames=12)
 
     return process_asl_frames(asl_frames, emotion_frames, source=str(path))

tests/test_asl_detector.py

@@ -85,13 +85,3 @@ def test_low_confidence_prediction_is_not_accepted(monkeypatch, tmp_path):
     assert result["status"] == "low_confidence"
     assert result["top_prediction"] == "where"
     assert result["gloss_sequence"] == []
-
-
-def test_keypoint_windows_cover_long_sequences(tmp_path):
-    detector = ASLDetector(model_dir=tmp_path)
-    keypoints = np.zeros((90, 543, 3), dtype=np.float32)
-
-    windows = detector._keypoint_windows(keypoints, window_size=30, max_windows=5)
-
-    assert len(windows) == 5
-    assert all(window.shape == (30, 543, 3) for window in windows)