latest changes

app copy.py

@@ -1,101 +0,0 @@
-import gradio as gr
-import torch
-from transformers import AutoImageProcessor, TimesformerForVideoClassification
-import cv2
-from PIL import Image
-import numpy as np
-import time
-from collections import deque
-
-# --- Configuration ---
-# Your Hugging Face model repository ID
-HF_MODEL_REPO_ID = "owinymarvin/timesformer-crime-detection"
-
-# These must match the values used during your training
-NUM_FRAMES = 8
-TARGET_IMAGE_HEIGHT = 224
-TARGET_IMAGE_WIDTH = 224
-
-# --- Load Model and Processor ---
-print(f"Loading model and image processor from {HF_MODEL_REPO_ID}...")
-try:
-    processor = AutoImageProcessor.from_pretrained(HF_MODEL_REPO_ID)
-    model = TimesformerForVideoClassification.from_pretrained(HF_MODEL_REPO_ID)
-except Exception as e:
-    print(f"Error loading model from Hugging Face Hub: {e}")
-    # Handle error - exit or raise exception for Space to fail gracefully
-    exit()
-
-model.eval() # Set model to evaluation mode
-device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
-model.to(device)
-print(f"Model loaded successfully on {device}.")
-print(f"Model's class labels: {model.config.id2label}")
-
-# Initialize a global buffer for frames for the session
-# Use a deque for efficient appending/popping from both ends
-frame_buffer = deque(maxlen=NUM_FRAMES)
-last_inference_time = time.time()
-inference_interval = 1.0 # Predict every 1 second (1.0 / INFERENCE_FPS)
-current_prediction_text = "Buffering frames..." # Initialize global text
-
-def predict_video_frame(image_np_array):
-    global frame_buffer, last_inference_time, current_prediction_text
-
-    # Gradio sends frames as numpy arrays (RGB)
-    # The image_processor will handle the resizing to TARGET_IMAGE_HEIGHT x TARGET_IMAGE_WIDTH
-    pil_image = Image.fromarray(image_np_array)
-    frame_buffer.append(pil_image)
-
-    current_time = time.time()
-
-    # Only perform inference if we have enough frames and it's time for a prediction
-    if len(frame_buffer) == NUM_FRAMES and (current_time - last_inference_time) >= inference_interval:
-        last_inference_time = current_time
-
-        # Preprocess the frames. processor expects a list of PIL Images or numpy arrays
-        # It will handle resizing and normalization based on its config
-        processed_input = processor(images=list(frame_buffer), return_tensors="pt")
-        pixel_values = processed_input.pixel_values.to(device)
-
-        with torch.no_grad():
-            outputs = model(pixel_values)
-            logits = outputs.logits
-
-        predicted_class_id = logits.argmax(-1).item()
-        predicted_label = model.config.id2label[predicted_class_id]
-        confidence = torch.nn.functional.softmax(logits, dim=-1)[0][predicted_class_id].item()
-
-        current_prediction_text = f"Predicted: {predicted_label} ({confidence:.2f})"
-        print(current_prediction_text) # Print to Space logs
-    
-    # Return the current prediction text for display in the UI
-    # Gradio's streaming will update this textbox asynchronously
-    return current_prediction_text
-
-# --- Gradio Interface ---
-# Create a streaming input for webcam
-webcam_input = gr.Image(
-    sources=["webcam"], # Allows webcam input
-    streaming=True,      # Enables continuous streaming of frames
-    # REMOVED: shape=(TARGET_IMAGE_WIDTH, TARGET_IMAGE_HEIGHT), # This was causing the TypeError
-    label="Live Webcam Feed"
-)
-
-# Output text box for predictions
-prediction_output = gr.Textbox(label="Real-time Prediction", value="Buffering frames...")
-
-
-# Define the Gradio Interface
-demo = gr.Interface(
-    fn=predict_video_frame,
-    inputs=webcam_input,
-    outputs=prediction_output,
-    live=True, # Enable live updates
-    allow_flagging="never", # Disable flagging on public demo
-    title="TimesFormer Crime Detection Live Demo",
-    description=f"This demo uses a finetuned TimesFormer model ({HF_MODEL_REPO_ID}) to predict crime actions from a live webcam feed. The model processes {NUM_FRAMES} frames at a time and makes a prediction every {inference_interval} seconds. Please allow webcam access.",
-)
-
-if __name__ == "__main__":
-    demo.launch()

app.py

@@ -7,10 +7,9 @@ import json
 from PIL import Image
 from torchvision import transforms
 from huggingface_hub import hf_hub_download
-import tempfile # For temporary file handling
+import time # For potential sleep to control frame rate if needed
 
 # --- 1. Define Model Architecture (Copy from small_video_classifier.py) ---
-# This is crucial because we need the model class definition to load weights.
 class SmallVideoClassifier(torch.nn.Module):
     def __init__(self, num_classes=2, num_frames=8):
         super(SmallVideoClassifier, self).__init__()
@@ -59,7 +58,7 @@ CLASS_LABELS = ["Non-violence", "Violence"]
 if NUM_CLASSES != len(CLASS_LABELS):
     print(f"Warning: NUM_CLASSES in config ({NUM_CLASSES}) does not match hardcoded CLASS_LABELS length ({len(CLASS_LABELS)}). Adjust CLASS_LABELS if needed.")
 
-device = torch.device("cpu")
+device = torch.device("cpu") # Explicitly use CPU
 print(f"Using device: {device}")
 
 model = SmallVideoClassifier(num_classes=NUM_CLASSES, num_frames=NUM_FRAMES)
@@ -79,106 +78,98 @@ transform = transforms.Compose([
     transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]),
 ])
 
-# --- 4. Gradio Inference Function ---
-def predict_video(video_path):
-    if video_path is None:
-        return None
-
-    cap = cv2.VideoCapture(video_path)
-
-    if not cap.isOpened():
-        print(f"Error: Could not open video file {video_path}.")
-        raise ValueError(f"Could not open video file {video_path}. Please ensure it's a valid video format.")
-
-    frame_width = int(cap.get(cv2.CAP_PROP_FRAME_WIDTH))
-    frame_height = int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT))
-    fps = cap.get(cv2.CAP_PROP_FPS)
-    # Ensure FPS is not zero to avoid division by zero errors, default to 25 if needed
-    if fps <= 0:
-        fps = 25.0
-        print(f"Warning: Original video FPS was 0 or less, defaulting to {fps}.")
-
-    total_frames = int(cap.get(cv2.CAP_PROP_FRAME_COUNT))
-
-    temp_output_file = tempfile.NamedTemporaryFile(suffix=".mp4", delete=False)
-    output_video_path = temp_output_file.name
-    temp_output_file.close()
-
-    # --- CHANGED: Use XVID codec for better browser compatibility ---
-    # This might prevent Gradio's internal re-encoding.
-    fourcc = cv2.VideoWriter_fourcc(*'XVID')
-    out = cv2.VideoWriter(output_video_path, fourcc, fps, (frame_width, frame_height))
-
-    print(f"Processing video: {video_path}")
-    print(f"Total frames: {total_frames}, FPS: {fps}")
-    print(f"Output video will be saved to: {output_video_path}")
-
-    frame_buffer = []
-    current_prediction_label = "Processing..."
-
-    frame_idx = 0
-    while True:
-        ret, frame = cap.read()
-        if not ret:
-            break
-
-        frame_idx += 1
-        
-        frame_rgb = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
-        pil_image = Image.fromarray(frame_rgb)
-        
-        processed_frame = transform(pil_image)
-        frame_buffer.append(processed_frame)
-
-        if len(frame_buffer) == NUM_FRAMES:
-            input_tensor = torch.stack(frame_buffer, dim=0).unsqueeze(0).to(device)
-
-            with torch.no_grad():
-                outputs = model(input_tensor)
-                probabilities = torch.softmax(outputs, dim=1)
-                predicted_class_idx = torch.argmax(probabilities, dim=1).item()
-                current_prediction_label = f"Prediction: {CLASS_LABELS[predicted_class_idx]} (Prob: {probabilities[0, predicted_class_idx]:.2f})"
+# --- 4. Gradio Live Inference Function (Generator) ---
+# This function will receive individual frames from the webcam
+def predict_live_frames(input_frame):
+    global frame_buffer, current_prediction_label, current_probabilities # Use global to maintain state across calls
+
+    if input_frame is None:
+        # If no frame is received (e.g., webcam not active), yield a black frame or handle gracefully
+        dummy_frame = np.zeros((200, 400, 3), dtype=np.uint8)
+        cv2.putText(dummy_frame, "Waiting for webcam input...", (10, 100), cv2.FONT_HERSHEY_SIMPLEX, 0.7, (255, 255, 255), 2)
+        yield dummy_frame
+        return # Exit if no frame to process
+    
+    # Gradio Webcam gives NumPy array (H, W, C) in RGB
+    pil_image = Image.fromarray(input_frame)
+    
+    # Apply transformations (outputs C, H, W tensor)
+    processed_frame_tensor = transform(pil_image)
+    frame_buffer.append(processed_frame_tensor)
+
+    # Perform prediction only when the buffer is full
+    if len(frame_buffer) == NUM_FRAMES:
+        # Stack the buffered frames and add a batch dimension
+        input_tensor = torch.stack(frame_buffer, dim=0).unsqueeze(0).to(device)
+
+        with torch.no_grad():
+            outputs = model(input_tensor)
+            probabilities = torch.softmax(outputs, dim=1)
+            predicted_class_idx = torch.argmax(probabilities, dim=1).item()
             
-            frame_buffer = [] 
-            # If you want a sliding window, you would do something like:
-            # frame_buffer = frame_buffer[int(NUM_FRAMES * 0.5):] # Slide by half the window size
-
-        # Draw prediction text on the current frame
-        # Ensure text color is clearly visible (e.g., white or bright green)
-        # Add a black outline for better readability
-        text_color = (0, 255, 0) # Green (BGR format for OpenCV)
-        text_outline_color = (0, 0, 0) # Black
-        font_scale = 1.0 # Increased font size
-        font_thickness = 2
+            current_prediction_label = f"Class: {CLASS_LABELS[predicted_class_idx]}"
+            current_probabilities = {CLASS_LABELS[i]: prob.item() for i, prob in enumerate(probabilities[0])}
         
-        # Draw outline first for better readability
-        cv2.putText(frame, current_prediction_label, (10, 40), # Slightly lower position
-                    cv2.FONT_HERSHEY_SIMPLEX, font_scale, text_outline_color, font_thickness + 2, cv2.LINE_AA)
-        # Draw actual text
-        cv2.putText(frame, current_prediction_label, (10, 40),
-                    cv2.FONT_HERSHEY_SIMPLEX, font_scale, text_color, font_thickness, cv2.LINE_AA)
-
-        out.write(frame)
-
-    cap.release()
-    out.release()
-    print(f"Video processing complete. Output saved to: {output_video_path}")
+        # --- Sliding Window ---
+        # Keep the last few frames to allow continuous predictions
+        # For example, if NUM_FRAMES is 8, and we want a new prediction every 2 frames,
+        # we slide the window by 2:
+        slide_window_by = 1 # Predict every frame (most "real-time" feel but highest compute)
+                           # Or: NUM_FRAMES // 2 (e.g., predict every 4 frames for NUM_FRAMES=8)
+                           # Or: NUM_FRAMES (non-overlapping windows, less frequent updates)
+        frame_buffer = frame_buffer[slide_window_by:] 
+
+    # --- Draw Prediction on the current input frame ---
+    # Convert the input_frame (RGB NumPy array) to BGR for OpenCV drawing
+    display_frame = cv2.cvtColor(input_frame, cv2.COLOR_RGB2BGR)
+
+    # Draw the main prediction label
+    text_color = (0, 255, 0) # Green (BGR)
+    text_outline_color = (0, 0, 0) # Black
+    font_scale = 1.0
+    font_thickness = 2
     
-    return output_video_path
+    # Draw outline first for better readability
+    cv2.putText(display_frame, current_prediction_label, (10, 40),
+                cv2.FONT_HERSHEY_SIMPLEX, font_scale, text_outline_color, font_thickness + 2, cv2.LINE_AA)
+    # Draw actual text
+    cv2.putText(display_frame, current_prediction_label, (10, 40),
+                cv2.FONT_HERSHEY_SIMPLEX, font_scale, text_color, font_thickness, cv2.LINE_AA)
+
+    # Draw probabilities for all classes (like YOLO)
+    y_offset = 80 # Start drawing probabilities slightly lower
+    for label, prob in current_probabilities.items():
+        prob_text = f"{label}: {prob:.2f}"
+        cv2.putText(display_frame, prob_text, (10, y_offset),
+                    cv2.FONT_HERSHEY_SIMPLEX, 0.7, text_outline_color, 2, cv2.LINE_AA)
+        cv2.putText(display_frame, prob_text, (10, y_offset),
+                    cv2.FONT_HERSHEY_SIMPLEX, 0.7, (255, 255, 0), 1, cv2.LINE_AA) # Yellow for probs
+        y_offset += 30 # Move down for next probability
+
+    # Yield the processed frame back to Gradio for display
+    # Gradio expects RGB NumPy array for video/image components
+    yield cv2.cvtColor(display_frame, cv2.COLOR_BGR2RGB)
+
+
+# --- Initialize global state for the generator function ---
+frame_buffer = [] # Buffer for collecting frames for model input
+current_prediction_label = "Initializing..."
+current_probabilities = {label: 0.0 for label in CLASS_LABELS} # Initial probabilities
 
 # --- 5. Gradio Interface Setup ---
 iface = gr.Interface(
-    fn=predict_video,
-    inputs=gr.Video(label="Upload Video for Violence Detection (MP4 recommended)"),
-    outputs=gr.Video(label="Processed Video with Predictions"),
-    title="Real-time Violence Detection with SmallVideoClassifier",
-    description="Upload a video, and the model will analyze it for violence, displaying the predicted class and confidence on each frame.",
-    allow_flagging="never",
-    examples=[
-        # Add example videos here for easier testing and demonstration
-        # E.g., a sample video that's publicly accessible:
-        # "https://huggingface.co/datasets/gradio/test-files/resolve/main/video.mp4"
-    ]
+    fn=predict_live_frames,
+    # Use gr.Webcam for direct webcam input
+    inputs=gr.Webcam(streaming=True, label="Live Webcam Feed for Violence Detection"),
+    # Outputs are updated continuously by the generator
+    outputs=gr.Image(type="numpy", label="Live Prediction Output"), # Using Image as output for continuous frames
+    title="Real-time Violence Detection with SmallVideoClassifier (Webcam)",
+    description=(
+        "This model detects violence in a live webcam feed. "
+        "Predictions (Class and Probabilities) will be displayed on each frame. "
+        "Please allow webcam access when prompted."
+    ),
+    allow_flagging="never", # Disable flagging on Hugging Face Spaces
 )
 
 iface.launch()

good copy.py

@@ -1,212 +1,184 @@
 import gradio as gr
 import torch
-from transformers import AutoImageProcessor, TimesformerForVideoClassification
 import cv2
-from PIL import Image
 import numpy as np
-import time
-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 # 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)
-    model = TimesformerForVideoClassification.from_pretrained(HF_MODEL_REPO_ID)
-except Exception as e:
-    print(f"Error loading model: {e}")
-    exit()
+import os
+import json
+from PIL import Image
+from torchvision import transforms
+from huggingface_hub import hf_hub_download
+import tempfile # For temporary file handling
+
+# --- 1. Define Model Architecture (Copy from small_video_classifier.py) ---
+# This is crucial because we need the model class definition to load weights.
+class SmallVideoClassifier(torch.nn.Module):
+    def __init__(self, num_classes=2, num_frames=8):
+        super(SmallVideoClassifier, self).__init__()
+        from torchvision.models import mobilenet_v3_small, MobileNet_V3_Small_Weights
+        try:
+            weights = MobileNet_V3_Small_Weights.IMAGENET1K_V1
+        except Exception:
+            print("Warning: MobileNet_V3_Small_Weights.IMAGENET1K_V1 not found, initializing without pre-trained weights.")
+            weights = None
+
+        self.feature_extractor = mobilenet_v3_small(weights=weights)
+        self.feature_extractor.classifier = torch.nn.Identity()
+        self.num_spatial_features = 576
+        self.temporal_aggregator = torch.nn.AdaptiveAvgPool1d(1)
+        self.classifier = torch.nn.Sequential(
+            torch.nn.Linear(self.num_spatial_features, 512),
+            torch.nn.ReLU(),
+            torch.nn.Dropout(0.2),
+            torch.nn.Linear(512, num_classes)
+        )
 
-model.eval()
-device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+    def forward(self, pixel_values):
+        batch_size, num_frames, channels, height, width = pixel_values.shape
+        x = pixel_values.view(batch_size * num_frames, channels, height, width)
+        spatial_features = self.feature_extractor(x)
+        spatial_features = spatial_features.view(batch_size, num_frames, self.num_spatial_features)
+        temporal_features = self.temporal_aggregator(spatial_features.permute(0, 2, 1)).squeeze(-1)
+        logits = self.classifier(temporal_features)
+        return logits
+
+# --- 2. Configuration and Model Loading ---
+HF_USERNAME = "owinymarvin"
+NEW_MODEL_REPO_ID_SHORT = "timesformer-violence-detector"
+NEW_MODEL_REPO_ID = f"{HF_USERNAME}/{NEW_MODEL_REPO_ID_SHORT}"
+
+print(f"Downloading config.json from {NEW_MODEL_REPO_ID}...")
+config_path = hf_hub_download(repo_id=NEW_MODEL_REPO_ID, filename="config.json")
+with open(config_path, 'r') as f:
+    model_config = json.load(f)
+
+NUM_FRAMES = model_config.get('num_frames', 8)
+IMAGE_SIZE = tuple(model_config.get('image_size', [224, 224]))
+NUM_CLASSES = model_config.get('num_classes', 2)
+
+CLASS_LABELS = ["Non-violence", "Violence"]
+if NUM_CLASSES != len(CLASS_LABELS):
+    print(f"Warning: NUM_CLASSES in config ({NUM_CLASSES}) does not match hardcoded CLASS_LABELS length ({len(CLASS_LABELS)}). Adjust CLASS_LABELS if needed.")
+
+device = torch.device("cpu")
+print(f"Using device: {device}")
+
+model = SmallVideoClassifier(num_classes=NUM_CLASSES, num_frames=NUM_FRAMES)
+
+print(f"Downloading model weights from {NEW_MODEL_REPO_ID}...")
+model_weights_path = hf_hub_download(repo_id=NEW_MODEL_REPO_ID, filename="small_violence_classifier.pth")
+model.load_state_dict(torch.load(model_weights_path, map_location=device))
 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" # 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)
-    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)
-
-    if app_state == "recording":
-        raw_frames_buffer.append(pil_image)
-        elapsed_recording_time = current_time - current_clip_start_time
-        
-        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"
-            yield "Preparing to predict...", "Processing..."
-            print("DEBUG: Transitioning to 'predicting' state.")
-
-    elif app_state == "predicting":
-        # 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:
-                    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 # 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)
-
-                with torch.no_grad():
-                    outputs = model(pixel_values)
-                    logits = outputs.logits
-
-                predicted_class_id = logits.argmax(-1).item()
-                predicted_label = model.config.id2label.get(predicted_class_id, "Unknown")
-                confidence = torch.nn.functional.softmax(logits, dim=-1)[0][predicted_class_id].item()
-
-                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:
-                error_message = f"Error during prediction: {e}"
-                print(f"ERROR during prediction: {e}")
-                # 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
-        
-        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
-            print("DEBUG: Transitioning back to 'recording' state.")
-            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
-    raw_frames_buffer.clear()
-    current_clip_start_time = time.time()
-    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"""
-        # TimesFormer Crime Detection - Hugging Face Space Host
-        This Space hosts the `owinymarvin/timesformer-crime-detection` model.
-        Live webcam demo with recording and prediction phases.
-        """
-    )
-
-    with gr.Tab("Live Webcam Demo"):
-        gr.Markdown(
-            f"""
-            Continuously captures live webcam feed for **{RAW_RECORDING_DURATION_SECONDS} seconds**,
-            then makes a prediction. There is a **{DELAY_BETWEEN_PREDICTIONS_SECONDS/60:.0f} minute delay** afterwards.
-            """
-        )
-        with gr.Row():
-            with gr.Column():
-                webcam_input = gr.Image(
-                    sources=["webcam"],
-                    streaming=True,
-                    label="Live Webcam Feed"
-                )
-                status_output = gr.Textbox(label="Current Status", value="Initializing...")
-                reset_button = gr.Button("Reset / Start New Cycle")
-            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=[],
-            outputs=[status_output, prediction_output]
-        )
+model.eval()
 
-    with gr.Tab("API Endpoint for External Clients"):
-        gr.Markdown(
-            """
-            Use this API endpoint to send base64-encoded frames for prediction.
-            """
-        )
-        # Placeholder for the API tab. The actual API calls target /run/predict_from_frames_api
-        gr.Interface(
-            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"
-        )
+print(f"Model loaded successfully with {NUM_FRAMES} frames and image size {IMAGE_SIZE}.")
 
+# --- 3. Define Preprocessing Transform ---
+transform = transforms.Compose([
+    transforms.Resize(IMAGE_SIZE),
+    transforms.ToTensor(),
+    transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]),
+])
 
-if __name__ == "__main__":
-    demo.launch()
+# --- 4. Gradio Inference Function ---
+def predict_video(video_path):
+    if video_path is None:
+        return None
+
+    cap = cv2.VideoCapture(video_path)
+
+    if not cap.isOpened():
+        print(f"Error: Could not open video file {video_path}.")
+        raise ValueError(f"Could not open video file {video_path}. Please ensure it's a valid video format.")
+
+    frame_width = int(cap.get(cv2.CAP_PROP_FRAME_WIDTH))
+    frame_height = int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT))
+    fps = cap.get(cv2.CAP_PROP_FPS)
+    # Ensure FPS is not zero to avoid division by zero errors, default to 25 if needed
+    if fps <= 0:
+        fps = 25.0
+        print(f"Warning: Original video FPS was 0 or less, defaulting to {fps}.")
+
+    total_frames = int(cap.get(cv2.CAP_PROP_FRAME_COUNT))
+
+    temp_output_file = tempfile.NamedTemporaryFile(suffix=".mp4", delete=False)
+    output_video_path = temp_output_file.name
+    temp_output_file.close()
+
+    # --- CHANGED: Use XVID codec for better browser compatibility ---
+    # This might prevent Gradio's internal re-encoding.
+    fourcc = cv2.VideoWriter_fourcc(*'XVID')
+    out = cv2.VideoWriter(output_video_path, fourcc, fps, (frame_width, frame_height))
+
+    print(f"Processing video: {video_path}")
+    print(f"Total frames: {total_frames}, FPS: {fps}")
+    print(f"Output video will be saved to: {output_video_path}")
+
+    frame_buffer = []
+    current_prediction_label = "Processing..."
+
+    frame_idx = 0
+    while True:
+        ret, frame = cap.read()
+        if not ret:
+            break
+
+        frame_idx += 1
+        
+        frame_rgb = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
+        pil_image = Image.fromarray(frame_rgb)
+        
+        processed_frame = transform(pil_image)
+        frame_buffer.append(processed_frame)
+
+        if len(frame_buffer) == NUM_FRAMES:
+            input_tensor = torch.stack(frame_buffer, dim=0).unsqueeze(0).to(device)
+
+            with torch.no_grad():
+                outputs = model(input_tensor)
+                probabilities = torch.softmax(outputs, dim=1)
+                predicted_class_idx = torch.argmax(probabilities, dim=1).item()
+                current_prediction_label = f"Prediction: {CLASS_LABELS[predicted_class_idx]} (Prob: {probabilities[0, predicted_class_idx]:.2f})"
+            
+            frame_buffer = [] 
+            # If you want a sliding window, you would do something like:
+            # frame_buffer = frame_buffer[int(NUM_FRAMES * 0.5):] # Slide by half the window size
+
+        # Draw prediction text on the current frame
+        # Ensure text color is clearly visible (e.g., white or bright green)
+        # Add a black outline for better readability
+        text_color = (0, 255, 0) # Green (BGR format for OpenCV)
+        text_outline_color = (0, 0, 0) # Black
+        font_scale = 1.0 # Increased font size
+        font_thickness = 2
+        
+        # Draw outline first for better readability
+        cv2.putText(frame, current_prediction_label, (10, 40), # Slightly lower position
+                    cv2.FONT_HERSHEY_SIMPLEX, font_scale, text_outline_color, font_thickness + 2, cv2.LINE_AA)
+        # Draw actual text
+        cv2.putText(frame, current_prediction_label, (10, 40),
+                    cv2.FONT_HERSHEY_SIMPLEX, font_scale, text_color, font_thickness, cv2.LINE_AA)
+
+        out.write(frame)
+
+    cap.release()
+    out.release()
+    print(f"Video processing complete. Output saved to: {output_video_path}")
+    
+    return output_video_path
+
+# --- 5. Gradio Interface Setup ---
+iface = gr.Interface(
+    fn=predict_video,
+    inputs=gr.Video(label="Upload Video for Violence Detection (MP4 recommended)"),
+    outputs=gr.Video(label="Processed Video with Predictions"),
+    title="Real-time Violence Detection with SmallVideoClassifier",
+    description="Upload a video, and the model will analyze it for violence, displaying the predicted class and confidence on each frame.",
+    allow_flagging="never",
+    examples=[
+        # Add example videos here for easier testing and demonstration
+        # E.g., a sample video that's publicly accessible:
+        # "https://huggingface.co/datasets/gradio/test-files/resolve/main/video.mp4"
+    ]
+)
+
+iface.launch()