diff --git a/lab02_Gun_detection_fasterRCNN/gun_detection_fasterRCNN.ipynb b/lab02_Gun_detection_fasterRCNN/gun_detection_fasterRCNN.ipynb index 88ef2d9..7be35cf 100644 --- a/lab02_Gun_detection_fasterRCNN/gun_detection_fasterRCNN.ipynb +++ b/lab02_Gun_detection_fasterRCNN/gun_detection_fasterRCNN.ipynb @@ -1,176 +1,916 @@ -# Gun Detection Lab: Detecting Guns in Images using PyTorch and Faster R-CNN - -# Step 1: Install Dependencies -!pip install torch torchvision matplotlib opencv-python pycocotools py7zr - -# Step 2: Import Libraries -import os -import torch -import torchvision -from torchvision.models.detection.faster_rcnn import FastRCNNPredictor -from torchvision.transforms import functional as F -from torch.utils.data import DataLoader -from PIL import Image -import matplotlib.pyplot as plt -import numpy as np -import py7zr - -# Step 3: Download and Extract Dataset -dataset_url = "https://github.com/frankwxu/AI4DigitalForensics/raw/main/lab02_Gun_detection_fasterRCNN/data/data.7z" -dataset_path = "/content/data.7z" -extracted_path = "/content/dataset" - -# Download the dataset -!wget -O {dataset_path} {dataset_url} - -# Extract the dataset -with py7zr.SevenZipFile(dataset_path, mode='r') as z: - z.extractall(path=extracted_path) - -# Define paths to images and labels -images_dir = os.path.join(extracted_path, "Images") # Folder name is "Images" -labels_dir = os.path.join(extracted_path, "Labels") # Folder name is "Labels" - -# Step 4: Create Custom Dataset Class -class GunDataset(torch.utils.data.Dataset): - def __init__(self, root, transforms=None): - self.root = root - self.transforms = transforms - self.imgs = list(sorted(os.listdir(os.path.join(root, "Images")))) - self.labels = list(sorted(os.listdir(os.path.join(root, "Labels")))) - - def __getitem__(self, idx): - img_path = os.path.join(self.root, "Images", self.imgs[idx]) - label_path = os.path.join(self.root, "Labels", self.labels[idx]) - - img = Image.open(img_path).convert("RGB") - target = self.parse_annotation(label_path) - - if self.transforms is not None: - img = self.transforms(img) - - return img, target - - def __len__(self): - return len(self.imgs) - - def parse_annotation(self, label_path): - with open(label_path, 'r') as f: - lines = f.readlines() - num_guns = int(lines[0].strip()) # Number of guns in the image - bboxes = [] - labels = [] - - # Parse each bounding box - for i in range(1, num_guns + 1): - bbox = list(map(int, lines[i].strip().split())) # Bounding box (xmin, ymin, xmax, ymax) - bboxes.append(bbox) - labels.append(1) # All objects are labeled as "Gun" (class 1) - - return { - 'boxes': torch.tensor(bboxes, dtype=torch.float32), - 'labels': torch.tensor(labels, dtype=torch.int64) +{ + "nbformat": 4, + "nbformat_minor": 0, + "metadata": { + "colab": { + "provenance": [], + "gpuType": "T4" + }, + "kernelspec": { + "name": "python3", + "display_name": "Python 3" + }, + "language_info": { + "name": "python" + }, + "accelerator": "GPU" + }, + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "shlleDiZEM06", + "outputId": "a9b467c4-9a1c-45af-f646-136ccedccd5f" + }, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Requirement already satisfied: torch in /usr/local/lib/python3.11/dist-packages (2.5.1+cu124)\n", + "Requirement already satisfied: torchvision in /usr/local/lib/python3.11/dist-packages (0.20.1+cu124)\n", + "Requirement already satisfied: matplotlib in /usr/local/lib/python3.11/dist-packages (3.10.0)\n", + "Requirement already satisfied: opencv-python in /usr/local/lib/python3.11/dist-packages (4.11.0.86)\n", + "Requirement already satisfied: pycocotools in /usr/local/lib/python3.11/dist-packages (2.0.8)\n", + "Collecting py7zr\n", + " Downloading py7zr-0.22.0-py3-none-any.whl.metadata (16 kB)\n", + "Requirement already satisfied: requests in /usr/local/lib/python3.11/dist-packages (2.32.3)\n", + "Requirement already satisfied: filelock in /usr/local/lib/python3.11/dist-packages (from torch) (3.17.0)\n", + "Requirement already satisfied: typing-extensions>=4.8.0 in /usr/local/lib/python3.11/dist-packages (from torch) (4.12.2)\n", + "Requirement already satisfied: networkx in /usr/local/lib/python3.11/dist-packages (from torch) (3.4.2)\n", + "Requirement already satisfied: jinja2 in /usr/local/lib/python3.11/dist-packages (from torch) (3.1.5)\n", + "Requirement already satisfied: fsspec in /usr/local/lib/python3.11/dist-packages (from torch) (2024.10.0)\n", + "Collecting nvidia-cuda-nvrtc-cu12==12.4.127 (from torch)\n", + " Downloading nvidia_cuda_nvrtc_cu12-12.4.127-py3-none-manylinux2014_x86_64.whl.metadata (1.5 kB)\n", + "Collecting nvidia-cuda-runtime-cu12==12.4.127 (from torch)\n", + " Downloading nvidia_cuda_runtime_cu12-12.4.127-py3-none-manylinux2014_x86_64.whl.metadata (1.5 kB)\n", + "Collecting nvidia-cuda-cupti-cu12==12.4.127 (from torch)\n", + " Downloading nvidia_cuda_cupti_cu12-12.4.127-py3-none-manylinux2014_x86_64.whl.metadata (1.6 kB)\n", + "Collecting nvidia-cudnn-cu12==9.1.0.70 (from torch)\n", + " Downloading nvidia_cudnn_cu12-9.1.0.70-py3-none-manylinux2014_x86_64.whl.metadata (1.6 kB)\n", + "Collecting nvidia-cublas-cu12==12.4.5.8 (from torch)\n", + " Downloading nvidia_cublas_cu12-12.4.5.8-py3-none-manylinux2014_x86_64.whl.metadata (1.5 kB)\n", + "Collecting nvidia-cufft-cu12==11.2.1.3 (from torch)\n", + " Downloading nvidia_cufft_cu12-11.2.1.3-py3-none-manylinux2014_x86_64.whl.metadata (1.5 kB)\n", + "Collecting nvidia-curand-cu12==10.3.5.147 (from torch)\n", + " Downloading nvidia_curand_cu12-10.3.5.147-py3-none-manylinux2014_x86_64.whl.metadata (1.5 kB)\n", + "Collecting nvidia-cusolver-cu12==11.6.1.9 (from torch)\n", + " Downloading nvidia_cusolver_cu12-11.6.1.9-py3-none-manylinux2014_x86_64.whl.metadata (1.6 kB)\n", + "Collecting nvidia-cusparse-cu12==12.3.1.170 (from torch)\n", + " Downloading nvidia_cusparse_cu12-12.3.1.170-py3-none-manylinux2014_x86_64.whl.metadata (1.6 kB)\n", + "Requirement already satisfied: nvidia-nccl-cu12==2.21.5 in /usr/local/lib/python3.11/dist-packages (from torch) (2.21.5)\n", + "Requirement already satisfied: nvidia-nvtx-cu12==12.4.127 in /usr/local/lib/python3.11/dist-packages (from torch) (12.4.127)\n", + "Collecting nvidia-nvjitlink-cu12==12.4.127 (from torch)\n", + " Downloading nvidia_nvjitlink_cu12-12.4.127-py3-none-manylinux2014_x86_64.whl.metadata (1.5 kB)\n", + "Requirement already satisfied: triton==3.1.0 in /usr/local/lib/python3.11/dist-packages (from torch) (3.1.0)\n", + "Requirement already satisfied: sympy==1.13.1 in /usr/local/lib/python3.11/dist-packages (from torch) (1.13.1)\n", + "Requirement already satisfied: mpmath<1.4,>=1.1.0 in /usr/local/lib/python3.11/dist-packages (from sympy==1.13.1->torch) (1.3.0)\n", + "Requirement already satisfied: numpy in /usr/local/lib/python3.11/dist-packages (from torchvision) (1.26.4)\n", + "Requirement already satisfied: pillow!=8.3.*,>=5.3.0 in /usr/local/lib/python3.11/dist-packages (from torchvision) (11.1.0)\n", + "Requirement already satisfied: contourpy>=1.0.1 in /usr/local/lib/python3.11/dist-packages (from matplotlib) (1.3.1)\n", + "Requirement already satisfied: cycler>=0.10 in /usr/local/lib/python3.11/dist-packages (from matplotlib) (0.12.1)\n", + "Requirement already satisfied: fonttools>=4.22.0 in /usr/local/lib/python3.11/dist-packages (from matplotlib) (4.56.0)\n", + "Requirement already satisfied: kiwisolver>=1.3.1 in /usr/local/lib/python3.11/dist-packages (from matplotlib) (1.4.8)\n", + "Requirement already satisfied: packaging>=20.0 in /usr/local/lib/python3.11/dist-packages (from matplotlib) (24.2)\n", + "Requirement already satisfied: pyparsing>=2.3.1 in /usr/local/lib/python3.11/dist-packages (from matplotlib) (3.2.1)\n", + "Requirement already satisfied: python-dateutil>=2.7 in /usr/local/lib/python3.11/dist-packages (from matplotlib) (2.8.2)\n", + "Collecting texttable (from py7zr)\n", + " Downloading texttable-1.7.0-py2.py3-none-any.whl.metadata (9.8 kB)\n", + "Collecting pycryptodomex>=3.16.0 (from py7zr)\n", + " Downloading pycryptodomex-3.21.0-cp36-abi3-manylinux_2_17_x86_64.manylinux2014_x86_64.whl.metadata (3.4 kB)\n", + "Collecting pyzstd>=0.15.9 (from py7zr)\n", + " Downloading pyzstd-0.16.2-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl.metadata (2.4 kB)\n", + "Collecting pyppmd<1.2.0,>=1.1.0 (from py7zr)\n", + " Downloading pyppmd-1.1.1-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl.metadata (5.5 kB)\n", + "Collecting pybcj<1.1.0,>=1.0.0 (from py7zr)\n", + " Downloading pybcj-1.0.3-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl.metadata (3.9 kB)\n", + "Collecting multivolumefile>=0.2.3 (from py7zr)\n", + " Downloading multivolumefile-0.2.3-py3-none-any.whl.metadata (6.3 kB)\n", + "Collecting inflate64<1.1.0,>=1.0.0 (from py7zr)\n", + " Downloading inflate64-1.0.1-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl.metadata (3.8 kB)\n", + "Collecting brotli>=1.1.0 (from py7zr)\n", + " Downloading Brotli-1.1.0-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl.metadata (5.5 kB)\n", + "Requirement already satisfied: psutil in /usr/local/lib/python3.11/dist-packages (from py7zr) (5.9.5)\n", + "Requirement already satisfied: charset-normalizer<4,>=2 in /usr/local/lib/python3.11/dist-packages (from requests) (3.4.1)\n", + "Requirement already satisfied: idna<4,>=2.5 in /usr/local/lib/python3.11/dist-packages (from requests) (3.10)\n", + "Requirement already satisfied: urllib3<3,>=1.21.1 in /usr/local/lib/python3.11/dist-packages (from requests) (2.3.0)\n", + "Requirement already satisfied: certifi>=2017.4.17 in /usr/local/lib/python3.11/dist-packages (from requests) (2025.1.31)\n", + "Requirement already satisfied: six>=1.5 in /usr/local/lib/python3.11/dist-packages (from python-dateutil>=2.7->matplotlib) (1.17.0)\n", + "Requirement already satisfied: MarkupSafe>=2.0 in /usr/local/lib/python3.11/dist-packages (from jinja2->torch) (3.0.2)\n", + "Downloading nvidia_cublas_cu12-12.4.5.8-py3-none-manylinux2014_x86_64.whl (363.4 MB)\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m363.4/363.4 MB\u001b[0m \u001b[31m3.3 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hDownloading nvidia_cuda_cupti_cu12-12.4.127-py3-none-manylinux2014_x86_64.whl (13.8 MB)\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m13.8/13.8 MB\u001b[0m \u001b[31m21.2 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hDownloading nvidia_cuda_nvrtc_cu12-12.4.127-py3-none-manylinux2014_x86_64.whl (24.6 MB)\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m24.6/24.6 MB\u001b[0m \u001b[31m16.1 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hDownloading nvidia_cuda_runtime_cu12-12.4.127-py3-none-manylinux2014_x86_64.whl (883 kB)\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m883.7/883.7 kB\u001b[0m \u001b[31m22.5 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hDownloading nvidia_cudnn_cu12-9.1.0.70-py3-none-manylinux2014_x86_64.whl (664.8 MB)\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m664.8/664.8 MB\u001b[0m \u001b[31m1.9 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hDownloading nvidia_cufft_cu12-11.2.1.3-py3-none-manylinux2014_x86_64.whl (211.5 MB)\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m211.5/211.5 MB\u001b[0m \u001b[31m5.8 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hDownloading nvidia_curand_cu12-10.3.5.147-py3-none-manylinux2014_x86_64.whl (56.3 MB)\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m56.3/56.3 MB\u001b[0m \u001b[31m9.8 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hDownloading nvidia_cusolver_cu12-11.6.1.9-py3-none-manylinux2014_x86_64.whl (127.9 MB)\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m127.9/127.9 MB\u001b[0m \u001b[31m7.6 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hDownloading nvidia_cusparse_cu12-12.3.1.170-py3-none-manylinux2014_x86_64.whl (207.5 MB)\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m207.5/207.5 MB\u001b[0m \u001b[31m5.3 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hDownloading nvidia_nvjitlink_cu12-12.4.127-py3-none-manylinux2014_x86_64.whl (21.1 MB)\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m21.1/21.1 MB\u001b[0m \u001b[31m41.2 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hDownloading py7zr-0.22.0-py3-none-any.whl (67 kB)\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m67.9/67.9 kB\u001b[0m \u001b[31m5.8 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hDownloading Brotli-1.1.0-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl (2.9 MB)\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m2.9/2.9 MB\u001b[0m \u001b[31m44.5 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hDownloading inflate64-1.0.1-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl (96 kB)\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m96.2/96.2 kB\u001b[0m \u001b[31m8.3 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hDownloading multivolumefile-0.2.3-py3-none-any.whl (17 kB)\n", + "Downloading pybcj-1.0.3-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl (50 kB)\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m50.6/50.6 kB\u001b[0m \u001b[31m4.8 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hDownloading pycryptodomex-3.21.0-cp36-abi3-manylinux_2_17_x86_64.manylinux2014_x86_64.whl (2.3 MB)\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m2.3/2.3 MB\u001b[0m \u001b[31m44.6 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hDownloading pyppmd-1.1.1-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl (141 kB)\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m141.3/141.3 kB\u001b[0m \u001b[31m11.1 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hDownloading pyzstd-0.16.2-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl (413 kB)\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m413.7/413.7 kB\u001b[0m \u001b[31m30.4 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hDownloading texttable-1.7.0-py2.py3-none-any.whl (10 kB)\n", + "Installing collected packages: texttable, brotli, pyzstd, pyppmd, pycryptodomex, pybcj, nvidia-nvjitlink-cu12, nvidia-curand-cu12, nvidia-cufft-cu12, nvidia-cuda-runtime-cu12, nvidia-cuda-nvrtc-cu12, nvidia-cuda-cupti-cu12, nvidia-cublas-cu12, multivolumefile, inflate64, py7zr, nvidia-cusparse-cu12, nvidia-cudnn-cu12, nvidia-cusolver-cu12\n", + " Attempting uninstall: nvidia-nvjitlink-cu12\n", + " Found existing installation: nvidia-nvjitlink-cu12 12.5.82\n", + " Uninstalling nvidia-nvjitlink-cu12-12.5.82:\n", + " Successfully uninstalled nvidia-nvjitlink-cu12-12.5.82\n", + " Attempting uninstall: nvidia-curand-cu12\n", + " Found existing installation: nvidia-curand-cu12 10.3.6.82\n", + " Uninstalling nvidia-curand-cu12-10.3.6.82:\n", + " Successfully uninstalled nvidia-curand-cu12-10.3.6.82\n", + " Attempting uninstall: nvidia-cufft-cu12\n", + " Found existing installation: nvidia-cufft-cu12 11.2.3.61\n", + " Uninstalling nvidia-cufft-cu12-11.2.3.61:\n", + " Successfully uninstalled nvidia-cufft-cu12-11.2.3.61\n", + " Attempting uninstall: nvidia-cuda-runtime-cu12\n", + " Found existing installation: nvidia-cuda-runtime-cu12 12.5.82\n", + " Uninstalling nvidia-cuda-runtime-cu12-12.5.82:\n", + " Successfully uninstalled nvidia-cuda-runtime-cu12-12.5.82\n", + " Attempting uninstall: nvidia-cuda-nvrtc-cu12\n", + " Found existing installation: nvidia-cuda-nvrtc-cu12 12.5.82\n", + " Uninstalling nvidia-cuda-nvrtc-cu12-12.5.82:\n", + " Successfully uninstalled nvidia-cuda-nvrtc-cu12-12.5.82\n", + " Attempting uninstall: nvidia-cuda-cupti-cu12\n", + " Found existing installation: nvidia-cuda-cupti-cu12 12.5.82\n", + " Uninstalling nvidia-cuda-cupti-cu12-12.5.82:\n", + " Successfully uninstalled nvidia-cuda-cupti-cu12-12.5.82\n", + " Attempting uninstall: nvidia-cublas-cu12\n", + " Found existing installation: nvidia-cublas-cu12 12.5.3.2\n", + " Uninstalling nvidia-cublas-cu12-12.5.3.2:\n", + " Successfully uninstalled nvidia-cublas-cu12-12.5.3.2\n", + " Attempting uninstall: nvidia-cusparse-cu12\n", + " Found existing installation: nvidia-cusparse-cu12 12.5.1.3\n", + " Uninstalling nvidia-cusparse-cu12-12.5.1.3:\n", + " Successfully uninstalled nvidia-cusparse-cu12-12.5.1.3\n", + " Attempting uninstall: nvidia-cudnn-cu12\n", + " Found existing installation: nvidia-cudnn-cu12 9.3.0.75\n", + " Uninstalling nvidia-cudnn-cu12-9.3.0.75:\n", + " Successfully uninstalled nvidia-cudnn-cu12-9.3.0.75\n", + " Attempting uninstall: nvidia-cusolver-cu12\n", + " Found existing installation: nvidia-cusolver-cu12 11.6.3.83\n", + " Uninstalling nvidia-cusolver-cu12-11.6.3.83:\n", + " Successfully uninstalled nvidia-cusolver-cu12-11.6.3.83\n", + "Successfully installed brotli-1.1.0 inflate64-1.0.1 multivolumefile-0.2.3 nvidia-cublas-cu12-12.4.5.8 nvidia-cuda-cupti-cu12-12.4.127 nvidia-cuda-nvrtc-cu12-12.4.127 nvidia-cuda-runtime-cu12-12.4.127 nvidia-cudnn-cu12-9.1.0.70 nvidia-cufft-cu12-11.2.1.3 nvidia-curand-cu12-10.3.5.147 nvidia-cusolver-cu12-11.6.1.9 nvidia-cusparse-cu12-12.3.1.170 nvidia-nvjitlink-cu12-12.4.127 py7zr-0.22.0 pybcj-1.0.3 pycryptodomex-3.21.0 pyppmd-1.1.1 pyzstd-0.16.2 texttable-1.7.0\n", + "--2025-03-05 01:28:27-- https://github.com/frankwxu/AI4DigitalForensics/raw/main/lab02_Gun_detection_fasterRCNN/data/data.7z\n", + "Resolving github.com (github.com)... 140.82.116.4\n", + "Connecting to github.com (github.com)|140.82.116.4|:443... connected.\n", + "HTTP request sent, awaiting response... 302 Found\n", + "Location: https://raw.githubusercontent.com/frankwxu/AI4DigitalForensics/main/lab02_Gun_detection_fasterRCNN/data/data.7z [following]\n", + "--2025-03-05 01:28:28-- https://raw.githubusercontent.com/frankwxu/AI4DigitalForensics/main/lab02_Gun_detection_fasterRCNN/data/data.7z\n", + "Resolving raw.githubusercontent.com (raw.githubusercontent.com)... 185.199.108.133, 185.199.109.133, 185.199.110.133, ...\n", + "Connecting to raw.githubusercontent.com (raw.githubusercontent.com)|185.199.108.133|:443... connected.\n", + "HTTP request sent, awaiting response... 200 OK\n", + "Length: 2171919 (2.1M) [application/octet-stream]\n", + "Saving to: ‘/content/data.7z’\n", + "\n", + "/content/data.7z 100%[===================>] 2.07M --.-KB/s in 0.05s \n", + "\n", + "2025-03-05 01:28:28 (41.8 MB/s) - ‘/content/data.7z’ saved [2171919/2171919]\n", + "\n" + ] } - -# Step 5: Define Data Transforms -def get_transform(train): - transforms = [] - transforms.append(torchvision.transforms.ToTensor()) - if train: - transforms.append(torchvision.transforms.RandomHorizontalFlip(0.5)) - return torchvision.transforms.Compose(transforms) - -# Step 6: Load Dataset -train_dataset = GunDataset(extracted_path, get_transform(train=True)) -test_dataset = GunDataset(extracted_path, get_transform(train=False)) - -train_loader = DataLoader(train_dataset, batch_size=2, shuffle=True, collate_fn=lambda x: tuple(zip(*x))) -test_loader = DataLoader(test_dataset, batch_size=1, shuffle=False, collate_fn=lambda x: tuple(zip(*x))) - -# Step 7: Load Pre-trained Faster R-CNN Model -model = torchvision.models.detection.fasterrcnn_resnet50_fpn(pretrained=True) - -# Replace the classifier head for custom classes -num_classes = 2 # Background + Gun -in_features = model.roi_heads.box_predictor.cls_score.in_features -model.roi_heads.box_predictor = FastRCNNPredictor(in_features, num_classes) - -# Move the model to GPU if available -device = torch.device("cuda" if torch.cuda.is_available() else "cpu") -model.to(device) - -# Step 8: Define Optimizer -params = [p for p in model.parameters() if p.requires_grad] -optimizer = torch.optim.SGD(params, lr=0.005, momentum=0.9, weight_decay=0.0005) - -# Step 9: Train the Model -def train_one_epoch(model, optimizer, data_loader, device, epoch): - model.train() - for i, (images, targets) in enumerate(data_loader): - images = list(image.to(device) for image in images) - targets = [{k: v.to(device) for k, v in t.items()} for t in targets] - - loss_dict = model(images, targets) - losses = sum(loss for loss in loss_dict.values()) - - optimizer.zero_grad() - losses.backward() - optimizer.step() - - if i % 10 == 0: - print(f"Iteration {i}, Loss: {losses.item()}") - -# Train for 10 epochs -num_epochs = 10 -for epoch in range(num_epochs): - print(f"Epoch {epoch+1}/{num_epochs}") - train_one_epoch(model, optimizer, train_loader, device, epoch) - -# Step 10: Evaluate the Model -def evaluate_model(model, data_loader, device): - model.eval() - all_preds = [] - all_labels = [] - - with torch.no_grad(): - for images, targets in data_loader: - images = list(image.to(device) for image in images) - outputs = model(images) - - for output in outputs: - preds = output['labels'].cpu().numpy() - all_preds.extend(preds) - - for target in targets: - labels = target['labels'].cpu().numpy() - all_labels.extend(labels) - - print("\nClassification Report:") - from sklearn.metrics import classification_report - print(classification_report(all_labels, all_preds, target_names=['Background', 'Gun'])) - -evaluate_model(model, test_loader, device) - -# Step 11: Test on Custom Images -def predict_image(img_path, model, transform): - img = Image.open(img_path).convert("RGB") - img_tensor = transform(img).unsqueeze(0).to(device) - - model.eval() - with torch.no_grad(): - prediction = model(img_tensor)[0] - - # Plot the image with bounding boxes - plt.figure(figsize=(10, 10)) - plt.imshow(img) - for box, label in zip(prediction['boxes'], prediction['labels']): - if label == 1: # Gun detected - box = box.cpu().numpy() - plt.gca().add_patch(plt.Rectangle((box[0], box[1]), box[2]-box[0], box[3]-box[1], - edgecolor='red', facecolor='none', linewidth=2)) - plt.axis('off') - plt.show() - -# Example Usage -custom_image_path = '/content/dataset/Images/test_image.jpg' # Update this path -predict_image(custom_image_path, model, get_transform(train=False)) \ No newline at end of file + ], + "source": [ + "# Gun Detection Lab: Detecting Guns in Images using PyTorch and Faster R-CNN\n", + "# Use GPU: Runtime=>Change Runtime type=>T4 GPU\n", + "\n", + "# Step 1: Install Dependencies\n", + "!pip install torch torchvision matplotlib opencv-python pycocotools py7zr requests\n", + "\n", + "# Step 2: Import Libraries\n", + "import os\n", + "import torch\n", + "import torchvision\n", + "from torchvision.models.detection.faster_rcnn import FastRCNNPredictor\n", + "from torchvision.transforms import functional as F\n", + "from torch.utils.data import DataLoader\n", + "from PIL import Image\n", + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "from sklearn.model_selection import train_test_split\n", + "import py7zr\n", + "import requests\n", + "\n", + "# Step 3: Download and Extract Dataset\n", + "dataset_url = \"https://github.com/frankwxu/AI4DigitalForensics/raw/main/lab02_Gun_detection_fasterRCNN/data/data.7z\"\n", + "dataset_path = \"/content/data.7z\"\n", + "extracted_path = \"/content/dataset\"\n", + "\n", + "# Download the dataset\n", + "!wget -O {dataset_path} {dataset_url}\n", + "\n", + "# Extract the dataset\n", + "with py7zr.SevenZipFile(dataset_path, mode='r') as z:\n", + " z.extractall(path=extracted_path)\n", + "\n", + "# Define paths to images and labels\n", + "images_dir = os.path.join(extracted_path, \"Images\")\n", + "labels_dir = os.path.join(extracted_path, \"Labels\")\n" + ] + }, + { + "cell_type": "code", + "source": [ + "# Step 4: Create Custom Dataset Class\n", + "class GunDataset(torch.utils.data.Dataset):\n", + " def __init__(self, root, transforms=None):\n", + " self.root = root\n", + " self.transforms = transforms\n", + " self.imgs = list(sorted(os.listdir(os.path.join(root, \"Images\"))))\n", + " self.labels = list(sorted(os.listdir(os.path.join(root, \"Labels\"))))\n", + "\n", + " def __getitem__(self, idx):\n", + " img_path = os.path.join(self.root, \"Images\", self.imgs[idx])\n", + " label_path = os.path.join(self.root, \"Labels\", self.labels[idx])\n", + "\n", + " img = Image.open(img_path).convert(\"RGB\")\n", + " target = self.parse_annotation(label_path)\n", + "\n", + " if self.transforms is not None:\n", + " img = self.transforms(img)\n", + "\n", + " return img, target\n", + "\n", + " def __len__(self):\n", + " return len(self.imgs)\n", + "\n", + " def parse_annotation(self, label_path):\n", + " with open(label_path, 'r') as f:\n", + " lines = f.readlines()\n", + " num_guns = int(lines[0].strip()) # Number of guns in the image\n", + " bboxes = []\n", + " labels = []\n", + "\n", + " # Parse each bounding box\n", + " for i in range(1, num_guns + 1):\n", + " bbox = list(map(int, lines[i].strip().split())) # Bounding box (xmin, ymin, xmax, ymax)\n", + " bboxes.append(bbox)\n", + " labels.append(1) # All objects are labeled as \"Gun\" (class 1)\n", + "\n", + " return {\n", + " 'boxes': torch.tensor(bboxes, dtype=torch.float32),\n", + " 'labels': torch.tensor(labels, dtype=torch.int64)\n", + " }" + ], + "metadata": { + "id": "Nc6U_Za2HU6F" + }, + "execution_count": 2, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "# Step 5: Define Data Transforms\n", + "def get_transform(train):\n", + " transforms = []\n", + " transforms.append(torchvision.transforms.ToTensor())\n", + " if train:\n", + " transforms.append(torchvision.transforms.RandomHorizontalFlip(0.5))\n", + " return torchvision.transforms.Compose(transforms)\n", + "\n", + "# Step 6: Load Dataset\n", + "train_dataset = GunDataset(extracted_path, get_transform(train=True))\n", + "test_dataset = GunDataset(extracted_path, get_transform(train=False))\n", + "\n", + "train_loader = DataLoader(train_dataset, batch_size=2, shuffle=True, collate_fn=lambda x: tuple(zip(*x)))\n", + "test_loader = DataLoader(test_dataset, batch_size=1, shuffle=False, collate_fn=lambda x: tuple(zip(*x)))\n", + "\n", + "# Step 7: Load Pre-trained Faster R-CNN Model\n", + "model = torchvision.models.detection.fasterrcnn_resnet50_fpn(pretrained=True)\n", + "\n", + "# Replace the classifier head for custom classes\n", + "num_classes = 2 # Background + Gun\n", + "in_features = model.roi_heads.box_predictor.cls_score.in_features\n", + "model.roi_heads.box_predictor = FastRCNNPredictor(in_features, num_classes)\n", + "\n", + "# Move the model to GPU if available\n", + "device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n", + "model.to(device)" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "P3KsnYssJ_aR", + "outputId": "dc676cb1-fc44-48b5-fa53-ec460623bbaa" + }, + "execution_count": 3, + "outputs": [ + { + "output_type": "stream", + "name": "stderr", + "text": [ + "/usr/local/lib/python3.11/dist-packages/torchvision/models/_utils.py:208: UserWarning: The parameter 'pretrained' is deprecated since 0.13 and may be removed in the future, please use 'weights' instead.\n", + " warnings.warn(\n", + "/usr/local/lib/python3.11/dist-packages/torchvision/models/_utils.py:223: UserWarning: Arguments other than a weight enum or `None` for 'weights' are deprecated since 0.13 and may be removed in the future. The current behavior is equivalent to passing `weights=FasterRCNN_ResNet50_FPN_Weights.COCO_V1`. You can also use `weights=FasterRCNN_ResNet50_FPN_Weights.DEFAULT` to get the most up-to-date weights.\n", + " warnings.warn(msg)\n", + "Downloading: \"https://download.pytorch.org/models/fasterrcnn_resnet50_fpn_coco-258fb6c6.pth\" to /root/.cache/torch/hub/checkpoints/fasterrcnn_resnet50_fpn_coco-258fb6c6.pth\n", + "100%|██████████| 160M/160M [00:02<00:00, 68.8MB/s]\n" + ] + }, + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "FasterRCNN(\n", + " (transform): GeneralizedRCNNTransform(\n", + " Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225])\n", + " Resize(min_size=(800,), max_size=1333, mode='bilinear')\n", + " )\n", + " (backbone): BackboneWithFPN(\n", + " (body): IntermediateLayerGetter(\n", + " (conv1): Conv2d(3, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False)\n", + " (bn1): FrozenBatchNorm2d(64, eps=0.0)\n", + " (relu): ReLU(inplace=True)\n", + " (maxpool): MaxPool2d(kernel_size=3, stride=2, padding=1, dilation=1, ceil_mode=False)\n", + " (layer1): Sequential(\n", + " (0): Bottleneck(\n", + " (conv1): Conv2d(64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn1): FrozenBatchNorm2d(64, eps=0.0)\n", + " (conv2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", + " (bn2): FrozenBatchNorm2d(64, eps=0.0)\n", + " (conv3): Conv2d(64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn3): FrozenBatchNorm2d(256, eps=0.0)\n", + " (relu): ReLU(inplace=True)\n", + " (downsample): Sequential(\n", + " (0): Conv2d(64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (1): FrozenBatchNorm2d(256, eps=0.0)\n", + " )\n", + " )\n", + " (1): Bottleneck(\n", + " (conv1): Conv2d(256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn1): FrozenBatchNorm2d(64, eps=0.0)\n", + " (conv2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", + " (bn2): FrozenBatchNorm2d(64, eps=0.0)\n", + " (conv3): Conv2d(64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn3): FrozenBatchNorm2d(256, eps=0.0)\n", + " (relu): ReLU(inplace=True)\n", + " )\n", + " (2): Bottleneck(\n", + " (conv1): Conv2d(256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn1): FrozenBatchNorm2d(64, eps=0.0)\n", + " (conv2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", + " (bn2): FrozenBatchNorm2d(64, eps=0.0)\n", + " (conv3): Conv2d(64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn3): FrozenBatchNorm2d(256, eps=0.0)\n", + " (relu): ReLU(inplace=True)\n", + " )\n", + " )\n", + " (layer2): Sequential(\n", + " (0): Bottleneck(\n", + " (conv1): Conv2d(256, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn1): FrozenBatchNorm2d(128, eps=0.0)\n", + " (conv2): Conv2d(128, 128, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), bias=False)\n", + " (bn2): FrozenBatchNorm2d(128, eps=0.0)\n", + " (conv3): Conv2d(128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn3): FrozenBatchNorm2d(512, eps=0.0)\n", + " (relu): ReLU(inplace=True)\n", + " (downsample): Sequential(\n", + " (0): Conv2d(256, 512, kernel_size=(1, 1), stride=(2, 2), bias=False)\n", + " (1): FrozenBatchNorm2d(512, eps=0.0)\n", + " )\n", + " )\n", + " (1): Bottleneck(\n", + " (conv1): Conv2d(512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn1): FrozenBatchNorm2d(128, eps=0.0)\n", + " (conv2): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", + " (bn2): FrozenBatchNorm2d(128, eps=0.0)\n", + " (conv3): Conv2d(128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn3): FrozenBatchNorm2d(512, eps=0.0)\n", + " (relu): ReLU(inplace=True)\n", + " )\n", + " (2): Bottleneck(\n", + " (conv1): Conv2d(512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn1): FrozenBatchNorm2d(128, eps=0.0)\n", + " (conv2): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", + " (bn2): FrozenBatchNorm2d(128, eps=0.0)\n", + " (conv3): Conv2d(128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn3): FrozenBatchNorm2d(512, eps=0.0)\n", + " (relu): ReLU(inplace=True)\n", + " )\n", + " (3): Bottleneck(\n", + " (conv1): Conv2d(512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn1): FrozenBatchNorm2d(128, eps=0.0)\n", + " (conv2): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", + " (bn2): FrozenBatchNorm2d(128, eps=0.0)\n", + " (conv3): Conv2d(128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn3): FrozenBatchNorm2d(512, eps=0.0)\n", + " (relu): ReLU(inplace=True)\n", + " )\n", + " )\n", + " (layer3): Sequential(\n", + " (0): Bottleneck(\n", + " (conv1): Conv2d(512, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn1): FrozenBatchNorm2d(256, eps=0.0)\n", + " (conv2): Conv2d(256, 256, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), bias=False)\n", + " (bn2): FrozenBatchNorm2d(256, eps=0.0)\n", + " (conv3): Conv2d(256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn3): FrozenBatchNorm2d(1024, eps=0.0)\n", + " (relu): ReLU(inplace=True)\n", + " (downsample): Sequential(\n", + " (0): Conv2d(512, 1024, kernel_size=(1, 1), stride=(2, 2), bias=False)\n", + " (1): FrozenBatchNorm2d(1024, eps=0.0)\n", + " )\n", + " )\n", + " (1): Bottleneck(\n", + " (conv1): Conv2d(1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn1): FrozenBatchNorm2d(256, eps=0.0)\n", + " (conv2): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", + " (bn2): FrozenBatchNorm2d(256, eps=0.0)\n", + " (conv3): Conv2d(256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn3): FrozenBatchNorm2d(1024, eps=0.0)\n", + " (relu): ReLU(inplace=True)\n", + " )\n", + " (2): Bottleneck(\n", + " (conv1): Conv2d(1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn1): FrozenBatchNorm2d(256, eps=0.0)\n", + " (conv2): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", + " (bn2): FrozenBatchNorm2d(256, eps=0.0)\n", + " (conv3): Conv2d(256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn3): FrozenBatchNorm2d(1024, eps=0.0)\n", + " (relu): ReLU(inplace=True)\n", + " )\n", + " (3): Bottleneck(\n", + " (conv1): Conv2d(1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn1): FrozenBatchNorm2d(256, eps=0.0)\n", + " (conv2): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", + " (bn2): FrozenBatchNorm2d(256, eps=0.0)\n", + " (conv3): Conv2d(256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn3): FrozenBatchNorm2d(1024, eps=0.0)\n", + " (relu): ReLU(inplace=True)\n", + " )\n", + " (4): Bottleneck(\n", + " (conv1): Conv2d(1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn1): FrozenBatchNorm2d(256, eps=0.0)\n", + " (conv2): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", + " (bn2): FrozenBatchNorm2d(256, eps=0.0)\n", + " (conv3): Conv2d(256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn3): FrozenBatchNorm2d(1024, eps=0.0)\n", + " (relu): ReLU(inplace=True)\n", + " )\n", + " (5): Bottleneck(\n", + " (conv1): Conv2d(1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn1): FrozenBatchNorm2d(256, eps=0.0)\n", + " (conv2): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", + " (bn2): FrozenBatchNorm2d(256, eps=0.0)\n", + " (conv3): Conv2d(256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn3): FrozenBatchNorm2d(1024, eps=0.0)\n", + " (relu): ReLU(inplace=True)\n", + " )\n", + " )\n", + " (layer4): Sequential(\n", + " (0): Bottleneck(\n", + " (conv1): Conv2d(1024, 512, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn1): FrozenBatchNorm2d(512, eps=0.0)\n", + " (conv2): Conv2d(512, 512, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), bias=False)\n", + " (bn2): FrozenBatchNorm2d(512, eps=0.0)\n", + " (conv3): Conv2d(512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn3): FrozenBatchNorm2d(2048, eps=0.0)\n", + " (relu): ReLU(inplace=True)\n", + " (downsample): Sequential(\n", + " (0): Conv2d(1024, 2048, kernel_size=(1, 1), stride=(2, 2), bias=False)\n", + " (1): FrozenBatchNorm2d(2048, eps=0.0)\n", + " )\n", + " )\n", + " (1): Bottleneck(\n", + " (conv1): Conv2d(2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn1): FrozenBatchNorm2d(512, eps=0.0)\n", + " (conv2): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", + " (bn2): FrozenBatchNorm2d(512, eps=0.0)\n", + " (conv3): Conv2d(512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn3): FrozenBatchNorm2d(2048, eps=0.0)\n", + " (relu): ReLU(inplace=True)\n", + " )\n", + " (2): Bottleneck(\n", + " (conv1): Conv2d(2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn1): FrozenBatchNorm2d(512, eps=0.0)\n", + " (conv2): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n", + " (bn2): FrozenBatchNorm2d(512, eps=0.0)\n", + " (conv3): Conv2d(512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " (bn3): FrozenBatchNorm2d(2048, eps=0.0)\n", + " (relu): ReLU(inplace=True)\n", + " )\n", + " )\n", + " )\n", + " (fpn): FeaturePyramidNetwork(\n", + " (inner_blocks): ModuleList(\n", + " (0): Conv2dNormActivation(\n", + " (0): Conv2d(256, 256, kernel_size=(1, 1), stride=(1, 1))\n", + " )\n", + " (1): Conv2dNormActivation(\n", + " (0): Conv2d(512, 256, kernel_size=(1, 1), stride=(1, 1))\n", + " )\n", + " (2): Conv2dNormActivation(\n", + " (0): Conv2d(1024, 256, kernel_size=(1, 1), stride=(1, 1))\n", + " )\n", + " (3): Conv2dNormActivation(\n", + " (0): Conv2d(2048, 256, kernel_size=(1, 1), stride=(1, 1))\n", + " )\n", + " )\n", + " (layer_blocks): ModuleList(\n", + " (0-3): 4 x Conv2dNormActivation(\n", + " (0): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n", + " )\n", + " )\n", + " (extra_blocks): LastLevelMaxPool()\n", + " )\n", + " )\n", + " (rpn): RegionProposalNetwork(\n", + " (anchor_generator): AnchorGenerator()\n", + " (head): RPNHead(\n", + " (conv): Sequential(\n", + " (0): Conv2dNormActivation(\n", + " (0): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n", + " (1): ReLU(inplace=True)\n", + " )\n", + " )\n", + " (cls_logits): Conv2d(256, 3, kernel_size=(1, 1), stride=(1, 1))\n", + " (bbox_pred): Conv2d(256, 12, kernel_size=(1, 1), stride=(1, 1))\n", + " )\n", + " )\n", + " (roi_heads): RoIHeads(\n", + " (box_roi_pool): MultiScaleRoIAlign(featmap_names=['0', '1', '2', '3'], output_size=(7, 7), sampling_ratio=2)\n", + " (box_head): TwoMLPHead(\n", + " (fc6): Linear(in_features=12544, out_features=1024, bias=True)\n", + " (fc7): Linear(in_features=1024, out_features=1024, bias=True)\n", + " )\n", + " (box_predictor): FastRCNNPredictor(\n", + " (cls_score): Linear(in_features=1024, out_features=2, bias=True)\n", + " (bbox_pred): Linear(in_features=1024, out_features=8, bias=True)\n", + " )\n", + " )\n", + ")" + ] + }, + "metadata": {}, + "execution_count": 3 + } + ] + }, + { + "cell_type": "code", + "source": [ + "# Step 8: Define Optimizer\n", + "params = [p for p in model.parameters() if p.requires_grad]\n", + "optimizer = torch.optim.SGD(params, lr=0.005, momentum=0.9, weight_decay=0.0005)\n", + "\n", + "# Step 9: Train the Model\n", + "def train_one_epoch(model, optimizer, data_loader, device, epoch):\n", + " model.train()\n", + " for i, (images, targets) in enumerate(data_loader):\n", + " images = list(image.to(device) for image in images)\n", + " targets = [{k: v.to(device) for k, v in t.items()} for t in targets]\n", + "\n", + " loss_dict = model(images, targets)\n", + " losses = sum(loss for loss in loss_dict.values())\n", + "\n", + " optimizer.zero_grad()\n", + " losses.backward()\n", + " optimizer.step()\n", + "\n", + " if i % 10 == 0:\n", + " print(f\"Iteration {i}, Loss: {losses.item()}\")\n" + ], + "metadata": { + "id": "TdBu0CaqKETZ" + }, + "execution_count": 4, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "# Train for 10 epochs\n", + "num_epochs = 1\n", + "for epoch in range(num_epochs):\n", + " print(f\"Epoch {epoch+1}/{num_epochs}\")\n", + " train_one_epoch(model, optimizer, train_loader, device, epoch)\n" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "gRQVGaXyKKfg", + "outputId": "db8a891a-8e01-48ee-d9aa-5dcd5dd2d574" + }, + "execution_count": 5, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Epoch 1/1\n", + "Iteration 0, Loss: 0.7363923788070679\n", + "Iteration 10, Loss: 0.1587277054786682\n", + "Iteration 20, Loss: 0.16397720575332642\n", + "Iteration 30, Loss: 0.15436731278896332\n", + "Iteration 40, Loss: 0.18009600043296814\n", + "Iteration 50, Loss: 0.23029766976833344\n", + "Iteration 60, Loss: 0.20594128966331482\n", + "Iteration 70, Loss: 0.19515010714530945\n", + "Iteration 80, Loss: 0.19444917142391205\n", + "Iteration 90, Loss: 0.14671386778354645\n", + "Iteration 100, Loss: 0.2077881097793579\n", + "Iteration 110, Loss: 0.20448961853981018\n", + "Iteration 120, Loss: 0.29605674743652344\n", + "Iteration 130, Loss: 0.1862543523311615\n", + "Iteration 140, Loss: 0.2156934291124344\n", + "Iteration 150, Loss: 0.29083454608917236\n", + "Iteration 160, Loss: 0.23125450313091278\n" + ] + } + ] + }, + { + "cell_type": "code", + "source": [ + "# Step 10: Save the Trained Model\n", + "model_save_path = \"/content/gun_detection_model_30epoch.pth\"\n", + "torch.save(model.state_dict(), model_save_path)\n", + "print(f\"Model saved to {model_save_path}\")" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "rpEs3TUgm8Jp", + "outputId": "32d89540-6fcd-48c0-c29d-fd296bd6dc37" + }, + "execution_count": 6, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Model saved to /content/gun_detection_model_30epoch.pth\n" + ] + } + ] + }, + { + "cell_type": "code", + "source": [ + "# Step 11: Evaluate the Model\n", + "def evaluate_model(model, data_loader, device, iou_threshold=0.5, score_threshold=0.5):\n", + " model.eval()\n", + " all_preds = []\n", + " all_labels = []\n", + "\n", + " with torch.no_grad():\n", + " for images, targets in data_loader:\n", + " images = list(image.to(device) for image in images)\n", + " outputs = model(images)\n", + "\n", + " for output, target in zip(outputs, targets):\n", + " # Ground truth labels and boxes\n", + " gt_boxes = target['boxes'].cpu().numpy()\n", + " gt_labels = target['labels'].cpu().numpy()\n", + "\n", + " # Predicted labels, boxes, and scores\n", + " pred_boxes = output['boxes'].cpu().numpy()\n", + " pred_labels = output['labels'].cpu().numpy()\n", + " pred_scores = output['scores'].cpu().numpy()\n", + "\n", + " # Filter predictions by confidence threshold\n", + " valid_preds = pred_scores > score_threshold\n", + " pred_boxes = pred_boxes[valid_preds]\n", + " pred_labels = pred_labels[valid_preds]\n", + "\n", + " # Match predictions to ground truth using IoU\n", + " matched_gt_indices = set() # To track matched ground truth boxes\n", + " for pred_box, pred_label in zip(pred_boxes, pred_labels):\n", + " best_iou = 0\n", + " best_gt_idx = -1\n", + "\n", + " # Compute IoU between the predicted box and all ground truth boxes\n", + " for gt_idx, gt_box in enumerate(gt_boxes):\n", + " iou = compute_iou(pred_box, gt_box)\n", + " if iou > best_iou:\n", + " best_iou = iou\n", + " best_gt_idx = gt_idx\n", + "\n", + " # If the best IoU exceeds the threshold, consider it a match\n", + " if best_iou >= iou_threshold and best_gt_idx not in matched_gt_indices:\n", + " all_preds.append(pred_label) # Predicted label\n", + " all_labels.append(gt_labels[best_gt_idx]) # Ground truth label\n", + " matched_gt_indices.add(best_gt_idx)\n", + " else:\n", + " # Unmatched prediction (treated as Background)\n", + " all_preds.append(0) # Background label\n", + " all_labels.append(0) # Background label\n", + "\n", + " # Add unmatched ground truth boxes as false negatives\n", + " for gt_idx, gt_label in enumerate(gt_labels):\n", + " if gt_idx not in matched_gt_indices:\n", + " all_preds.append(0) # Background label\n", + " all_labels.append(gt_label) # Ground truth label\n", + "\n", + " print(\"\\nClassification Report:\")\n", + " from sklearn.metrics import classification_report\n", + " print(classification_report(all_labels, all_preds, target_names=['Background', 'Gun']))\n", + "\n", + "# Helper function to compute IoU\n", + "def compute_iou(box1, box2):\n", + " \"\"\"\n", + " Compute Intersection over Union (IoU) between two bounding boxes.\n", + " Each box is represented as [xmin, ymin, xmax, ymax].\n", + " \"\"\"\n", + " # Compute coordinates of intersection rectangle\n", + " xmin = max(box1[0], box2[0])\n", + " ymin = max(box1[1], box2[1])\n", + " xmax = min(box1[2], box2[2])\n", + " ymax = min(box1[3], box2[3])\n", + "\n", + " # Compute area of intersection\n", + " inter_width = max(0, xmax - xmin)\n", + " inter_height = max(0, ymax - ymin)\n", + " inter_area = inter_width * inter_height\n", + "\n", + " # Compute area of both boxes\n", + " box1_area = (box1[2] - box1[0]) * (box1[3] - box1[1])\n", + " box2_area = (box2[2] - box2[0]) * (box2[3] - box2[1])\n", + "\n", + " # Compute IoU\n", + " iou = inter_area / (box1_area + box2_area - inter_area)\n", + " return iou\n", + "\n", + "evaluate_model(model, test_loader, device)" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "pvBjmmdKplFA", + "outputId": "7d6bc226-64f1-4c2e-f933-9499d9d1a852" + }, + "execution_count": 7, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "\n", + "Classification Report:\n", + " precision recall f1-score support\n", + "\n", + " Background 0.60 1.00 0.75 142\n", + " Gun 1.00 0.78 0.88 428\n", + "\n", + " accuracy 0.83 570\n", + " macro avg 0.80 0.89 0.81 570\n", + "weighted avg 0.90 0.83 0.84 570\n", + "\n" + ] + } + ] + }, + { + "cell_type": "code", + "source": [ + "# Step 12: Download Pre-trained Model from Dropbox with high accuracy I trained with 1 hour\n", + "dropbox_model_url = \"https://www.dropbox.com/scl/fi/prwobzaj9i7ks1qirvs4u/gun_detection_model_30epoch.pth?rlkey=bdqqc7m6hxnzaapxo5hm8z1pm&st=m0cpspeb&dl=1\"\n", + "local_model_path = \"/content/gun_detection_model_30epoch.pth\"\n", + "\n", + "if not os.path.exists(local_model_path):\n", + " print(\"Downloading pre-trained model from Dropbox...\")\n", + " response = requests.get(dropbox_model_url, stream=True)\n", + " with open(local_model_path, 'wb') as f:\n", + " for chunk in response.iter_content(chunk_size=1024):\n", + " if chunk:\n", + " f.write(chunk)\n", + " print(f\"Model downloaded to {local_model_path}\")\n", + "else:\n", + " print(f\"Pre-trained model already exists at {local_model_path}\")" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "kMIx8GNBzR3p", + "outputId": "db50edba-e88b-4ec8-a01a-9114b6d007eb" + }, + "execution_count": 8, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Pre-trained model already exists at /content/gun_detection_model_30epoch.pth\n" + ] + } + ] + }, + { + "cell_type": "code", + "source": [ + "# Step 13: Load Pre-trained Model\n", + "def load_model(model_path):\n", + " # Load the pre-trained Faster R-CNN model\n", + " model = torchvision.models.detection.fasterrcnn_resnet50_fpn(pretrained=False)\n", + " num_classes = 2 # Background + Gun\n", + " in_features = model.roi_heads.box_predictor.cls_score.in_features\n", + " model.roi_heads.box_predictor = FastRCNNPredictor(in_features, num_classes)\n", + "\n", + " # Load the saved state dictionary\n", + " model.load_state_dict(torch.load(model_path, map_location=torch.device('cpu')))\n", + " model.eval()\n", + " return model\n", + "\n", + "# Step 14: Test on Custom Images Using Saved Model\n", + "def predict_image(img_path, model, transform):\n", + " img = Image.open(img_path).convert(\"RGB\")\n", + " img_tensor = transform(img).unsqueeze(0)\n", + "\n", + " with torch.no_grad():\n", + " prediction = model(img_tensor)[0]\n", + "\n", + " # Plot the image with bounding boxes\n", + " plt.figure(figsize=(10, 10))\n", + " plt.imshow(img)\n", + " for box, label, score in zip(prediction['boxes'], prediction['labels'], prediction['scores']):\n", + " if label == 1 and score > 0.5: # Gun detected with confidence > 0.5\n", + " box = box.cpu().numpy()\n", + " plt.gca().add_patch(plt.Rectangle((box[0], box[1]), box[2]-box[0], box[3]-box[1],\n", + " edgecolor='red', facecolor='none', linewidth=2))\n", + " plt.axis('off')\n", + " plt.show()\n", + "\n", + "# Example Usage for Testing\n", + "custom_image_path = '/content/dataset/Images/3.jpeg' # Update this path\n", + "\n", + "# Load the pre-trained model\n", + "model = load_model(local_model_path)\n", + "\n", + "# Predict on a custom image\n", + "predict_image(custom_image_path, model, get_transform(train=False))" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 402 + }, + "id": "kjPnTObBZDeM", + "outputId": "464d087d-1ab9-427b-ab0f-628ae44f96d6" + }, + "execution_count": 11, + "outputs": [ + { + "output_type": "stream", + "name": "stderr", + "text": [ + ":10: FutureWarning: You are using `torch.load` with `weights_only=False` (the current default value), which uses the default pickle module implicitly. It is possible to construct malicious pickle data which will execute arbitrary code during unpickling (See https://github.com/pytorch/pytorch/blob/main/SECURITY.md#untrusted-models for more details). In a future release, the default value for `weights_only` will be flipped to `True`. This limits the functions that could be executed during unpickling. Arbitrary objects will no longer be allowed to be loaded via this mode unless they are explicitly allowlisted by the user via `torch.serialization.add_safe_globals`. We recommend you start setting `weights_only=True` for any use case where you don't have full control of the loaded file. Please open an issue on GitHub for any issues related to this experimental feature.\n", + " model.load_state_dict(torch.load(model_path, map_location=torch.device('cpu')))\n" + ] + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": {} + } + ] + }, + { + "cell_type": "code", + "source": [], + "metadata": { + "id": "ww_qyzkKqnsn" + }, + "execution_count": 9, + "outputs": [] + } + ] +} \ No newline at end of file