Upload 9 files

Fight_detec_func.py

@@ -0,0 +1,103 @@
+import tensorflow as tf
+from frame_slicer import extract_video_frames
+import cv2
+import os
+import numpy as np
+import matplotlib.pyplot as plt
+
+# Configuration
+import os
+MODEL_PATH = os.path.join(os.path.dirname(__file__), "trainnig_output", "final_model_2.h5")
+N_FRAMES = 30
+IMG_SIZE = (96, 96)
+RESULT_PATH = os.path.join(os.path.dirname(__file__), "results")  # Will be created if doesn't exist
+
+def fight_detec(video_path: str, debug: bool = True):
+    """Detects fight in a video and returns the result and confidence score."""
+    
+    class FightDetector:
+        def __init__(self):
+            self.model = self._load_model()
+        
+        def _load_model(self):
+            try:
+                model = tf.keras.models.load_model(MODEL_PATH, compile=False)
+                if debug:
+                    print("\nModel loaded successfully. Input shape:", model.input_shape)
+                return model
+            except Exception as e:
+                print(f"Model loading failed: {e}")
+                return None
+        
+        def _extract_frames(self, video_path):
+            frames = extract_video_frames(video_path, N_FRAMES, IMG_SIZE)
+            if frames is None:
+                return None
+            
+            if debug:
+                blank_frames = np.all(frames == 0, axis=(1, 2, 3)).sum()
+                if blank_frames > 0:
+                    print(f"Warning: {blank_frames} blank frames detected")
+                sample_frame = (frames[0] * 255).astype(np.uint8)
+                os.makedirs(RESULT_PATH, exist_ok=True)
+                cv2.imwrite(os.path.join(RESULT_PATH, 'debug_frame.jpg'), 
+                            cv2.cvtColor(sample_frame, cv2.COLOR_RGB2BGR))
+            
+            return frames
+        
+        def predict(self, video_path):
+            if not os.path.exists(video_path):
+                return "Error: Video not found", None
+            
+            try:
+                frames = self._extract_frames(video_path)
+                if frames is None:
+                    return "Error: Frame extraction failed", None
+                
+                if frames.shape[0] != N_FRAMES:
+                    return f"Error: Expected {N_FRAMES} frames, got {frames.shape[0]}", None
+                
+                if np.all(frames == 0):
+                    return "Error: All frames are blank", None
+                
+                prediction = self.model.predict(frames[np.newaxis, ...], verbose=0)[0][0]
+                result = "FIGHT" if prediction >= 0.61 else "NORMAL"
+                confidence = min(max(abs(prediction - 0.61) * 150 + 50, 0), 100)
+                
+                if debug:
+                    self._debug_visualization(frames, prediction, result, video_path)
+                
+                return f"{result} ({confidence:.1f}% confidence)", prediction
+            
+            except Exception as e:
+                return f"Prediction error: {str(e)}", None
+
+        def _debug_visualization(self, frames, score, result, video_path):
+            print(f"\nPrediction Score: {score:.4f}")
+            print(f"Decision: {result}")
+            plt.figure(figsize=(15, 5))
+            for i in range(min(10, len(frames))):
+                plt.subplot(2, 5, i+1)
+                plt.imshow(frames[i])
+                plt.title(f"Frame {i}\nMean: {frames[i].mean():.2f}")
+                plt.axis('off')
+            plt.suptitle(f"Prediction: {result} (Score: {score:.4f})")
+            plt.tight_layout()
+
+            # Save the visualization
+            base_name = os.path.splitext(os.path.basename(video_path))[0]
+            save_path = os.path.join(RESULT_PATH, f"{base_name}_prediction_result.png")
+            plt.savefig(save_path)
+            plt.close()
+            print(f"Visualization saved to: {save_path}")
+
+    detector = FightDetector()
+    if detector.model is None:
+        return "Error: Model loading failed", None
+    return detector.predict(video_path)
+
+# # Entry point
+# path0 = input("Enter the local path to the video file to detect fight: ")
+# path = path0.strip('"')  # Remove extra quotes if copied from Windows
+# print(f"[INFO] Loading video: {path}")
+# fight_detec(path)

README.md

@@ -1,12 +1,187 @@
----
-title: Fight-object Detection
-emoji: 💻
-colorFrom: green
-colorTo: blue
-sdk: gradio
-sdk_version: 5.25.2
-app_file: app.py
-pinned: false
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# Video Analysis Project: Fight and Object Detection
+
+## 1. Overview
+
+This project analyzes video files to perform two main tasks:
+*   **Fight Detection:** Classifies video segments as containing a "FIGHT" or being "NORMAL" using a custom-trained 3D Convolutional Neural Network (CNN).
+*   **Object Detection:** Identifies and tracks specific objects within the video using a pre-trained YOLOv8 model.
+
+The system processes an input video and outputs the fight classification result along with an annotated version of the video highlighting detected objects.
+
+## 2. Features
+
+*   Dual analysis: Combines action recognition (fight detection) and object detection.
+*   Custom-trained model for fight detection tailored to specific data.
+*   Utilizes state-of-the-art YOLOv8 for object detection.
+*   Generates an annotated output video showing detected objects and their tracks.
+*   Provides confidence scores for fight detection results.
+*   Includes scripts for both inference (`full_project.py`) and training (`trainig.py`) the fight detection model.
+
+## 3. Project Structure
+
+```
+ComV/
+├── [Project Directory]/        # e.g., AI_made
+│   ├── full_project.py         # Main script for running inference
+│   ├── Fight_detec_func.py     # Fight detection logic and model loading
+│   ├── objec_detect_yolo.py    # Object detection logic using YOLOv8
+│   ├── frame_slicer.py         # Utility for extracting frames for fight detection
+│   ├── trainig.py              # Script for training the fight detection model
+│   ├── README.md               # This documentation file
+│   └── trainnig_output/        # Directory for training artifacts
+│       ├── final_model_2.h5    # Trained fight detection model (relative path)
+│       └── checkpoint/         # Checkpoints saved during training (relative path)
+│       └── training_log.csv    # Log file for training history (relative path)
+│   └── yolo/                   # (Assumed location)
+│       └── yolo/
+│           └── best.pt         # Pre-trained YOLOv8 model weights (relative path)
+├── train/
+│   ├── Fighting/               # Directory containing fight video examples (relative path)
+│   └── Normal/                 # Directory containing normal video examples (relative path)
+└── try/
+    ├── result/                 # Directory where output videos are saved (relative path)
+    └── ... (Input video files) # Location for input videos (example)
+```
+
+*(Note: Model paths and data directories might be hardcoded in the scripts. Consider making these configurable or using relative paths.)*
+
+## 4. Setup and Installation
+
+**Python Version:**
+
+*   This project was developed and tested using Python 3.10.
+
+**Dependencies:**
+
+Based on the code imports and `pip freeze` output, the following libraries and versions were used:
+
+*   `opencv-python==4.11.0.86` (cv2)
+*   `numpy==1.26.4`
+*   `tensorflow==2.19.0` (tf)
+*   `ultralytics==8.3.108` (for YOLOv8)
+*   `matplotlib==3.10.1` (for debug visualizations)
+*   `scikit-learn==1.6.1` (sklearn - used in `trainig.py`)
+
+*(Note: Other versions might also work, but these are the ones confirmed in the development environment.)*
+
+**Installation (using pip):**
+
+```bash
+pip install opencv-python numpy tensorflow ultralytics matplotlib scikit-learn
+```
+
+**Models:**
+
+1.  **Fight Detection Model:** Ensure the trained model (`final_model_2.h5`) is present in the `trainnig_output` subdirectory relative to the script location.
+2.  **YOLOv8 Model:** Ensure the YOLO model (`best.pt`) is present in the `yolo/yolo` subdirectory relative to the script location.
+
+*(Note: Absolute paths might be hardcoded in the scripts and may need adjustment depending on the deployment environment.)*
+
+## 5. Usage
+
+To run the analysis on a video file:
+
+1.  Navigate to the `d:/K_REPO/ComV/AI_made/` directory in your terminal (or ensure Python's working directory is `d:/K_REPO`).
+2.  Run the main script:
+    ```bash
+    python full_project.py
+    ```
+3.  The script will prompt you to enter the path to the video file:
+    ```
+    Enter the local path : <your_video_path.mp4>
+    ```
+    *(Ensure you provide the full path, potentially removing extra quotes if copying from Windows Explorer.)*
+
+**Output:**
+
+*   The console will print the fight detection result (e.g., "FIGHT (85.3% confidence)") and information about the object detection process.
+*   An annotated video file will be saved in the `D:\K_REPO\ComV\try\result` directory. The filename will include the original video name and the unique detected object labels (e.g., `input_video_label1_label2_output.mp4`).
+*   If debug mode is enabled in `Fight_detec_func.py`, additional debug images might be saved in the result directory.
+
+## 6. Module Descriptions
+
+*   **`full_project.py`:** Orchestrates the process by taking user input and calling the fight detection and object detection functions.
+*   **`Fight_detec_func.py`:**
+    *   Contains the `fight_detec` function and `FightDetector` class.
+    *   Loads the Keras model (`final_model_2.h5`).
+    *   Uses `frame_slicer` to prepare input for the model.
+    *   Performs prediction and calculates confidence.
+    *   Handles debug visualizations.
+*   **`objec_detect_yolo.py`:**
+    *   Contains the `detection` function.
+    *   Loads the YOLOv8 model (`best.pt`).
+    *   Iterates through video frames, performs object detection and tracking.
+    *   Generates and saves the annotated output video.
+    *   Returns detected object labels.
+*   **`frame_slicer.py`:**
+    *   Contains the `extract_video_frames` utility function.
+    *   Extracts a fixed number of frames, resizes, normalizes, and handles potential errors during extraction.
+*   **`trainig.py`:**
+    *   Script for training the fight detection model.
+    *   Includes `VideoDataGenerator` for loading/processing video data.
+    *   Defines the 3D CNN model architecture.
+    *   Handles data loading, splitting, training loops, checkpointing, and saving the final model.
+
+## 7. Training Data
+
+### Dataset Composition
+| Category       | Count | Percentage | Formats       | Avg Duration |
+|----------------|-------|------------|---------------|--------------|
+| Fight Videos   | 2,340 | 61.9%      | .mp4, .mpeg   | 5.2 sec      |
+| Normal Videos  | 1,441 | 38.1%      | .mp4, .mpeg   | 6.1 sec      |
+| **Total**      | **3,781** | **100%**  |               |              |
+
+### Technical Specifications
+- **Resolution:** 64×64 pixels
+- **Color Space:** RGB
+- **Frame Rate:** 30 FPS (average)
+- **Frame Sampling:** 50 frames per video
+- **Input Shape:** (30, 96, 96, 3) - Model resizes input
+
+### Data Sources
+- Fighting videos: Collected from public surveillance datasets
+- Normal videos: Sampled from public CCTV footage
+- Manually verified and labeled by domain experts
+
+### Preprocessing
+1. Frame extraction at 50 frames/video
+2. Resizing to 96×96 pixels
+3. Normalization (pixel values [0,1])
+4. Temporal sampling to 30 frames for model input
+
+## 8. Models Used
+
+*   **Fight Detection:** A custom 3D CNN trained using `trainig.py`. Located at `D:\K_REPO\ComV\AI_made\trainnig_output\final_model_2.h5`. Input shape expects `(30, 96, 96, 3)` frames.
+*   **Object Detection:** YOLOv8 model. Weights located at `D:\K_REPO\ComV\yolo\yolo\best.pt`. This model is trained to detect the following classes: `['Fire', 'Gun', 'License_Plate', 'Smoke', 'knife']`.
+
+## 7a. Fight Detection Model Performance
+
+The following metrics represent the performance achieved during the training of the `final_model_2.h5`:
+
+*   **Best Training Accuracy:** 0.8583 (Epoch 7)
+*   **Best Validation Accuracy:** 0.9167 (Epoch 10)
+*   **Lowest Training Loss:** 0.3636 (Epoch 7)
+*   **Lowest Validation Loss:** 0.2805 (Epoch 8)
+
+*(Note: These metrics are based on the training run that produced the saved model. Performance may vary slightly on different datasets or during retraining.)*
+
+## 8. Configuration
+
+Key parameters and paths are mostly hardcoded within the scripts:
+
+*   `Fight_detec_func.py`: `MODEL_PATH`, `N_FRAMES`, `IMG_SIZE`, `RESULT_PATH`.
+*   `objec_detect_yolo.py`: YOLO model path, output directory path (`output_dir`), confidence threshold (`conf=0.7`).
+*   `trainig.py`: `DATA_DIR`, `N_FRAMES`, `IMG_SIZE`, `EPOCHS`, `BATCH_SIZE`, `CHECKPOINT_DIR`, `OUTPUT_PATH`.
+
+*Recommendation: Refactor these hardcoded values into a separate configuration file (e.g., YAML or JSON) or use command-line arguments for better flexibility.*
+
+## 9. Training the Fight Detection Model
+
+To retrain or train the fight detection model:
+
+1.  **Prepare Data:** Place training videos into `D:\K_REPO\ComV\train\Fighting` and `D:\K_REPO\ComV\train\Normal` subdirectories.
+2.  **Run Training Script:** Execute `trainig.py`:
+    ```bash
+    python trainig.py
+    ```
+3.  The script will load data, build the model (or resume from a checkpoint if `RESUME_TRAINING=1` and a checkpoint exists), train it, and save the final model to `D:\K_REPO\ComV\AI_made\trainnig_output\final_model_2.h5`. Checkpoints and logs are saved in the `trainnig_output` directory.

app.py

@@ -0,0 +1,35 @@
+import gradio as gr
+import os
+import tempfile
+from Fight_detec_func import fight_detec
+from objec_detect_yolo import detection
+
+def analyze_video(video_file):
+    # Save uploaded file to temp location
+    temp_dir = tempfile.mkdtemp()
+    video_path = os.path.join(temp_dir, video_file.name)
+    with open(video_path, 'wb') as f:
+        f.write(video_file.read())
+    
+    # Run both detection functions
+    fight_result = fight_detec(video_path, debug=False)
+    yolo_result = detection(video_path)
+    
+    # Clean up
+    os.remove(video_path)
+    os.rmdir(temp_dir)
+    
+    return {
+        "Fight Detection": fight_result[0],
+        "YOLO Object Detection": yolo_result
+    }
+
+iface = gr.Interface(
+    fn=analyze_video,
+    inputs=gr.Video(label="Upload Video"),
+    outputs=gr.JSON(label="Detection Results"),
+    title="Fight and Object Detection System",
+    description="Upload a video to detect fights and objects using our AI models"
+)
+
+iface.launch()

frame_slicer.py

@@ -0,0 +1,58 @@
+import cv2
+import numpy as np
+import random
+
+def extract_video_frames(video_path, n_frames=30, frame_size=(96, 96)):
+    """
+    Simplified robust frame extractor for short videos (2-10 sec)
+    - Automatically handles varying video lengths
+    - Ensures consistent output shape
+    - Optimized for MP4/MPEG
+    """
+    # Open video
+    cap = cv2.VideoCapture(video_path)
+    if not cap.isOpened():
+        print(f"Error: Could not open video {video_path}")
+        return None
+    
+    total_frames = int(cap.get(cv2.CAP_PROP_FRAME_COUNT))
+    fps = cap.get(cv2.CAP_PROP_FPS)
+    
+    # Basic video validation
+    if total_frames < 1 or fps < 1:
+        print(f"Error: Invalid video (frames:{total_frames}, fps:{fps})")
+        cap.release()
+        return None
+    
+    # Calculate how many frames to skip (adaptive based on video length)
+    video_length = total_frames / fps
+    frame_step = max(1, int(total_frames / n_frames))
+    
+    frames = []
+    last_good_frame = None
+    
+    for i in range(n_frames):
+        # Calculate position to read (spread evenly across video)
+        pos = min(int(i * (total_frames / n_frames)), total_frames - 1)
+        cap.set(cv2.CAP_PROP_POS_FRAMES, pos)
+        
+        ret, frame = cap.read()
+        
+        # Fallback strategies if read fails
+        if not ret or frame is None:
+            if last_good_frame is not None:
+                frame = last_good_frame.copy()
+            else:
+                # Generate placeholder frame (light gray)
+                frame = np.full((*frame_size[::-1], 3), 0.8, dtype=np.float32)
+        else:
+            # Process valid frame
+            frame = cv2.resize(frame, frame_size)
+            frame = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
+            frame = frame.astype(np.float32) / 255.0
+            last_good_frame = frame
+        
+        frames.append(frame)
+    
+    cap.release()
+    return np.array(frames)

full_project.py

@@ -0,0 +1,22 @@
+import cv2
+import numpy as np
+import os
+from ultralytics import YOLO
+import time
+import tensorflow as tf
+from frame_slicer import extract_video_frames
+import matplotlib.pyplot as plt
+
+from Fight_detec_func import fight_detec
+from objec_detect_yolo import detection
+
+
+
+# Entry point
+path0 = input("Enter the local path : ")
+path = path0.strip('"')  # Remove extra quotes if copied from Windows
+print(f"[INFO] Loading video: {path}")
+
+fight_detec(path)
+detection(path)
+

model_summary.py

@@ -0,0 +1,10 @@
+from tensorflow.keras.models import load_model
+
+model = load_model(r"D:\K_REPO\ComV\AI_made\trainnig_output\final_model_2.h5")
+model.summary()
+
+
+
+from tensorflow.python.client import device_lib
+print("[INFO] Devices available:")
+print(device_lib.list_local_devices())

objec_detect_yolo.py

@@ -0,0 +1,121 @@
+import cv2
+import numpy as np
+import os
+from ultralytics import YOLO
+import time
+from typing import Tuple, Set
+
+def detection(path: str) -> Tuple[Set[str], str]:
+    """
+    Detects and tracks objects in a video using YOLOv8 model, saving an annotated output video.
+    
+    Args:
+        path (str): Path to the input video file. Supports common video formats (mp4, avi, etc.)
+        
+    Returns:
+        Tuple[Set[str], str]: 
+            - Set of unique detected object labels (e.g., {'Gun', 'Knife'})
+            - Path to the output annotated video with detection boxes and tracking IDs
+            
+    Raises:
+        FileNotFoundError: If input video doesn't exist
+        ValueError: If video cannot be opened/processed
+    """
+
+    # Validate input file exists
+    if not os.path.exists(path):
+        raise FileNotFoundError(f"Video file not found: {path}")
+
+    # Initialize YOLOv8 model with pretrained weights
+    # Model is trained to detect: ['Fire', 'Gun', 'License_Plate', 'Smoke', 'knife']
+    model = YOLO(os.path.join(os.path.dirname(__file__), "yolo", "best.pt"))
+    class_names = model.names  # Get class label mappings
+
+    # Set up output paths:
+    # 1. Temporary output during processing
+    # 2. Final output with detected objects in filename
+    input_video_name = os.path.basename(path)
+    base_name = os.path.splitext(input_video_name)[0]
+    temp_output_name = f"{base_name}_output_temp.mp4"
+    output_dir = "results"
+    os.makedirs(output_dir, exist_ok=True)  # Create output dir if needed
+    if not os.path.exists(output_dir):
+        raise ValueError(f"Failed to create output directory: {output_dir}")
+    temp_output_path = os.path.join(output_dir, temp_output_name)
+
+    # Video processing setup:
+    # - Open input video stream
+    # - Initialize output writer with MP4 codec
+    cap = cv2.VideoCapture(path)
+    if not cap.isOpened():
+        raise ValueError(f"Failed to open video file: {path}")
+
+    # Process all frames at 640x640 resolution for consistency
+    frame_width, frame_height = 640, 640
+    out = cv2.VideoWriter(
+        temp_output_path, 
+        cv2.VideoWriter_fourcc(*'mp4v'),  # MP4 codec
+        30.0,  # Output FPS
+        (frame_width, frame_height)
+    )
+
+    # Main processing loop:
+    # 1. Read each frame
+    # 2. Run object detection + tracking
+    # 3. Annotate frame with boxes and IDs
+    # 4. Collect detected classes
+    crimes = []  # Track all detected objects
+    start = time.time()
+    print(f"[INFO] Processing started at {start:.2f} seconds")
+
+    while True:
+        ret, frame = cap.read()
+        if not ret:  # End of video
+            break
+
+        # Resize and run detection + tracking
+        frame = cv2.resize(frame, (frame_width, frame_height))
+        results = model.track(
+            source=frame,
+            conf=0.7,  # Minimum confidence threshold
+            persist=True  # Enable tracking across frames
+        )
+
+        # Annotate frame with boxes and tracking IDs
+        annotated_frame = results[0].plot()
+        
+        # Record detected classes
+        for box in results[0].boxes:
+            cls = int(box.cls)
+            crimes.append(class_names[cls])
+
+        out.write(annotated_frame)
+
+    # Clean up video resources
+    end = time.time()
+    print(f"[INFO] Processing finished at {end:.2f} seconds")
+    print(f"[INFO] Total execution time: {end - start:.2f} seconds")
+    cap.release()
+    out.release()
+
+    # Generate final output filename containing detected object labels
+    # Format: {original_name}_{detected_objects}_output.mp4
+    unique_crimes = set(crimes)
+    crimes_str = "_".join(sorted(unique_crimes)).replace(" ", "_")[:50]  # truncate if needed
+    final_output_name = f"{base_name}_{crimes_str}_output.mp4"
+    final_output_path = os.path.join(output_dir, final_output_name)
+
+    # Rename the video file
+    os.rename(temp_output_path, final_output_path)
+
+    print(f"[INFO] Detected crimes: {unique_crimes}")
+    print(f"[INFO] Annotated video saved at: {final_output_path}")
+
+    return unique_crimes, final_output_path
+
+
+# # Entry point
+# path0 = input("Enter the local path to the video file to detect objects: ")
+# path = path0.strip('"')  # Remove extra quotes if copied from Windows
+# print(f"[INFO] Loading video: {path}")
+# detection(path)

requirements.txt

@@ -0,0 +1,6 @@
+gradio>=3.0
+tensorflow>=2.10
+opencv-python>=4.6
+ultralytics>=8.0
+numpy>=1.22
+matplotlib>=3.6

trainig.py

@@ -0,0 +1,248 @@
+import os
+import numpy as np
+import cv2
+import traceback
+from collections import Counter
+from sklearn.model_selection import train_test_split
+from tensorflow.keras.utils import Sequence
+from tensorflow.keras.models import Sequential, load_model
+from tensorflow.keras.layers import Input, Conv3D, MaxPooling3D, Flatten, Dense, Dropout, BatchNormalization
+from tensorflow.keras.callbacks import EarlyStopping, ModelCheckpoint, CSVLogger
+import tensorflow as tf
+
+# === CONFIG ===
+DATA_DIR = "D:\\K_REPO\\ComV\\train"
+N_FRAMES = 30
+IMG_SIZE = (96, 96)
+EPOCHS = 10
+BATCH_SIZE = 14
+CHECKPOINT_DIR = r"D:\K_REPO\ComV\AI_made\trainnig_output\checkpoint"
+RESUME_TRAINING = 1
+MIN_REQUIRED_FRAMES = 10
+OUTPUT_PATH = r"D:\K_REPO\ComV\AI_made\trainnig_output\final_model_2.h5"
+# Optimize OpenCV
+cv2.setUseOptimized(True)
+cv2.setNumThreads(8)
+
+# === VIDEO DATA GENERATOR ===
+class VideoDataGenerator(Sequence):
+    def __init__(self, video_paths, labels, batch_size, n_frames, img_size):
+        self.video_paths, self.labels = self._filter_invalid_videos(video_paths, labels)
+        self.batch_size = batch_size
+        self.n_frames = n_frames
+        self.img_size = img_size
+        self.indices = np.arange(len(self.video_paths))
+        print(f"[INFO] Final dataset size: {len(self.video_paths)} videos")
+        
+    def _filter_invalid_videos(self, paths, labels):
+        valid_paths = []
+        valid_labels = []
+        
+        for path, label in zip(paths, labels):
+            cap = cv2.VideoCapture(path)
+            if not cap.isOpened():
+                print(f"[WARNING] Could not open video: {path}")
+                continue
+                
+            total_frames = int(cap.get(cv2.CAP_PROP_FRAME_COUNT))
+            cap.release()
+            
+            if total_frames < MIN_REQUIRED_FRAMES:
+                print(f"[WARNING] Skipping {path} - only {total_frames} frames (needs at least {MIN_REQUIRED_FRAMES})")
+                continue
+                
+            valid_paths.append(path)
+            valid_labels.append(label)
+            
+        return valid_paths, valid_labels
+        
+    def __len__(self):
+        return int(np.ceil(len(self.video_paths) / self.batch_size))
+    
+    def __getitem__(self, index):
+        batch_indices = self.indices[index*self.batch_size:(index+1)*self.batch_size]
+        X, y = [], []
+        
+        for i in batch_indices:
+            path = self.video_paths[i]
+            label = self.labels[i]
+            try:
+                frames = self._load_video_frames(path)
+                X.append(frames)
+                y.append(label)
+            except Exception as e:
+                print(f"[WARNING] Error processing {path} - {str(e)}")
+                X.append(np.zeros((self.n_frames, *self.img_size, 3)))
+                y.append(label)
+                
+        return np.array(X), np.array(y)
+    
+    def _load_video_frames(self, path):
+        cap = cv2.VideoCapture(path)
+        total_frames = int(cap.get(cv2.CAP_PROP_FRAME_COUNT))
+        
+        if total_frames < self.n_frames:
+            frame_indices = np.linspace(0, total_frames - 1, min(total_frames, self.n_frames), dtype=np.int32)
+        else:
+            frame_indices = np.linspace(0, total_frames - 1, self.n_frames, dtype=np.int32)
+        
+        frames = []
+        for idx in frame_indices:
+            cap.set(cv2.CAP_PROP_POS_FRAMES, idx)
+            ret, frame = cap.read()
+            if not ret:
+                frame = np.zeros((*self.img_size, 3), dtype=np.uint8)
+            else:
+                frame = cv2.resize(frame, self.img_size)
+                frame = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
+            frames.append(frame)
+        
+        cap.release()
+        
+        while len(frames) < self.n_frames:
+            frames.append(frames[-1] if frames else np.zeros((*self.img_size, 3), dtype=np.uint8))
+        
+        return np.array(frames) / 255.0
+    
+    def on_epoch_end(self):
+        np.random.shuffle(self.indices)
+
+def create_model():
+    model = Sequential([
+        Input(shape=(N_FRAMES, *IMG_SIZE, 3)),
+        Conv3D(32, kernel_size=(3, 3, 3), activation='relu', padding='same'),
+        MaxPooling3D(pool_size=(1, 2, 2)),
+        BatchNormalization(),
+        
+        Conv3D(64, kernel_size=(3, 3, 3), activation='relu', padding='same'),
+        MaxPooling3D(pool_size=(1, 2, 2)),
+        BatchNormalization(),
+        
+        Conv3D(128, kernel_size=(3, 3, 3), activation='relu', padding='same'),
+        MaxPooling3D(pool_size=(2, 2, 2)),
+        BatchNormalization(),
+        
+        Flatten(),
+        Dense(256, activation='relu'),
+        Dropout(0.5),
+        Dense(1, activation='sigmoid')
+    ])
+    
+    model.compile(optimizer='adam',
+                 loss='binary_crossentropy',
+                 metrics=['accuracy'])
+    
+    return model
+
+def load_data():
+    video_paths, labels = [], []
+    for label_name in ["Fighting", "Normal"]:
+        label_dir = os.path.join(DATA_DIR, label_name)
+        if not os.path.isdir(label_dir):
+            raise FileNotFoundError(f"Directory not found: {label_dir}")
+
+        label = 1 if label_name.lower() == "fighting" else 0
+
+        for file in os.listdir(label_dir):
+            if file.lower().endswith((".mp4", ".mpeg", ".avi", ".mov")):
+                full_path = os.path.join(label_dir, file)
+                video_paths.append(full_path)
+                labels.append(label)
+
+    if not video_paths:
+        raise ValueError(f"No videos found in {DATA_DIR}")
+
+    print(f"[INFO] Total videos: {len(video_paths)} (Fighting: {labels.count(1)}, Normal: {labels.count(0)})")
+
+    if len(set(labels)) > 1:
+        return train_test_split(video_paths, labels, test_size=0.2, stratify=labels, random_state=42)
+    else:
+        print("[WARNING] Only one class found. Splitting without stratification.")
+        return train_test_split(video_paths, labels, test_size=0.2, random_state=42)
+
+def get_latest_checkpoint():
+    if not os.path.exists(CHECKPOINT_DIR):
+        os.makedirs(CHECKPOINT_DIR)
+        return None
+    
+    checkpoints = [f for f in os.listdir(CHECKPOINT_DIR) 
+                 if f.startswith('ckpt_') and f.endswith('.h5')]
+    if not checkpoints:
+        return None
+    
+    checkpoints.sort(key=lambda x: int(x.split('_')[1].split('.')[0]))
+    return os.path.join(CHECKPOINT_DIR, checkpoints[-1])
+
+def main():
+    # Load and split data
+    try:
+        train_paths, val_paths, train_labels, val_labels = load_data()
+    except Exception as e:
+        print(f"[ERROR] Failed to load data: {str(e)}")
+        return
+
+    # Create data generators
+    try:
+        train_gen = VideoDataGenerator(train_paths, train_labels, BATCH_SIZE, N_FRAMES, IMG_SIZE)
+        val_gen = VideoDataGenerator(val_paths, val_labels, BATCH_SIZE, N_FRAMES, IMG_SIZE)
+    except Exception as e:
+        print(f"[ERROR] Failed to create data generators: {str(e)}")
+        return
+
+    # Callbacks
+    callbacks = [
+        ModelCheckpoint(
+            os.path.join(CHECKPOINT_DIR, 'ckpt_{epoch}.h5'),
+            save_best_only=False,
+            save_weights_only=False
+        ),
+        CSVLogger('training_log.csv', append=True),
+        EarlyStopping(monitor='val_loss', patience=5, restore_best_weights=True)
+    ]
+
+    # Handle resume training
+    initial_epoch = 0
+    try:
+        if RESUME_TRAINING:
+            ckpt = get_latest_checkpoint()
+            if ckpt:
+                print(f"[INFO] Resuming training from checkpoint: {ckpt}")
+                model = load_model(ckpt)
+                initial_epoch = int(ckpt.split('_')[1].split('.')[0])
+            else:
+                print("[INFO] No checkpoint found, starting new training")
+                model = create_model()
+        else:
+            model = create_model()
+    except Exception as e:
+        print(f"[ERROR] Failed to initialize model: {str(e)}")
+        return
+
+    # Display model summary
+    model.summary()
+
+    # Train model
+    try:
+        print("[INFO] Starting training...")
+        history = model.fit(
+            train_gen,
+            validation_data=val_gen,
+            epochs=EPOCHS,
+            initial_epoch=initial_epoch,
+            callbacks=callbacks,
+            verbose=1
+        )
+    except Exception as e:
+        print(f"[ERROR] Training failed: {str(e)}")
+        traceback.print_exc()
+    finally:
+        model.save(OUTPUT_PATH)
+        print("[INFO] Training completed. Model saved to final_model_2.h5")
+
+if __name__ == "__main__":
+    print("[INFO] Starting script...")
+    main()
+    print("[INFO] Script execution completed.")
+
+
+