Add YOLOv8 model weights with LFS tracking

Dockerfile

@@ -1,7 +1,7 @@
 # ------------------------------------------------------------
 # Base image
 # ------------------------------------------------------------
-FROM python:3.12-slim-bookworm
+FROM python:3.12-slim
 
 # ------------------------------------------------------------
 # Environment
@@ -62,4 +62,4 @@ EXPOSE 8000
 # ------------------------------------------------------------
 # Start FastAPI with auto-reload (remove --reload for production)
 # ------------------------------------------------------------
-CMD ["uvicorn", "app:app", "--host", "0.0.0.0", "--port", "7860", "--reload"]
+CMD ["uvicorn", "main:app", "--host", "0.0.0.0", "--port", "7860"]

app.py

@@ -1,100 +0,0 @@
-import os
-import uuid
-import tempfile
-import pandas as pd
-from fastapi import FastAPI, UploadFile, File, HTTPException
-from fastapi.responses import FileResponse
-import uvicorn
-
-from backend.services.video_data_extraction.video_preprocessor import VideoDataExtractor
-from backend.services.prediction.predictor import ViolencePredictor
-
-app = FastAPI(title="Video Analysis Backend")
-
-processor = VideoDataExtractor()
-predictor = ViolencePredictor()
-jobs: dict[str, dict] = {}
-
-
-@app.get("/")
-def greet_json():
-    return {"Hello": "World!"}
-
-
-@app.get("/health")
-async def health_check():
-    return {"status": "ok", "message": "Service is running"}
-
-
-@app.post("/process-video/")
-async def process_video(file: UploadFile = File(...)):
-    try:
-        with tempfile.NamedTemporaryFile(delete=False, suffix=".mp4") as input_video:
-            input_video.write(await file.read())
-            input_path = input_video.name
-
-        output_csv = tempfile.NamedTemporaryFile(delete=False, suffix=".csv").name
-        output_video_path = tempfile.NamedTemporaryFile(
-            delete=False, suffix=".mp4"
-        ).name
-
-        frame_w, frame_h, num_interactions = processor.extract_video_data(
-            input_path,
-            output_csv,
-            output_folder=os.path.dirname(output_video_path),
-            save_video=True,
-        )
-
-        job_id = str(uuid.uuid4())
-        jobs[job_id] = {"csv": output_csv, "video": output_video_path}
-
-        return {
-            "job_id": job_id,
-            "message": f"Processed video with {num_interactions} interactions",
-            "frame_width": frame_w,
-            "frame_height": frame_h,
-        }
-    except Exception as e:
-        raise HTTPException(status_code=500, detail=str(e))
-    finally:
-        if os.path.exists(input_path):
-            os.unlink(input_path)
-
-
-@app.get("/get-results/{job_id}")
-async def get_results(job_id: str):
-    if job_id not in jobs:
-        raise HTTPException(status_code=404, detail="Job ID not found")
-    csv_path = jobs[job_id]["csv"]
-    if not os.path.exists(csv_path):
-        raise HTTPException(status_code=404, detail="CSV file not found")
-    return FileResponse(
-        csv_path, media_type="text/csv", filename="violence_analysis_results.csv"
-    )
-
-
-@app.get("/sample-results/{job_id}")
-async def get_sample_results(job_id: str):
-    if job_id not in jobs:
-        raise HTTPException(status_code=404, detail="Job ID not found")
-    csv_path = jobs[job_id]["csv"]
-    if not os.path.exists(csv_path):
-        raise HTTPException(status_code=404, detail="CSV file not found")
-    df = pd.read_csv(csv_path)
-    return df.head(5).to_dict(orient="records")
-
-
-@app.post("/predict/{job_id}")
-async def predict_violence(job_id: str):
-    if job_id not in jobs:
-        raise HTTPException(status_code=404, detail="Job ID not found")
-    csv_path = jobs[job_id]["csv"]
-    if not os.path.exists(csv_path):
-        raise HTTPException(status_code=404, detail="CSV file not found")
-    df = pd.read_csv(csv_path)
-    preds = predictor.predict(df)
-    return {"predictions": preds.tolist()}
-
-
-if __name__ == "__main__":
-    uvicorn.run(app, host="0.0.0.0", port=7860)

backend/config.py → config.py

@@ -3,6 +3,7 @@ import os
 BASE_DIR = os.path.dirname(os.path.abspath(__file__))
 DETECT_MODEL = os.path.join(BASE_DIR, "models", "yolov8n.pt")
 POSE_MODEL = os.path.join(BASE_DIR, "models", "yolov8n-pose.pt")
+MAIN_MODEL = os.path.join(BASE_DIR, "models", "xgb_model.pkl")
 
 
 # Thresholds and params

{backend/data_extraction → data_extraction}/interaction_analyzer.py

@@ -1,10 +1,10 @@
 import numpy as np
-from backend.utils.motion_utils import (
+from utils.motion_utils import (
     calc_avg_speed,
     calc_motion_intensity,
     calc_sudden_movements,
 )
-from backend.utils.interaction_utils import (
+from utils.interaction_utils import (
     get_box_center,
     euclidean_distance,
     relative_distance,

{backend/data_extraction → data_extraction}/person_tracker.py

@@ -1,6 +1,6 @@
 import numpy as np
-from backend.utils.iou_utils import calculate_iou
-from backend.utils.id_utils import get_new_id
+from utils.iou_utils import calculate_iou
+from utils.id_utils import get_new_id
 
 
 class PersonTracker:

{backend/feature_extraction → feature_extraction}/extractor.py

@@ -1,10 +1,10 @@
 import torch
-from backend.config import DETECT_MODEL, POSE_MODEL, CONF_THRESHOLD
-from backend.utils.gpu import GPUConfigurator
-from backend.preprocessing.preprocessor import FramePreprocessor
-from backend.data_extraction.interaction_analyzer import InteractionAnalyzer
-from backend.data_extraction.person_tracker import PersonTracker
-from backend.utils.visualizer import Visualizer
+from config import DETECT_MODEL, POSE_MODEL, CONF_THRESHOLD
+from utils.gpu import GPUConfigurator
+from preprocessing.preprocessor import FramePreprocessor
+from data_extraction.interaction_analyzer import InteractionAnalyzer
+from data_extraction.person_tracker import PersonTracker
+from utils.visualizer import Visualizer
 import numpy as np
 from ultralytics import YOLO
 

main.py

@@ -0,0 +1,113 @@
+from services.prediction.predictor import ViolencePredictor
+from services.video_data_extraction.video_preprocessor import VideoDataExtractor
+from fastapi import FastAPI, UploadFile, File, Form, HTTPException
+from fastapi.middleware.cors import CORSMiddleware
+from fastapi.responses import JSONResponse
+import numpy as np
+import os
+import logging
+import uuid
+
+# Initialize logging
+logging.basicConfig(
+    level=logging.INFO, format="%(asctime)s - %(name)s - %(levelname)s - %(message)s"
+)
+logger = logging.getLogger("main")
+
+app = FastAPI(title="Violence Prediction System")
+
+# ✅ Enable CORS
+from fastapi.middleware.cors import CORSMiddleware
+
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],  # or ["http://localhost:5173"]
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+UPLOAD_DIR = "temp"
+os.makedirs(UPLOAD_DIR, exist_ok=True)
+# Initialize shared service objects
+try:
+    extractor = VideoDataExtractor()
+    predictor = ViolencePredictor()
+    logger.info("Initialized shared service objects")
+except Exception as e:
+    logger.error(f"Failed to create service objects: {str(e)}")
+    # Create mock objects for testing
+    extractor = None
+    predictor = None
+
+
+def to_python(obj):
+    if isinstance(obj, np.generic):
+        return obj.item()
+    elif isinstance(obj, np.ndarray):
+        return obj.tolist()
+    elif isinstance(obj, dict):
+        return {k: to_python(v) for k, v in obj.items()}
+    elif isinstance(obj, list):
+        return [to_python(i) for i in obj]
+    return obj
+
+
+# Health Check endpoint
+@app.get("/")
+async def health():
+    return {"status": "ok", "message": "Violence Detection API is running"}
+
+
+# Extract video data
+@app.post("/analyze")
+async def extract_data(mode: str = Form(...), file: UploadFile = File(...)):
+    if not extractor or not predictor:
+        raise HTTPException(status_code=500, detail="Service not initialized properly")
+
+    if not file.filename:
+        raise HTTPException(status_code=400, detail="No file provided")
+
+    # Create temp file with proper path
+    tmp_file_code = uuid.uuid4()
+    temp_path = os.path.join(UPLOAD_DIR, f"{tmp_file_code}_{file.filename}")
+
+    try:
+        # Save uploaded file
+        with open(temp_path, "wb") as f:
+            content = await file.read()
+            f.write(content)
+
+        logger.info(f"Processing file: {file.filename}, mode: {mode}")
+
+        # Extract video data
+        data = extractor.extract_video_data(temp_path)
+
+        if mode == "extract":
+            result = {"data": data.to_dict(orient="records")}
+        else:
+            prediction = predictor.predict(data)
+            prediction = to_python(prediction)
+            result = {"prediction": prediction}
+
+        return result
+
+    except Exception as e:
+        logger.error(f"Error processing video: {str(e)}")
+        raise HTTPException(
+            status_code=500, detail=f"Failed to process video: {str(e)}"
+        )
+    finally:
+        # Clean up temp file
+        try:
+            if os.path.exists(temp_path):
+                os.remove(temp_path)
+        except Exception as e:
+            logger.warning(f"Could not remove temp file: {e}")
+
+
+# Run app
+if __name__ == "__main__":
+    import uvicorn
+
+    uvicorn.run(app, host="0.0.0.0", port=8000)

models/xgb_model.pkl

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

requirements.txt

@@ -1,6 +1,7 @@
 fastapi
 uvicorn[standard]
 numpy
+xgboost
 opencv-python
 pandas
 scikit-learn

services/prediction/predictor.py

@@ -0,0 +1,40 @@
+import joblib
+from config import MAIN_MODEL
+import pandas as pd
+
+
+class ViolencePredictor:
+    def __init__(self):
+        self.model = joblib.load(MAIN_MODEL)
+
+    def _preprocess_data_pdict(self, data: pd.DataFrame) -> pd.DataFrame:
+        cols_to_drop = [
+            "video_name",
+            "frame_index",
+            "timestamp",
+            "frame_width",
+            "frame_height",
+            "person1_id",
+            "person2_id",
+            "person1_idx",
+            "person2_idx",
+        ]
+        data = data.drop(columns=cols_to_drop)
+        return data
+
+    def predict(self, data):
+        data = self._preprocess_data_pdict(data)
+        y_pred = self.model.predict(data)
+        print(y_pred)
+
+        return y_pred
+
+
+if __name__ == "__main__":
+    import pandas as pd
+
+    data = pd.read_csv("data/fight_train.csv")
+    data = data[0:20]
+    print("dataloaded")
+    VP = ViolencePredictor()
+    VP.predict(data)

backend/services/prediction/predictor.py → services/preprocessing/preprocessor.py

@@ -1,43 +1,44 @@
 import numpy as np
+import pandas as pd
 from sklearn.preprocessing import MinMaxScaler
 
 
-class ViolencePredictor:
+class DataPreprocessor:
     def __init__(self):
+        # Initialize scaler (use transform() only during inference)
         self.scaler = MinMaxScaler()
 
-    def preprocess_data(self, df):
-        # Normalize coordinates, distances and keypoints
-        # Drop confidence columns
-        # Scale selected columns
-        # Similar as existing code...
+    def preprocess_data(self, df: pd.DataFrame) -> pd.DataFrame:
         """
-        Preprocess the data by normalizing box coordinates, center coordinates, distances, and keypoints.
+        Preprocess the data by normalizing box coordinates, center coordinates,
+        distances, and keypoints.
         """
+        df = df.copy()  # prevent modifying original
+
         # Normalize box coordinates
         frame_height = df["frame_height"]
         frame_width = df["frame_width"]
-        df["box1_x_min"] = df["box1_x_min"] / frame_width
-        df["box1_y_min"] = df["box1_y_min"] / frame_height
-        df["box1_x_max"] = df["box1_x_max"] / frame_width
-        df["box1_y_max"] = df["box1_y_max"] / frame_height
 
-        df["box2_x_min"] = df["box2_x_min"] / frame_width
-        df["box2_y_min"] = df["box2_y_min"] / frame_height
-        df["box2_x_max"] = df["box2_x_max"] / frame_width
-        df["box2_y_max"] = df["box2_y_max"] / frame_height
+        for prefix in ["box1", "box2"]:
+            for coord in ["x_min", "x_max"]:
+                df[f"{prefix}_{coord}"] = df[f"{prefix}_{coord}"] / frame_width
+            for coord in ["y_min", "y_max"]:
+                df[f"{prefix}_{coord}"] = df[f"{prefix}_{coord}"] / frame_height
 
         # Normalize center coordinates
-        df["center1_x"] = df["center1_x"] / frame_width
-        df["center1_y"] = df["center1_y"] / frame_height
-
-        df["center2_x"] = df["center2_x"] / frame_width
-        df["center2_y"] = df["center2_y"] / frame_height
+        for axis in ["x", "y"]:
+            df[f"center1_{axis}"] = df[f"center1_{axis}"] / (
+                frame_width if axis == "x" else frame_height
+            )
+            df[f"center2_{axis}"] = df[f"center2_{axis}"] / (
+                frame_width if axis == "x" else frame_height
+            )
 
         # Normalize distances
         max_distance = np.sqrt(frame_width**2 + frame_height**2)
-        df["distance"] = df["distance"] / max_distance
-        df["relative_distance"] = df["relative_distance"] / max_distance
+        for col in ["distance", "relative_distance"]:
+            if col in df.columns:
+                df[col] = df[col] / max_distance
 
         # Drop confidence columns
         drop_columns = (
@@ -45,31 +46,28 @@ class ViolencePredictor:
             + [f"person2_kp{i}_conf" for i in range(17)]
             + [f"relative_kp{i}_conf" for i in range(17)]
         )
-
-        existing_columns = [col for col in drop_columns if col in df.columns]
-        df = df.drop(columns=existing_columns)
+        df = df.drop(
+            columns=[c for c in drop_columns if c in df.columns], errors="ignore"
+        )
 
         # Normalize keypoints
         for i in range(17):
             for prefix in ["person1_kp", "person2_kp", "relative_kp"]:
-                x_col = f"{prefix}{i}_x"
-                y_col = f"{prefix}{i}_y"
+                if f"{prefix}{i}_x" in df.columns:
+                    df[f"{prefix}{i}_x"] = df[f"{prefix}{i}_x"] / frame_width
+                if f"{prefix}{i}_y" in df.columns:
+                    df[f"{prefix}{i}_y"] = df[f"{prefix}{i}_y"] / frame_height
 
-                if x_col in df.columns:
-                    df[x_col] = df[x_col] / frame_width
-                if y_col in df.columns:
-                    df[y_col] = df[y_col] / frame_height
+        # Scale motion/distance columns
+        for col in [
+            "distance",
+            "relative_distance",
+            "motion_average_speed",
+            "motion_motion_intensity",
+        ]:
+            if col in df.columns:
+                df[col] = self.scaler.fit_transform(
+                    df[[col]]
+                )  # change to transform() in production
 
-        # Scale specific columns
-        df["distance"] = self.scaler.fit_transform(df[["distance"]])
-        df["relative_distance"] = self.scaler.fit_transform(df[["relative_distance"]])
-        df["motion_average_speed"] = self.scaler.fit_transform(
-            df[["motion_average_speed"]]
-        )
-        df["motion_motion_intensity"] = self.scaler.fit_transform(
-            df[["motion_motion_intensity"]]
-        )
         return df
-
-    def predict(self, data):
-        return 0

{backend/services → services}/video_data_extraction/video_preprocessor.py

@@ -2,8 +2,8 @@ import os
 import cv2
 import torch
 import pandas as pd
-from backend.feature_extraction.extractor import VideoFeatureExtractor
-from backend.utils.csv_utils import _create_interaction_row
+from feature_extraction.extractor import VideoFeatureExtractor
+from utils.csv_utils import _create_interaction_row
 
 
 class VideoDataExtractor:
@@ -13,23 +13,23 @@ class VideoDataExtractor:
     def extract_video_data(
         self,
         video_path,
-        output_csv_path,
+        output_csv_path=None,
         output_folder=None,
         show_video=False,
         save_video=False,
     ):
         """
-        Extract data from a video file.
+        Extract interaction data from a video file and return a DataFrame.
 
         Args:
             video_path: Path to input video
-            output_csv_path: Path to save CSV output
-            output_folder: Folder to save output video
+            output_csv_path: Optional path to save CSV output
+            output_folder: Optional folder to save annotated video
             show_video: Whether to display video during processing
             save_video: Whether to save output video
 
         Returns:
-            Tuple of (frame_width, frame_height, num_interactions)
+            pandas.DataFrame containing extracted interactions
         """
         cap = None
         video_writer = None
@@ -51,16 +51,13 @@ class VideoDataExtractor:
 
             video_name = os.path.splitext(os.path.basename(video_path))[0]
 
-            # Set frame skip based on resolution
+            # Configure resolution-based settings
             batch_size, frame_skip = self.extractor.preprocessor.set_resolution_config(
                 frame_width, frame_height
             )
             self.extractor.preprocessor.frame_skip = frame_skip
 
-            print(f"Processing video: {frame_width}x{frame_height} at {fps} fps")
-            print(f"Using frame_skip: {frame_skip}")
-
-            # Initialize video writer if needed
+            # Initialize video writer if required
             if output_folder and save_video:
                 os.makedirs(output_folder, exist_ok=True)
                 output_video_path = os.path.join(
@@ -73,7 +70,7 @@ class VideoDataExtractor:
                     (frame_width, frame_height),
                 )
 
-            # Reset extractor for new video
+            # Reset extractor for a fresh start
             self.extractor.reset()
 
             # Process frames
@@ -83,13 +80,11 @@ class VideoDataExtractor:
                 if not ret:
                     break
 
-                # Extract features
                 frame_data, annotated_frame = self.extractor.extract_features(
                     frame, frame_idx
                 )
 
                 if frame_data is not None:
-                    # Process interactions
                     for interaction in frame_data["interactions"]:
                         interaction_id = (
                             interaction["person1_id"],
@@ -108,34 +103,30 @@ class VideoDataExtractor:
                             )
                             csv_data.append(row)
 
-                    # Write frame to output video
                     if video_writer is not None and annotated_frame is not None:
                         video_writer.write(annotated_frame)
 
-                    # Show video if enabled
                     if show_video and annotated_frame is not None:
                         cv2.imshow("Video Data Extraction", annotated_frame)
-                        key = cv2.waitKey(1) & 0xFF
-                        if key == ord("q"):
+                        if cv2.waitKey(1) & 0xFF == ord("q"):
                             break
 
-                # Clear memory periodically
                 if frame_idx % 100 == 0:
                     torch.cuda.empty_cache()
 
+            # ✅ Return only the DataFrame
             if csv_data:
                 df = pd.DataFrame(csv_data)
-
-                if os.path.exists(output_csv_path):
-                    # Append to existing CSV
-                    df.to_csv(output_csv_path, mode="a", header=False, index=False)
-                    print(f"Appended {len(csv_data)} interactions to {output_csv_path}")
-                else:
-                    # Save new CSV
-                    df.to_csv(output_csv_path, index=False)
-                    print(f"Saved {len(csv_data)} interactions to {output_csv_path}")
-
-            return frame_width, frame_height, len(csv_data)
+                if output_csv_path:
+                    df.to_csv(
+                        output_csv_path,
+                        mode="a" if os.path.exists(output_csv_path) else "w",
+                        header=not os.path.exists(output_csv_path),
+                        index=False,
+                    )
+                return df
+            else:
+                return pd.DataFrame()  # empty DataFrame if nothing found
 
         finally:
             if cap is not None: