latest changes

app.py

@@ -9,14 +9,16 @@ from collections import deque
 import base64
 import io
 
+# --- Configuration ---
 HF_MODEL_REPO_ID = "owinymarvin/timesformer-crime-detection"
 MODEL_INPUT_NUM_FRAMES = 8
 TARGET_IMAGE_HEIGHT = 224
 TARGET_IMAGE_WIDTH = 224
 RAW_RECORDING_DURATION_SECONDS = 10.0
 FRAMES_TO_SAMPLE_PER_CLIP = 20
-DELAY_BETWEEN_PREDICTIONS_SECONDS = 120.0
+DELAY_BETWEEN_PREDICTIONS_SECONDS = 120.0 # 2 minutes for CPU
 
+# --- Load Model and Processor ---
 print(f"Loading model and processor from {HF_MODEL_REPO_ID}...")
 try:
     processor = AutoImageProcessor.from_pretrained(HF_MODEL_REPO_ID)
@@ -30,57 +32,57 @@ device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
 model.to(device)
 print(f"Model loaded on {device}.")
 
+# --- Global State Variables for Live Demo ---
 raw_frames_buffer = deque()
 current_clip_start_time = time.time()
 last_prediction_completion_time = time.time()
-app_state = "recording"
+app_state = "recording" # States: "recording", "predicting", "processing_delay"
 
+# --- Helper function to sample frames ---
 def sample_frames(frames_list, target_count):
     if not frames_list:
         return []
     if len(frames_list) <= target_count:
         return frames_list
     indices = np.linspace(0, len(frames_list) - 1, target_count, dtype=int)
-    # FIX: Corrected list indexing from () to []
     sampled = [frames_list[int(i)] for i in indices]
     return sampled
 
+# --- Main processing function for Live Demo Stream ---
 def live_predict_stream(image_np_array):
     global raw_frames_buffer, current_clip_start_time, last_prediction_completion_time, app_state
 
     current_time = time.time()
     pil_image = Image.fromarray(image_np_array)
 
-    status_message = ""
-    prediction_result = ""
-
     if app_state == "recording":
         raw_frames_buffer.append(pil_image)
         elapsed_recording_time = current_time - current_clip_start_time
-        status_message = f"Recording: {elapsed_recording_time:.1f}/{RAW_RECORDING_DURATION_SECONDS}s. Raw frames: {len(raw_frames_buffer)}"
-        prediction_result = "Buffering..."
+        
+        yield f"Recording: {elapsed_recording_time:.1f}/{RAW_RECORDING_DURATION_SECONDS}s. Raw frames: {len(raw_frames_buffer)}", "Buffering..."
+
         if elapsed_recording_time >= RAW_RECORDING_DURATION_SECONDS:
+            # Transition to predicting state
             app_state = "predicting"
-            status_message = "Preparing to predict..."
-            prediction_result = "Processing..."
+            yield "Preparing to predict...", "Processing..."
             print("DEBUG: Transitioning to 'predicting' state.")
 
     elif app_state == "predicting":
-        if raw_frames_buffer:
+        # Ensure this prediction block only runs once per cycle
+        if raw_frames_buffer: # Only proceed if there are frames to process
             print("DEBUG: Starting prediction.")
             try:
                 sampled_raw_frames = sample_frames(list(raw_frames_buffer), FRAMES_TO_SAMPLE_PER_CLIP)
                 frames_for_model = sample_frames(sampled_raw_frames, MODEL_INPUT_NUM_FRAMES)
 
                 if len(frames_for_model) < MODEL_INPUT_NUM_FRAMES:
-                    prediction_result = "Error: Not enough frames for model."
-                    status_message = "Error during frame sampling."
-                    print(f"ERROR: Insufficient frames for model input: {len(frames_for_model)}/{MODEL_INPUT_NUM_FRAMES}")
-                    app_state = "recording" # Reset to recording state
+                    yield "Error during frame sampling.", f"Error: Not enough frames ({len(frames_for_model)}/{MODEL_INPUT_NUM_FRAMES}). Resetting."
+                    print(f"ERROR: Insufficient frames for model input: {len(frames_for_model)}/{MODEL_INPUT_NUM_FRAMES}. Resetting state.")
+                    app_state = "recording" # Reset state to start a new recording
                     raw_frames_buffer.clear()
                     current_clip_start_time = time.time()
                     last_prediction_completion_time = time.time()
-                    return status_message, prediction_result
+                    return # Exit this stream call to wait for next frame or reset
 
                 processed_input = processor(images=frames_for_model, return_tensors="pt")
                 pixel_values = processed_input.pixel_values.to(device)
@@ -96,32 +98,45 @@ def live_predict_stream(image_np_array):
                 prediction_result = f"Predicted: {predicted_label} (Confidence: {confidence:.2f})"
                 status_message = "Prediction complete."
                 print(f"DEBUG: Prediction Result: {prediction_result}")
+                
+                # Yield the prediction result immediately to ensure UI update
+                yield status_message, prediction_result
 
+                # Clear buffer and transition to delay AFTER yielding the prediction
                 raw_frames_buffer.clear()
                 last_prediction_completion_time = current_time
                 app_state = "processing_delay"
                 print("DEBUG: Transitioning to 'processing_delay' state.")
 
             except Exception as e:
-                prediction_result = f"Error during prediction: {e}"
-                status_message = "Prediction error."
+                error_message = f"Error during prediction: {e}"
                 print(f"ERROR during prediction: {e}")
-                app_state = "processing_delay" # Move to delay to avoid continuous errors
-        else:
-            status_message = "Waiting for frames..."
-            prediction_result = "..."
+                # Yield error to UI
+                yield "Prediction error.", error_message
+                app_state = "processing_delay" # Still go to delay state to prevent constant errors
+                raw_frames_buffer.clear() # Clear buffer to prevent re-processing same problematic frames
 
     elif app_state == "processing_delay":
         elapsed_delay = current_time - last_prediction_completion_time
-        status_message = f"Delaying next prediction: {int(elapsed_delay)}/{int(DELAY_BETWEEN_PREDICTIONS_SECONDS)}s"
-        if elapsed_delay >= DELAY_BETWEEN_PREDICTIONS_SECONDS:
+        
+        if elapsed_delay < DELAY_BETWEEN_PREDICTIONS_SECONDS:
+            # Continue yielding the delay message and the last prediction result
+            # Assuming prediction_result from previous state is still held by UI
+            yield f"Delaying next prediction: {int(elapsed_delay)}/{int(DELAY_BETWEEN_PREDICTIONS_SECONDS)}s", gr.NO_VALUE # NO_VALUE keeps previous prediction visible
+        else:
+            # Delay is over, reset for new recording cycle
             app_state = "recording"
             current_clip_start_time = current_time
-            status_message = "Starting new recording..."
-            prediction_result = "Ready..."
             print("DEBUG: Transitioning back to 'recording' state.")
-
-    return status_message, prediction_result
+            yield "Starting new recording...", "Ready for new prediction."
+    
+    # If for some reason nothing is yielded, return the current state to prevent UI freeze.
+    # This acts as a fallback if no state transition happens.
+    # However, with the yield statements, this might be less critical.
+    # For streaming, yielding is the preferred way to update.
+    # If the function ends without yielding, Gradio will just keep the last state.
+    # We always yield in every branch.
+    pass # No explicit return needed at the end if all paths yield
 
 def reset_app_state_manual():
     global raw_frames_buffer, current_clip_start_time, last_prediction_completion_time, app_state
@@ -130,8 +145,10 @@ def reset_app_state_manual():
     last_prediction_completion_time = time.time()
     app_state = "recording"
     print("DEBUG: Manual reset triggered.")
+    # Return initial values immediately upon reset
     return "Ready to record...", "Ready for new prediction."
 
+# --- Gradio UI Layout ---
 with gr.Blocks() as demo:
     gr.Markdown(
         f"""
@@ -160,11 +177,15 @@ with gr.Blocks() as demo:
             with gr.Column():
                 prediction_output = gr.Textbox(label="Prediction Result", value="Waiting...")
 
+        # IMPORTANT: Use webcam_input.stream() with a generator function (live_predict_stream)
+        # to enable progressive updates via 'yield'.
         webcam_input.stream(
             live_predict_stream,
             inputs=[webcam_input],
             outputs=[status_output, prediction_output]
         )
+        
+        # The reset button is a regular click event, not a stream
         reset_button.click(
             reset_app_state_manual,
             inputs=[],
@@ -177,19 +198,14 @@ with gr.Blocks() as demo:
             Use this API endpoint to send base64-encoded frames for prediction.
             """
         )
-        # Re-adding a slightly more representative API interface
-        # Gradio's automatic API documentation will use this to show inputs/outputs
+        # Placeholder for the API tab. The actual API calls target /run/predict_from_frames_api
         gr.Interface(
-            fn=lambda frames_list: f"Received {len(frames_list)} frames. This is a dummy response. Integrate predict_from_frames_api here.",
+            fn=lambda frames_list: "API endpoint is active for programmatic calls. See documentation in app.py.",
             inputs=gr.Json(label="List of Base64-encoded image strings"),
             outputs=gr.Textbox(label="API Response"),
             live=False,
-            allow_flagging="never" # For API endpoints, flagging is usually not desired
+            allow_flagging="never"
         )
-        # Note: The actual `predict_from_frames_api` function is defined above,
-        # but for a clean API tab, we can use a dummy interface here that Gradio will
-        # use to generate the interactive API documentation. The actual API call
-        # from your local script directly targets the /run/predict_from_frames_api endpoint.
 
 
 if __name__ == "__main__":