Upload 8 files

README.md

@@ -1,14 +1,60 @@
----
-title: Gun Detection Agent
-emoji: 👁
-colorFrom: green
-colorTo: yellow
-sdk: gradio
-sdk_version: 5.17.0
-app_file: app.py
-pinned: false
-license: mit
-short_description: YOLO object detection model into a LangChain tool
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# Gun Detection Agent
+
+This project integrates a YOLO object detection model into a LangChain tool. It allows you to process videos (either file-based or real-time), detect objects, and generate both image and text outputs.
+
+## 📌 Features
+- Detects objects using YOLO (class IDs: 0-5)
+- Draws **red bounding boxes** and labels (e.g. "Handgun", "Knife")
+- Saves detected frames as images in the `detections` directory
+- Logs detection results in `detections/detections.txt`
+- Can be used as a **LangChain Tool** for easy integration into other projects
+
+## 🚀 Installation
+### 1️⃣ Install dependencies:
+```bash
+pip install -r requirements.txt
+```
+### 2️⃣ Set up the project:
+```bash
+git clone https://github.com/your-repository/langchain-yolo-agent.git
+cd langchain-yolo-agent
+```
+### 3️⃣ Run the detection script:
+```bash
+python langchain_yolo_agent.py
+```
+
+## 🔧 Usage
+### As a Standalone Script
+```python
+from langchain_yolo_agent import video_detection_tool
+
+response = video_detection_tool("path/to/video.mp4")
+print(response)
+```
+### As a LangChain Tool
+```python
+from langchain.agents import initialize_agent, AgentType
+from langchain.llms import OpenAI
+from langchain_yolo_agent import video_detection_tool
+
+llm = OpenAI(temperature=0)
+tools = [video_detection_tool]
+
+agent = initialize_agent(tools, llm, agent=AgentType.ZERO_SHOT_REACT_DESCRIPTION, verbose=True)
+
+user_input = "Analyze the objects in the video: path/to/video.mp4"
+response = agent.run(user_input)
+print(response)
+```
+
+## 📂 Output Files
+- **Detected frames**: Saved in `detections/` (e.g., `detections/frame_1240.jpg`)
+- **Detection log**: `detections/detections.txt` (text-based log of detected objects)
+
+## 🔥 Future Improvements
+- Add support for real-time video detection
+- Deploy as an API for remote processing
+
+## 📝 License
+This project is open-source and available under the MIT license.

__init__.py

@@ -0,0 +1,3 @@
+from .yolo_agent import video_detection_tool
+
+__all__ = ["video_detection_tool"]

app.py

@@ -0,0 +1,36 @@
+import gradio as gr
+from yolo_agent import video_detection_tool
+import os
+import time
+
+def detect_objects(video):
+    """Handles video upload and runs YOLO detection, displaying detections in real-time."""
+    result = video_detection_tool.invoke(video, conf=0.8)  # Explicitly setting confidence threshold
+    detected_images = "detections"  # Folder where detected images are stored
+
+    
+    image_paths = []
+    if os.path.exists(detected_images):
+        for _ in range(20):  # Limit the loop to avoid infinite execution
+            new_images = sorted(
+                [os.path.join(detected_images, img) for img in os.listdir(detected_images) if img.endswith(".jpg")],
+                key=os.path.getmtime  # Sort images by modification time for real-time order
+            )
+            if new_images != image_paths:
+                image_paths = new_images
+                yield result, image_paths
+            time.sleep(1)  # Update images in real-time
+    
+    return result, []
+
+# Gradio Interface
+demo = gr.Blocks()
+with demo:
+    gr.Markdown("# 🎥 YOLO Object Detection with LangChain - Real-time Display")
+    video_input = gr.File(label="📤 Upload a Video", type="filepath")
+    output_text = gr.Textbox(label="📄 Detection Results")
+    output_gallery = gr.Gallery(label="📸 Detected Objects", show_label=True, interactive=False, columns=4)
+    detect_button = gr.Button("🚀 Run Detection")
+    detect_button.click(fn=detect_objects, inputs=video_input, outputs=[output_text, output_gallery])  # Removed `live=True`
+
+demo.launch(share=True)

fix_plan.md

@@ -0,0 +1,26 @@
+# Proje Düzeltme Planı
+
+## 1. Model Yolu Güncellemesi
+- `yolo_agent.py` dosyasındaki `MODEL_PATH` değişkenini güncelleyerek "last.pt" dosyasını kullanacak şekilde ayarlayacağım:
+```python
+MODEL_PATH = os.path.join(os.path.dirname(__file__), "last.pt")
+```
+
+## 2. Test Videosu Ekleme
+- Projeye örnek bir test videosu ekleyeceğim. Bu video `test_videos` dizinine eklenecek ve README.md'de belirtilecek.
+
+## 3. LangChain Entegrasyonu Testi
+- LangChain entegrasyonunu test etmek için `test_langchain.py` adında yeni bir dosya oluşturacağım. Bu dosya README.md'de belirtilen örnek kullanımı içerecek.
+
+## 4. README.md Güncellemesi
+- README.md dosyasını güncelleyerek hem Gradio arayüzü hem de LangChain aracı kullanımını açıkça belirteceğim.
+- Yeni test videosu ve LangChain test scripti hakkında bilgi ekleyeceğim.
+
+## Uygulama Adımları
+1. Model yolunu güncelle
+2. Test videosu ekle
+3. LangChain test scripti oluştur
+4. README.md'yi güncelle
+5. Tüm değişiklikleri test et
+
+Bu planı onaylarsanız Code moduna geçerek uygulamaya başlayabilirim.

last.pt

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

requirements.txt

@@ -0,0 +1,6 @@
+langchain
+openai
+ultralytics
+opencv-python
+opencv-contrib-python
+gradio

setup.py

@@ -0,0 +1,18 @@
+from setuptools import setup, find_packages
+
+setup(
+    name="yolo_agent",
+    version="1.0",
+    packages=find_packages(),
+    install_requires=[
+        "langchain",
+        "openai",
+        "ultralytics",
+        "opencv-python",
+        "opencv-contrib-python"
+    ],
+    include_package_data=True,
+    package_data={
+        "": ["best.pt"]  # Ensure the YOLO model file is included in the package
+    },
+)

yolo_agent.py

@@ -0,0 +1,153 @@
+"""
+LangChain YOLO Agent
+---------------------
+
+This project provides a YOLO-based object detection tool integrated with LangChain.
+Users can upload any video to analyze its contents, generate object detection logs,
+and visualize detections with bounding boxes.
+
+Steps:
+1) Install dependencies: `pip install langchain openai ultralytics opencv-python`
+2) Add this file (`yolo_agent.py`) to your project.
+3) Ensure that the YOLO model file (`last.pt`) is available in the working directory.
+4) Use the provided functions to analyze uploaded videos dynamically.
+"""
+
+import os
+import cv2
+import shutil
+from langchain.agents import Tool, tool
+from ultralytics import YOLO
+
+UPLOAD_FOLDER = "uploads"
+os.makedirs(UPLOAD_FOLDER, exist_ok=True)
+# Update the model path to point to the "yolo" directory
+MODEL_PATH = os.path.join(os.path.dirname(__file__), "last.pt")
+
+
+def detect_with_yolo(
+    video_path: str,
+    model_path: str = os.path.join(os.path.dirname(__file__), "last.pt"),
+    output_dir: str = "detections",
+    frame_skip: int = 10,
+    conf: float = 0.7
+) -> str:
+    """
+    Runs YOLO detection on the given video.
+    - Detects only class_id 0..5 (Danger / Handgun / Knife, etc.)
+    - Draws red bounding boxes
+    - Saves logs to a text file
+    - Saves detected frames as images
+    """
+
+    if not os.path.exists(video_path):
+        return f"Video not found: {video_path}"
+
+    try:
+        model = YOLO(model_path)
+    except Exception as e:
+        return f"Failed to load model: {e}"
+
+    cap = cv2.VideoCapture(video_path)
+    if not cap.isOpened():
+        return f"Cannot open video: {video_path}"
+
+    os.makedirs(output_dir, exist_ok=True)
+    output_txt = os.path.join(output_dir, "detections.txt")
+    frame_count = 0
+
+    with open(output_txt, "w") as ftxt:
+        while cap.isOpened():
+            ret, frame = cap.read()
+            if not ret:
+                break
+
+            results = model(frame, conf=0.8)
+            detections = (
+                results[0].boxes.data.cpu().numpy() if len(results) > 0 else []
+            )
+
+            valid_detections = [det for det in detections if int(det[5]) in [0, 1, 2, 3, 4, 5]]
+
+            if len(valid_detections) > 0:
+                for det in valid_detections:
+                    x1, y1, x2, y2, conf, cls_ = det
+                    class_id = int(cls_)
+
+                    if class_id in [0, 1, 2]:
+                        class_label = "Danger"
+                    elif class_id in [3, 4, 5]:
+                        class_label = model.names.get(class_id, f"Class {class_id}")
+                    else:
+                        class_label = f"Class {class_id}"
+
+                    cv2.rectangle(
+                        frame,
+                        (int(x1), int(y1)),
+                        (int(x2), int(y2)),
+                        (0, 0, 255),
+                        3,
+                    )
+
+                    (w, h), _ = cv2.getTextSize(class_label, cv2.FONT_HERSHEY_COMPLEX, 0.8, 2)
+                    label_x1 = int(x1)
+                    label_y2 = int(y1)
+                    label_y1 = label_y2 - h - 10
+                    label_x2 = label_x1 + w + 10
+
+                    cv2.rectangle(
+                        frame,
+                        (label_x1, label_y1),
+                        (label_x2, label_y2),
+                        (0, 0, 255),
+                        cv2.FILLED,
+                    )
+
+                    cv2.putText(
+                        frame,
+                        class_label,
+                        (label_x1 + 5, label_y1 + h + 5),
+                        cv2.FONT_HERSHEY_COMPLEX,
+                        0.85,
+                        (255, 255, 255),
+                        2,
+                        cv2.LINE_AA,
+                    )
+
+                    ftxt.write(
+                        f"Frame {frame_count}: {class_label} at ({int(x1)}, {int(y1)}, {int(x2)}, {int(y2)})\n"
+                    )
+
+                output_frame_path = os.path.join(output_dir, f"frame_{frame_count}.jpg")
+                cv2.imwrite(output_frame_path, frame)
+
+            frame_count += frame_skip
+            cap.set(cv2.CAP_PROP_POS_FRAMES, frame_count)
+
+    cap.release()
+    cv2.destroyAllWindows()
+
+    return f"Processing complete. Outputs saved in '{output_dir}' and '{output_txt}'."
+
+@tool("video_detection_tool", return_direct=True)
+def video_detection_tool(video) -> str:
+    """
+    Handles video uploads dynamically and runs YOLO detection.
+    Saves results in the "detections" folder and logs to detections.txt.
+    """
+    video_path = os.path.join(UPLOAD_FOLDER, os.path.basename(video.name))
+    # Update the model path used here too
+    MODEL_PATH = os.path.join(os.path.dirname(__file__), "last.pt")
+
+    shutil.copy(video.name, video_path)
+    try:
+        result = detect_with_yolo(video_path)
+    except Exception as e:
+        return f"Error during detection: {e}"
+
+    return result
+
+if __name__ == "__main__":
+    print("LangChain YOLO Agent Ready!")
+
+__all__ = ["video_detection_tool"]