Upload 4 files

Dockerfile

@@ -0,0 +1,33 @@
+FROM python:3.10-slim
+
+WORKDIR /app
+
+# Install system dependencies
+RUN apt-get update && apt-get install -y \
+    libgl1-mesa-glx \
+    libglib2.0-0 \
+    && rm -rf /var/lib/apt/lists/*
+
+# Create a non-root user
+RUN useradd -m -u 1000 user
+USER user
+
+# Set environment variables for writable config directories
+ENV MPLCONFIGDIR=/home/user/.cache/matplotlib
+ENV YOLO_CONFIG_DIR=/home/user/.config/Ultralytics
+
+# Create the necessary directories
+RUN mkdir -p ${MPLCONFIGDIR} ${YOLO_CONFIG_DIR}
+
+# Copy and install Python dependencies
+COPY --chown=user:user requirements.txt .
+RUN pip install --no-cache-dir -r requirements.txt
+
+# Copy the project files
+COPY --chown=user:user . .
+
+# Expose the port Gradio will run on
+EXPOSE 7860
+
+# Start the Gradio app
+CMD ["python", "app.py"]

app.py

@@ -0,0 +1,171 @@
+import os
+os.environ['YOLO_CONFIG_DIR'] = '/home/user/.config/Ultralytics'
+from ultralytics import YOLO
+from PIL import Image
+import numpy as np
+import io
+import gradio as gr
+import cv2
+
+# Load the model with the saved weights on CPU
+model = YOLO('best.pt').to('cpu')
+
+def process_webcam(image):
+    # Perform inference
+    results = model.predict(source=image)
+    
+    # Get the annotated image with bounding boxes
+    annotated_image = results[0].plot()
+    
+    # Convert annotated image to PIL Image for Gradio
+    annotated_image_pil = Image.fromarray(annotated_image)
+    
+    # Process results for Gradio display
+    processed_results = []
+    for result in results:
+        boxes = result.boxes.xyxy.tolist()
+        classes = result.boxes.cls.tolist()
+        confs = result.boxes.conf.tolist()
+        
+        for box, cls, conf in zip(boxes, classes, confs):
+            processed_results.append({
+                "box": box,
+                "class": int(cls),
+                "confidence": float(conf)
+            })
+    
+    return annotated_image_pil, processed_results
+
+def process_video(video):
+    cap = cv2.VideoCapture(video)
+    frames = []
+    processed_results = []
+
+    while cap.isOpened():
+        ret, frame = cap.read()
+        if not ret:
+            break
+        
+        # Convert frame to RGB
+        frame_rgb = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
+        
+        # Perform inference
+        results = model.predict(source=frame_rgb)
+        
+        # Get the annotated image with bounding boxes
+        annotated_frame = results[0].plot()
+        
+        # Append the annotated frame to the list
+        frames.append(annotated_frame)
+        
+        # Process results for Gradio display
+        for result in results:
+            boxes = result.boxes.xyxy.tolist()
+            classes = result.boxes.cls.tolist()
+            confs = result.boxes.conf.tolist()
+            
+            for box, cls, conf in zip(boxes, classes, confs):
+                processed_results.append({
+                    "box": box,
+                    "class": int(cls),
+                    "confidence": float(conf)
+                })
+
+    cap.release()
+    
+    # Convert frames to video
+    if frames:
+        height, width, layers = frames[0].shape
+        video_buffer = io.BytesIO()
+        out = cv2.VideoWriter(video_buffer.name, cv2.VideoWriter_fourcc(*'mp4v'), 20.0, (width, height))
+
+        for frame in frames:
+            out.write(cv2.cvtColor(frame, cv2.COLOR_RGB2BGR))
+        
+        out.release()
+        video_buffer.seek(0)
+        return video_buffer, processed_results
+    else:
+        return None, processed_results
+
+def process_image(image):
+    # Perform inference
+    results = model.predict(source=image)
+    
+    # Get the annotated image with bounding boxes
+    annotated_image = results[0].plot()
+    
+    # Convert annotated image to PIL Image for Gradio
+    annotated_image_pil = Image.fromarray(annotated_image)
+    
+    # Process results for Gradio display
+    processed_results = []
+    for result in results:
+        boxes = result.boxes.xyxy.tolist()
+        classes = result.boxes.cls.tolist()
+        confs = result.boxes.conf.tolist()
+        
+        for box, cls, conf in zip(boxes, classes, confs):
+            processed_results.append({
+                "box": box,
+                "class": int(cls),
+                "confidence": float(conf)
+            })
+    
+    return annotated_image_pil, processed_results
+
+# Define the Gradio interface
+with gr.Blocks() as interface:
+    gr.Markdown("# Object Detection with YOLO")
+    
+    with gr.Row():
+        input_type = gr.Radio(["Live Webcam", "Video", "Image"], label="Input Type", value="Image")
+    
+    with gr.Row():
+        with gr.Column():
+            live_webcam = gr.Image(sources="webcam", streaming=True, label="Live Webcam", visible=False)
+            video_input = gr.Video(label="Video Input", visible=False)
+            image_input = gr.Image(type="numpy", label="Image Input")
+        
+        with gr.Column():
+            live_output = gr.Image(label="Live Detection", visible=False)
+            video_output = gr.Video(label="Processed Video", visible=False)
+            image_output = gr.Image(label="Processed Image")
+    
+    json_output = gr.JSON(label="Detection Results")
+    
+    submit_button = gr.Button("Submit", visible=True)
+    
+    def update_input_type(choice):
+        return {
+            live_webcam: gr.update(visible=choice == "Live Webcam"),
+            video_input: gr.update(visible=choice == "Video"),
+            image_input: gr.update(visible=choice == "Image"),
+            live_output: gr.update(visible=choice == "Live Webcam"),
+            video_output: gr.update(visible=choice == "Video"),
+            image_output: gr.update(visible=choice != "Live Webcam"),
+            submit_button: gr.update(visible=choice != "Live Webcam")
+        }
+    
+    input_type.change(update_input_type, input_type, 
+                      [live_webcam, video_input, image_input, 
+                       live_output, video_output, image_output, submit_button])
+    
+    live_webcam.stream(process_webcam, live_webcam, [live_output, json_output])
+    
+    def process_input(input_type, video, image):
+        if input_type == "Video":
+            video_buffer, results = process_video(video)
+            return video_buffer, None, results
+        else:
+            image_pil, results = process_image(image)
+            return None, image_pil, results
+    
+    submit_button.click(
+        process_input,
+        inputs=[input_type, video_input, image_input],
+        outputs=[video_output, image_output, json_output]
+    )
+
+# Launch the Gradio 
+# interface.launch()

best.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:7ffb24fcb2dbfe282d4eda104508becb1d6f73eb69fbff043c34d8dc87918b41
+size 22520803

requirements.txt

@@ -0,0 +1,7 @@
+gradio==4.40.0
+numpy==1.24.4
+opencv_contrib_python==4.7.0.72
+opencv_python==4.7.0.72
+opencv_python_headless==4.8.0.74
+Pillow==10.4.0
+ultralytics==8.2.71