Upload 6 files

.gitattributes

@@ -33,3 +33,4 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+flash_attn-2.7.3+cu11torch2.2cxx11abiFALSE-cp311-cp311-linux_x86_64.whl filter=lfs diff=lfs merge=lfs -text

agent_integration.py

@@ -0,0 +1,66 @@
+from typing import Optional, List
+from langchain.agents import Tool, AgentType, initialize_agent
+from langchain.llms.base import LLM
+
+from firedetection import detect_fire_in_video
+
+# Define a LangChain tool using a decorator or by manually creating a Tool object.
+@Tool(
+    name="FireDetectionTool",
+    description="Detect fire in a given video using YOLO."
+)
+def detect_fire_in_video_tool(video_path: str) -> str:
+    """
+    Takes a video path, calls 'detect_fire_in_video' function,
+    and returns a message indicating the output location.
+    """
+    output_video_path = detect_fire_in_video(
+        input_video_path=video_path,
+        output_video_path="temp_outputs/result.avi",
+        model_path="/Users/bahakizil/Desktop/firedetection/firedetectionyolo/last.pt",  # Adjust if your model file is named differently
+        device="cpu"               # or 'cuda'/'mps' if available
+    )
+    return f"Fire detection completed. Output saved to: {output_video_path}"
+
+
+class SimpleFakeLLM(LLM):
+    """
+    A trivial/fake LLM for demonstration. 
+    It always decides to call 'FireDetectionTool' regardless of the prompt.
+    This replaces the need for external APIs like OpenAI or HuggingFace,
+    while still demonstrating the agent + tool usage in LangChain.
+    """
+
+    @property
+    def _llm_type(self) -> str:
+        return "fake-llm"
+
+    def _call(self, prompt: str, stop: Optional[List[str]] = None) -> str:
+        # Always produce a response suggesting the use of FireDetectionTool:
+        return "I should use FireDetectionTool to process the video."
+
+def create_fire_detection_agent():
+    """
+    Creates a LangChain agent with:
+      - A single tool: FireDetectionTool
+      - A trivial LLM (SimpleFakeLLM)
+    """
+    llm = SimpleFakeLLM()
+    tools = [detect_fire_in_video_tool]
+
+    agent = initialize_agent(
+        tools=tools,
+        llm=llm,
+        agent=AgentType.ZERO_SHOT_REACT_DESCRIPTION,
+        verbose=True
+    )
+    return agent
+
+if __name__ == "__main__":
+    # Example usage:
+    agent = create_fire_detection_agent()
+
+    # Prompt the agent to detect fire in a given video (sample_video.mp4)
+    prompt = "Please detect fire in 'sample_video.mp4'."
+    response = agent.run(prompt)
+    print("\nAgent response:", response)

app.py

@@ -2,41 +2,41 @@ import gradio as gr
 import os
 from firedetection import detect_fire_in_video
 
+# Temporary directory to store results
 TEMP_DIR = "temp_outputs"
 os.makedirs(TEMP_DIR, exist_ok=True)
 
-MODEL_PATH = "/Users/bahakizil/Desktop/firedetection/last.pt"  # Fire detection model .pt dosyası (örnek)
-DEVICE = "cpu"  # İsterseniz 'cpu' veya 'cuda' vb. olarak değiştirebilirsiniz.
-
 def fire_detection_interface(video_file):
-
-    if not video_file:
+    """
+    Gradio interface function that:
+      1) Receives an uploaded video.
+      2) Calls detect_fire_in_video.
+      3) Returns the path of the processed video for display in Gradio.
+    """
+    if video_file is None:
         return None
 
+    # Extract filename
     input_video_path = video_file
-
     base_name = os.path.basename(input_video_path)
     name_no_ext, ext = os.path.splitext(base_name)
-    output_video_path = os.path.join(TEMP_DIR, f"{name_no_ext}_fire_detection{ext}")
+
+    output_path = os.path.join(TEMP_DIR, f"{name_no_ext}_fire{ext}")
 
     processed_path = detect_fire_in_video(
         input_video_path=input_video_path,
-        output_video_path=output_video_path,
-        model_path=MODEL_PATH,
-        device=DEVICE
+        output_video_path=output_path,
+        model_path="yolov12n.pt",
+        device="cpu"
     )
-
     return processed_path
 
-
 demo = gr.Interface(
     fn=fire_detection_interface,
-    inputs=gr.Video(label="Video Yükleyin"),
-    outputs=gr.Video(label="İşlenmiş Video"),
-    title="Fire Detection",
-    description=(
-        
-    ),
+    inputs=gr.Video(label="Upload a Video"),
+    outputs=gr.Video(label="Annotated Video"),
+    title="Fire Detection with YOLO",
+    description="This interface detects fire in an uploaded video using YOLO."
 )
 
 if __name__ == "__main__":

firedetection.py

@@ -1,3 +1,5 @@
+
+
 from collections import defaultdict
 import cv2
 from ultralytics import YOLO
@@ -8,33 +10,38 @@ def detect_fire_in_video(
     output_video_path: str,
     model_path: str,
     device: str = "cpu"
-):
+) -> str:
     """
-    Belirtilen videoda YOLO modelini kullanarak yangın tespiti yapar ve 
-    etiketlenmiş çıktıyı output_video_path'e kaydeder.
-
-    :param input_video_path: Girdi videosunun dosya yolu
-    :param output_video_path: İşlenen (annotate edilmiş) videonun kaydedileceği dosya yolu
-    :param model_path: YOLO model dosyasının (ör. .pt uzantılı) dosya yolu
-    :param device: İşlem için kullanılacak donanım ('cpu', 'cuda', 'mps' vb.)
-    :return: İşlenen video yolunu döndürür.
+    Detects fire in the given video using a YOLO model.
+    It draws annotations on each frame and saves the output video.
+
+    Args:
+        input_video_path (str): Path to the input video file.
+        output_video_path (str): Path to save the annotated output video.
+        model_path (str): Path to the YOLO .pt file.
+        device (str): 'cpu', 'cuda', or 'mps' for processing.
+
+    Returns:
+        str: The path to the output annotated video.
     """
 
-    # Takip geçmişi için defaultdict oluştur
+    # Tracking history - optional usage
     track_history = defaultdict(lambda: [])
 
-    # YOLO modelini yükle
+    # Load the YOLO model
     model = YOLO(model_path, device=device)
 
-    # Video dosyasını aç
+    # Open the video
     cap = cv2.VideoCapture(input_video_path)
 
-    # Video özelliklerini al
-    w, h, fps = (int(cap.get(x)) for x in (cv2.CAP_PROP_FRAME_WIDTH,
-                                           cv2.CAP_PROP_FRAME_HEIGHT,
-                                           cv2.CAP_PROP_FPS))
+    # Retrieve video properties
+    w, h, fps = (int(cap.get(prop)) for prop in [
+        cv2.CAP_PROP_FRAME_WIDTH,
+        cv2.CAP_PROP_FRAME_HEIGHT,
+        cv2.CAP_PROP_FPS
+    ])
 
-    # Çıktı videosu kaydı için VideoWriter ayarla
+    # Prepare output video writer
     out = cv2.VideoWriter(
         output_video_path,
         cv2.VideoWriter_fourcc(*"MJPG"),
@@ -43,18 +50,18 @@ def detect_fire_in_video(
     )
 
     while True:
-        ret, im0 = cap.read()
+        ret, frame = cap.read()
         if not ret:
-            print("Video bitti veya çerçeve okunamadı.")
+            print("Reached end of video or no frame retrieved.")
             break
 
-        # Annotator objesi ile çizim yapma
-        annotator = Annotator(im0, line_width=2)
+        # Create an annotator to draw on the frame
+        annotator = Annotator(frame, line_width=2)
 
-        # model.track ile takip (tracking) sonuçlarını al
-        results = model.track(im0, persist=True)
+        # Perform object tracking
+        results = model.track(frame, persist=True)
 
-        # Track ID'ler ve maskeler varsa işleme al
+        # If there are boxes with IDs and masks, annotate them
         if results[0].boxes.id is not None and results[0].masks is not None:
             masks = results[0].masks.xy
             track_ids = results[0].boxes.id.int().cpu().tolist()
@@ -63,11 +70,11 @@ def detect_fire_in_video(
                 annotator.seg_bbox(
                     mask=mask,
                     mask_color=colors(int(track_id), True),
-                    label=str(track_id)
+                    label=f"ID:{track_id}"
                 )
 
-        # Annotate edilmiş frame'i kaydet
-        out.write(im0)
+        # Write the annotated frame to output
+        out.write(frame)
 
     out.release()
     cap.release()

flash_attn-2.7.3+cu11torch2.2cxx11abiFALSE-cp311-cp311-linux_x86_64.whl

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

requirements.txt

@@ -15,4 +15,7 @@ py-cpuinfo==9.0.0
 huggingface-hub==0.23.2
 safetensors==0.4.3
 numpy==1.26.4
-
+ultralytics==8.0.20
+opencv-python==4.7.0.72
+langchain==0.0.102
+gradio==3.23.0