Update app.py

app.py

@@ -1,45 +1,55 @@
 import gradio as gr
 import torch
+import torchvision.transforms as transforms
+from torchvision.models.detection import detr
 from PIL import Image
-from transformers import DetrImageProcessor, DetrForObjectDetection
 import cv2
 import numpy as np
 
-# Load the pre-trained DETR model
-processor = DetrImageProcessor.from_pretrained("facebook/detr-resnet-50", revision="no_timm")
-model = DetrForObjectDetection.from_pretrained("facebook/detr-resnet-50", revision="no_timm")
-model.eval()
+# Load the pretrained DETR model
+device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+model = detr.DETR(resnet50=True)
+model = model.to(device).eval()
 
-# Function for image object detection
-def image_object_detection(image_pil):
-    # Process the image with the DETR model
-    inputs = processor(images=image_pil, return_tensors="pt")
-    outputs = model(**inputs)
+# Define the transformation for the input image
+transform = transforms.Compose([
+    transforms.ToTensor(),
+    transforms.Resize((800, 800)),
+])
 
-    # Convert the image to numpy array for drawing bounding boxes
-    image_np = cv2.cvtColor(cv2.cvtColor(cv2.cvtColor(np.array(image_pil), cv2.COLOR_RGB2BGR), cv2.COLOR_BGR2RGB), cv2.COLOR_RGB2BGR)
+# Define the object detection function
+def detect_objects(frame):
+    # Convert the frame to PIL image
+    image = Image.fromarray(frame)
 
-    # convert outputs (bounding boxes and class logits) to COCO API
-    # let's only keep detections with score > 0.9
-    target_sizes = torch.tensor([image_pil.size[::-1]])
-    results = processor.post_process_object_detection(outputs, target_sizes=target_sizes, threshold=0.9)[0]
+    # Apply the transformation
+    image = transform(image).unsqueeze(0).to(device)
 
-    # Draw bounding boxes on the image
-    for score, label, box in zip(results["scores"], results["labels"], results["boxes"]):
-        box = [int(round(i)) for i in box.tolist()]
-        cv2.rectangle(image_np, (box[0], box[1]), (box[2], box[3]), (0, 255, 0), 2)
-        label_text = f"{model.config.id2label[label.item()]}: {round(score.item(), 3)}"
-        cv2.putText(image_np, label_text, (box[0], box[1] - 10), cv2.FONT_HERSHEY_SIMPLEX, 0.5, (0, 255, 0), 2)
+    # Perform object detection
+    with torch.no_grad():
+        outputs = model(image)
 
-    return image_np
+    # Get the bounding boxes and labels
+    boxes = outputs['pred_boxes'][0].cpu().numpy()
+    labels = outputs['pred_classes'][0].cpu().numpy()
+
+    # Draw bounding boxes on the frame
+    for box, label in zip(boxes, labels):
+        box = [int(coord) for coord in box]
+        frame = cv2.rectangle(frame, (box[0], box[1]), (box[2], box[3]), (0, 255, 0), 2)
+        frame = cv2.putText(frame, f'Class: {label}', (box[0], box[1] - 10),
+                            cv2.FONT_HERSHEY_SIMPLEX, 0.5, (0, 255, 0), 2, cv2.LINE_AA)
+
+    return frame
 
 # Define the Gradio interface
 iface = gr.Interface(
-    fn=image_object_detection,
-    inputs=gr.Image(type="pil", label="Upload an image for object detection"),
-    outputs="image",
+    fn=detect_objects,
+    inputs=gr.Video(),
+    outputs="video",
     live=True,
+    capture_session=True,
 )
 
-# Launch the Gradio interface
+# Launch the Gradio app
 iface.launch()