Update app.py

app.py

@@ -3,19 +3,32 @@ import torch
 import numpy as np
 from transformers import AutoProcessor, AutoModel
 from PIL import Image
-from decord import VideoReader, cpu, gpu
+import cv2 
 
 MODEL_NAME = "microsoft/xclip-base-patch16-zero-shot"
 CLIP_LEN = 32
 
-# Check for GPU availability
-device = "cuda" if torch.cuda.is_available() else "cpu"
-print (device)
-
-# Load model and processor once and move them to the GPU
+# Load model and processor once
 processor = AutoProcessor.from_pretrained(MODEL_NAME)
-model = AutoModel.from_pretrained(MODEL_NAME).to(device)
-model.eval()
+model = AutoModel.from_pretrained(MODEL_NAME)
+
+
+def get_video_length(file_path):
+    cap = cv2.VideoCapture(file_path)
+    length = int(cap.get(cv2.CAP_PROP_FRAME_COUNT))
+    cap.release()
+    return length
+
+def read_video_opencv(file_path, indices):
+    cap = cv2.VideoCapture(file_path)
+    frames = []
+    for i in indices:
+        cap.set(cv2.CAP_PROP_POS_FRAMES, i)
+        ret, frame = cap.read()
+        if ret:
+            frames.append(cv2.cvtColor(frame, cv2.COLOR_BGR2RGB))
+    cap.release()
+    return frames
 
 def sample_uniform_frame_indices(clip_len, seg_len):
     if seg_len < clip_len:
@@ -27,12 +40,7 @@ def sample_uniform_frame_indices(clip_len, seg_len):
         indices = [i * spacing for i in range(clip_len)]
     return np.array(indices).astype(np.int64)
 
-def read_video_decord(file_path, indices):
-    # Use GPU for video decoding if available
-    vr_ctx = cpu(0)
-    vr = VideoReader(file_path, num_threads=1, ctx=vr_ctx)
-    video = vr.get_batch(indices).asnumpy()
-    return video
+
 
 def concatenate_frames(frames, clip_len):
     layout = { 32: (4, 8) }
@@ -50,24 +58,18 @@ def concatenate_frames(frames, clip_len):
     return combined_image
 
 def model_interface(uploaded_video, activity):
-    indices = sample_uniform_frame_indices(CLIP_LEN, seg_len=len(VideoReader(uploaded_video)))
-    video = read_video_decord(uploaded_video, indices)
+    video_length = get_video_length(uploaded_video)
+    indices = sample_uniform_frame_indices(CLIP_LEN, seg_len=video_length)
+    video = read_video_opencv(uploaded_video, indices)
     concatenated_image = concatenate_frames(video, CLIP_LEN)
 
     activities_list = [activity, "other"]
-    
-    # Convert list of numpy.ndarrays to a single numpy.ndarray
-    video_array = np.array(video)
-    
     inputs = processor(
         text=activities_list,
-        videos=video_array,
+        videos=list(video),
         return_tensors="pt",
         padding=True,
     )
-    
-    # Move inputs to GPU
-    inputs = {name: tensor.to(device) for name, tensor in inputs.items()}
 
     with torch.no_grad():
         outputs = model(**inputs)
@@ -80,13 +82,13 @@ def model_interface(uploaded_video, activity):
     max_prob_index = torch.argmax(probs[0]).item()
     for i in range(len(activities_list)):
         current_activity = activities_list[i]
-        prob = float(probs[0][i].cpu())
-        logit = float(logits_per_video[0][i].cpu())
+        prob = float(probs[0][i])
+        logit = float(logits_per_video[0][i])
         results_probs.append((current_activity, f"Probability: {prob * 100:.2f}%"))
         results_logits.append((current_activity, f"Raw Score: {logit:.2f}"))
 
     likely_label = activities_list[max_prob_index]
-    likely_probability = float(probs[0][max_prob_index].cpu()) * 100
+    likely_probability = float(probs[0][max_prob_index]) * 100
 
     return concatenated_image, results_probs, results_logits, [ likely_label , likely_probability ]