diff --git a/Volleyball Detection with Deep Learning/README.md b/Volleyball Detection with Deep Learning/README.md
new file mode 100644
index 000000000..91a7919ee
--- /dev/null
+++ b/Volleyball Detection with Deep Learning/README.md	
@@ -0,0 +1,53 @@
+# Volleyball Tracking & Object Detection Benchmark
+
+## Project Goal
+The primary objective of this project is to build, train, and benchmark multiple object detection architectures to determine the optimal algorithm for tracking a fast-moving, small object (a volleyball) in video footage. The project compares single-stage and two-stage detectors, evaluating them on a strict matrix of **Accuracy (mAP)** and **Inference Speed (FPS)** to find the best fit for real-world sports analytics.
+
+## Dataset
+* **Source:** https://www.kaggle.com/datasets/pythonistasamurai/volleyball-ball-object-detection-dataset
+* **Format:** The dataset was originally annotated in YOLO format (normalized `x_center, y_center, width, height`).
+* **Processing:** For the PyTorch-native models, a custom PyTorch `Dataset` class was engineered to dynamically parse YOLO `.txt` files and convert them into Pascal VOC absolute coordinates (`xmin, ymin, xmax, ymax`) on the fly during the training loop.
+
+## Models Evaluated
+1. **YOLOv8 (Nano & Medium):** State-of-the-art single-stage detector.
+2. **Faster R-CNN (ResNet50 FPN):** Heavyweight, highly accurate two-stage detector.
+3. **SSD300 (VGG16):** Single Shot MultiBox Detector bridging the gap between speed and architectural complexity.
+4. **RetinaNet (ResNet50 FPN):** Single-stage detector utilizing **Focal Loss** to handle extreme foreground-background class imbalance (critical for finding a small ball on a large court).
+
+## Libraries & Tech Stack
+* **Deep Learning:** `PyTorch`, `Torchvision`, `Ultralytics`
+* **Computer Vision:** `OpenCV (cv2)`
+* **Metrics & Math:** `Torchmetrics`, `NumPy`
+* **Visualization:** `Matplotlib`
+* **Environment:** Google Colab (T4 GPU for Training), VS Code (Local Inference)
+
+## Methodology & Approach
+1. **Baseline Establishment:** Trained YOLOv8 Nano to establish a fast but easily confused baseline. Scaled up to YOLOv8 Medium to solve motion blur and tracking inconsistencies.
+2. **Custom Data Pipeline:** Engineered a PyTorch DataLoader to bridge YOLO text annotations into tensor dictionaries required by `torchvision` models.
+3. **Model Head Modification:** Loaded pre-trained backbones (ResNet50/VGG16) and manually modified the prediction heads to output exactly 2 classes: `Background (0)` and `Volleyball (1)`.
+4. **Training Stability:** Implemented **Gradient Clipping** (`max_norm=1.0`) and reduced learning rates (`0.0005`) to prevent exploding gradients (`NaN` loss) during the highly volatile early epochs of SSD and RetinaNet training.
+5. **Evaluation Engine:** Wrote a custom local Python script (`benchmark.py`) using OpenCV to run exactly 100 frames of a test video through all four architectures back-to-back to calculate true inference speed (FPS). Utilized `torchmetrics` to calculate Mean Average Precision (mAP) for the PyTorch models.
+
+## Results: Accuracy & Speed Benchmark
+
+| Algorithm | Architecture Type | Final Validation Loss | Accuracy (mAP@50) | Speed (Inference FPS) |
+| :--- | :--- | :--- | :--- | :--- |
+| **YOLOv8 Medium** | Single-Stage | 0.934 | **99.2%** | **4.68 FPS** |
+| **SSD300** | Single-Stage | 1.6742 | **41.12%** | **2.86 FPS** |
+| **RetinaNet** | Single-Stage (Focal Loss) | 0.2662 | **92.63%** | **0.51 FPS** |
+| **Faster R-CNN** | Two-Stage | 0.0070 | **96.04%** | **0.16 FPS** |
+
+*(Note: FPS benchmarks were conducted on CPU using OpenCV.)*
+
+## Key Observations
+* **YOLOv8:** Smaller models (like YOLOv8 Nano) aggressively lost tracking confidence when the ball moved rapidly due to motion blur. Scaling the parameters up (Medium/ResNet50) allowed the models to recognize the shape of a blurred object.
+* **SSD:** SSD proved highly unstable in early training epochs compared to Faster R-CNN. Implementing gradient clipping was mandatory to prevent the loss from hitting infinity (`NaN`).
+* **RetinaNet:** Because a volleyball takes up <1% of the pixels in an image, standard models spend too much time learning the background. RetinaNet's focal loss mathematically forced the network to focus on the "hard" examples (the ball), making it highly efficient at small object detection.
+* **Faster R-CNN:** Faster R-CNN provided highly accurate and tight bounding boxes, but its Region Proposal Network makes it far too slow for real-time video processing compared to single-stage architectures.
+
+## Conclusion
+For real-time sports analytics, **YOLOv8 Medium** proved to be the best-fitted algorithm for this model. It successfully tracked the ball through motion blur and net occlusion while maintaining a high enough FPS to process live video. While architectures like Faster R-CNN and RetinaNet offer incredible accuracy and robust theoretical approaches (like Focal Loss), their heavier computational load makes them better suited for static image analysis rather than high-speed video tracking.
+
+**Ashwast Gupta**
+* **LinkedIn:** //https://www.linkedin.com/in/ashwast-gupta/
+* **GitHub:** https://github.com/ash-heinz
\ No newline at end of file
diff --git a/Volleyball Detection with Deep Learning/dataset/README.md b/Volleyball Detection with Deep Learning/dataset/README.md
new file mode 100644
index 000000000..fdcb89c14
--- /dev/null
+++ b/Volleyball Detection with Deep Learning/dataset/README.md	
@@ -0,0 +1,2 @@
+## Dataset
+**Source:** https://www.kaggle.com/datasets/pythonistasamurai/volleyball-ball-object-detection-dataset
\ No newline at end of file
diff --git a/Volleyball Detection with Deep Learning/images/faster_rcnn_metrics.png b/Volleyball Detection with Deep Learning/images/faster_rcnn_metrics.png
new file mode 100644
index 000000000..3bb914e03
Binary files /dev/null and b/Volleyball Detection with Deep Learning/images/faster_rcnn_metrics.png differ
diff --git a/Volleyball Detection with Deep Learning/images/retinanet_metrics.png b/Volleyball Detection with Deep Learning/images/retinanet_metrics.png
new file mode 100644
index 000000000..ff0086977
Binary files /dev/null and b/Volleyball Detection with Deep Learning/images/retinanet_metrics.png differ
diff --git a/Volleyball Detection with Deep Learning/images/ssd_metrics.png b/Volleyball Detection with Deep Learning/images/ssd_metrics.png
new file mode 100644
index 000000000..10cb205cb
Binary files /dev/null and b/Volleyball Detection with Deep Learning/images/ssd_metrics.png differ
diff --git a/Volleyball Detection with Deep Learning/images/yolov8_metrics.png b/Volleyball Detection with Deep Learning/images/yolov8_metrics.png
new file mode 100644
index 000000000..50c2616bf
Binary files /dev/null and b/Volleyball Detection with Deep Learning/images/yolov8_metrics.png differ
diff --git a/Volleyball Detection with Deep Learning/model/README.md b/Volleyball Detection with Deep Learning/model/README.md
new file mode 100644
index 000000000..0ee870ade
--- /dev/null
+++ b/Volleyball Detection with Deep Learning/model/README.md	
@@ -0,0 +1,2 @@
+due to github limits on file sizes, all the trained models have also been uploaded on the following google drive link:
+https://drive.google.com/drive/folders/1XkFLB1MFFx5ZEhCOhEtiEWxBwewM4Mme?usp=sharing
\ No newline at end of file
diff --git a/Volleyball Detection with Deep Learning/model/ssd_volleyball.pth b/Volleyball Detection with Deep Learning/model/ssd_volleyball.pth
new file mode 100644
index 000000000..e311b0169
Binary files /dev/null and b/Volleyball Detection with Deep Learning/model/ssd_volleyball.pth differ
diff --git a/Volleyball Detection with Deep Learning/model/volleyball_detection_with_deep_learning.ipynb b/Volleyball Detection with Deep Learning/model/volleyball_detection_with_deep_learning.ipynb
new file mode 100644
index 000000000..bd2db91b2
--- /dev/null
+++ b/Volleyball Detection with Deep Learning/model/volleyball_detection_with_deep_learning.ipynb	
@@ -0,0 +1,913 @@
+{
+  "cells": [
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "## Unzipping the dataset"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 1,
+      "metadata": {
+        "id": "FdEHr_v9MEAc"
+      },
+      "outputs": [],
+      "source": [
+        "!unzip -q volleyball_data.zip"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "## Format YOLO Labels\n",
+        "Custom Dataset to load images and labels.\n",
+        "Converts YOLO format labels (normalized center x,y, w, h) into absolute bounding box coordinates [xmin, ymin, xmax, ymax] as required by PyTorch object detection models."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "03cWZFhBME4B",
+        "outputId": "d23a55d2-0ca3-4379-c24f-cd9e05c9c8b7"
+      },
+      "outputs": [
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "Loaded 521 training images and 27 validation images.\n"
+          ]
+        }
+      ],
+      "source": [
+        "import os\n",
+        "import torch\n",
+        "import cv2\n",
+        "import numpy as np\n",
+        "from torch.utils.data import Dataset, DataLoader\n",
+        "import torchvision\n",
+        "from torchvision.transforms import functional as F\n",
+        "\n",
+        "class VolleyballDataset(Dataset):\n",
+        "    def __init__(self, images_dir, labels_dir):\n",
+        "        self.images_dir = images_dir\n",
+        "        self.labels_dir = labels_dir\n",
+        "        self.image_names = [f for f in os.listdir(images_dir) if f.endswith(('.jpg', '.png'))]\n",
+        "\n",
+        "    def __len__(self):\n",
+        "        return len(self.image_names)\n",
+        "\n",
+        "    def __getitem__(self, idx):\n",
+        "        img_name = self.image_names[idx]\n",
+        "        img_path = os.path.join(self.images_dir, img_name)\n",
+        "        image = cv2.imread(img_path)\n",
+        "        image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)\n",
+        "        height, width, _ = image.shape\n",
+        "\n",
+        "        image_tensor = F.to_tensor(image)\n",
+        "\n",
+        "        label_name = img_name.replace('.jpg', '.txt').replace('.png', '.txt')\n",
+        "        label_path = os.path.join(self.labels_dir, label_name)\n",
+        "\n",
+        "        boxes = []\n",
+        "        labels = []\n",
+        "\n",
+        "        if os.path.exists(label_path):\n",
+        "            with open(label_path, 'r') as f:\n",
+        "                for line in f.readlines():\n",
+        "                    class_id, x_center, y_center, w, h = map(float, line.strip().split())\n",
+        "\n",
+        "                    xmin = (x_center - w / 2) * width\n",
+        "                    ymin = (y_center - h / 2) * height\n",
+        "                    xmax = (x_center + w / 2) * width\n",
+        "                    ymax = (y_center + h / 2) * height\n",
+        "\n",
+        "                    boxes.append([xmin, ymin, xmax, ymax])\n",
+        "                    labels.append(1)\n",
+        "\n",
+        "        boxes = torch.as_tensor(boxes, dtype=torch.float32)\n",
+        "        labels = torch.as_tensor(labels, dtype=torch.int64)\n",
+        "\n",
+        "        if len(boxes) == 0:\n",
+        "            boxes = torch.zeros((0, 4), dtype=torch.float32)\n",
+        "\n",
+        "        target = {}\n",
+        "        target[\"boxes\"] = boxes\n",
+        "        target[\"labels\"] = labels\n",
+        "        target[\"image_id\"] = torch.tensor([idx])\n",
+        "\n",
+        "        return image_tensor, target\n",
+        "\n",
+        "def collate_fn(batch):\n",
+        "    return tuple(zip(*batch))\n",
+        "\n",
+        "train_dataset = VolleyballDataset(images_dir='data/train/images', labels_dir='data/train/labels')\n",
+        "val_dataset = VolleyballDataset(images_dir='data/valid/images', labels_dir='data/valid/labels')\n",
+        "\n",
+        "train_loader = DataLoader(train_dataset, batch_size=4, shuffle=True, collate_fn=collate_fn)\n",
+        "val_loader = DataLoader(val_dataset, batch_size=4, shuffle=False, collate_fn=collate_fn)\n",
+        "\n",
+        "print(f\"Loaded {len(train_dataset)} training images and {len(val_dataset)} validation images.\")\n"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "## Metrics\n",
+        "Calculates mAP@50 for the given model and validation loader"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "Ph2VzmmuMGYs",
+        "outputId": "a4156a51-d67b-4d65-ca15-be1b2b397c97"
+      },
+      "outputs": [
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "\u001b[?25l   \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m0.0/983.4 kB\u001b[0m \u001b[31m?\u001b[0m eta \u001b[36m-:--:--\u001b[0m\r\u001b[2K   \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m983.4/983.4 kB\u001b[0m \u001b[31m61.7 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
+            "\u001b[?25h"
+          ]
+        }
+      ],
+      "source": [
+        "%pip install torchmetrics -q\n",
+        "\n",
+        "import torch\n",
+        "from torchmetrics.detection.mean_ap import MeanAveragePrecision\n",
+        "\n",
+        "def evaluate_model(model, val_loader, device):\n",
+        "    \"\"\"Calculates mAP@50 for the given model and validation loader.\"\"\"\n",
+        "    model.eval()\n",
+        "    metric = MeanAveragePrecision(iou_type=\"bbox\")\n",
+        "\n",
+        "    with torch.no_grad():\n",
+        "        for images, targets in val_loader:\n",
+        "            images = list(image.to(device) for image in images)\n",
+        "\n",
+        "            formatted_targets = [{\"boxes\": t[\"boxes\"].to(device), \"labels\": t[\"labels\"].to(device)} for t in targets]\n",
+        "\n",
+        "            predictions = model(images)\n",
+        "\n",
+        "            formatted_preds = [{\"boxes\": p[\"boxes\"].to(device), \"scores\": p[\"scores\"].to(device), \"labels\": p[\"labels\"].to(device)} for p in predictions]\n",
+        "\n",
+        "            metric.update(formatted_preds, formatted_targets)\n",
+        "\n",
+        "    result = metric.compute()\n",
+        "    return result['map_50'].item() * 100 # Return as percentage"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "## Faster RCNN"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 11,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "u54MKiwSMKEb",
+        "outputId": "984290eb-ec06-4afa-bead-cd065bd23b9c"
+      },
+      "outputs": [
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "Model loaded and moved to: cuda\n"
+          ]
+        }
+      ],
+      "source": [
+        "import torchvision\n",
+        "from torchvision.models.detection.faster_rcnn import FastRCNNPredictor\n",
+        "import torch\n",
+        "\n",
+        "def get_model(num_classes):\n",
+        "    model = torchvision.models.detection.fasterrcnn_resnet50_fpn(weights=\"DEFAULT\")\n",
+        "\n",
+        "    in_features = model.roi_heads.box_predictor.cls_score.in_features\n",
+        "\n",
+        "    model.roi_heads.box_predictor = FastRCNNPredictor(in_features, num_classes)\n",
+        "\n",
+        "    return model\n",
+        "\n",
+        "model = get_model(num_classes=2)\n",
+        "\n",
+        "device = torch.device('cuda') if torch.cuda.is_available() else torch.device('cpu')\n",
+        "model.to(device)\n",
+        "\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",
+        "print(f\"Model loaded and moved to: {device}\")"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "6Y0qilITMKrh",
+        "outputId": "6cf893bb-9bee-4bc5-87cf-c8c9ceb4b5b9"
+      },
+      "outputs": [
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "Starting Faster R-CNN training...\n",
+            "Epoch 1/50 | Average Loss: 0.1428 | Val mAP@50: 96.04%\n",
+            "Epoch 2/50 | Average Loss: 0.0635 | Val mAP@50: 96.04%\n",
+            "Epoch 3/50 | Average Loss: 0.0503 | Val mAP@50: 96.04%\n",
+            "Epoch 4/50 | Average Loss: 0.0425 | Val mAP@50: 96.04%\n",
+            "Epoch 5/50 | Average Loss: 0.0372 | Val mAP@50: 96.04%\n",
+            "Epoch 6/50 | Average Loss: 0.0338 | Val mAP@50: 96.04%\n",
+            "Epoch 7/50 | Average Loss: 0.0306 | Val mAP@50: 96.04%\n",
+            "Epoch 8/50 | Average Loss: 0.0274 | Val mAP@50: 96.04%\n",
+            "Epoch 9/50 | Average Loss: 0.0262 | Val mAP@50: 96.04%\n",
+            "Epoch 10/50 | Average Loss: 0.0237 | Val mAP@50: 96.04%\n",
+            "Epoch 11/50 | Average Loss: 0.0223 | Val mAP@50: 96.04%\n",
+            "Epoch 12/50 | Average Loss: 0.0217 | Val mAP@50: 96.04%\n",
+            "Epoch 13/50 | Average Loss: 0.0198 | Val mAP@50: 96.04%\n",
+            "Epoch 14/50 | Average Loss: 0.0183 | Val mAP@50: 96.04%\n",
+            "Epoch 15/50 | Average Loss: 0.0184 | Val mAP@50: 96.04%\n",
+            "Epoch 16/50 | Average Loss: 0.0179 | Val mAP@50: 96.04%\n",
+            "Epoch 17/50 | Average Loss: 0.0156 | Val mAP@50: 96.04%\n",
+            "Epoch 18/50 | Average Loss: 0.0155 | Val mAP@50: 96.04%\n",
+            "Epoch 19/50 | Average Loss: 0.0146 | Val mAP@50: 96.04%\n",
+            "Epoch 20/50 | Average Loss: 0.0143 | Val mAP@50: 96.04%\n",
+            "Epoch 21/50 | Average Loss: 0.0140 | Val mAP@50: 96.04%\n",
+            "Epoch 22/50 | Average Loss: 0.0130 | Val mAP@50: 96.04%\n",
+            "Epoch 23/50 | Average Loss: 0.0136 | Val mAP@50: 96.04%\n",
+            "Epoch 24/50 | Average Loss: 0.0127 | Val mAP@50: 96.04%\n",
+            "Epoch 25/50 | Average Loss: 0.0127 | Val mAP@50: 96.04%\n",
+            "Epoch 26/50 | Average Loss: 0.0121 | Val mAP@50: 96.04%\n",
+            "Epoch 27/50 | Average Loss: 0.0110 | Val mAP@50: 96.04%\n",
+            "Epoch 28/50 | Average Loss: 0.0103 | Val mAP@50: 96.04%\n",
+            "Epoch 29/50 | Average Loss: 0.0105 | Val mAP@50: 96.04%\n",
+            "Epoch 30/50 | Average Loss: 0.0099 | Val mAP@50: 96.04%\n",
+            "Epoch 31/50 | Average Loss: 0.0108 | Val mAP@50: 96.04%\n",
+            "Epoch 32/50 | Average Loss: 0.0108 | Val mAP@50: 96.04%\n",
+            "Epoch 33/50 | Average Loss: 0.0107 | Val mAP@50: 96.04%\n",
+            "Epoch 34/50 | Average Loss: 0.0091 | Val mAP@50: 96.04%\n",
+            "Epoch 35/50 | Average Loss: 0.0092 | Val mAP@50: 96.04%\n",
+            "Epoch 36/50 | Average Loss: 0.0089 | Val mAP@50: 96.04%\n",
+            "Epoch 37/50 | Average Loss: 0.0086 | Val mAP@50: 96.04%\n",
+            "Epoch 38/50 | Average Loss: 0.0083 | Val mAP@50: 96.04%\n",
+            "Epoch 39/50 | Average Loss: 0.0078 | Val mAP@50: 96.04%\n",
+            "Epoch 40/50 | Average Loss: 0.0078 | Val mAP@50: 96.04%\n",
+            "Epoch 41/50 | Average Loss: 0.0079 | Val mAP@50: 96.04%\n",
+            "Epoch 42/50 | Average Loss: 0.0078 | Val mAP@50: 96.04%\n",
+            "Epoch 43/50 | Average Loss: 0.0075 | Val mAP@50: 96.04%\n",
+            "Epoch 44/50 | Average Loss: 0.0076 | Val mAP@50: 96.04%\n",
+            "Epoch 45/50 | Average Loss: 0.0078 | Val mAP@50: 96.04%\n",
+            "Epoch 46/50 | Average Loss: 0.0084 | Val mAP@50: 96.04%\n",
+            "Epoch 47/50 | Average Loss: 0.0074 | Val mAP@50: 96.04%\n",
+            "Epoch 48/50 | Average Loss: 0.0081 | Val mAP@50: 96.04%\n",
+            "Epoch 49/50 | Average Loss: 0.0077 | Val mAP@50: 96.04%\n",
+            "Epoch 50/50 | Average Loss: 0.0070 | Val mAP@50: 96.04%\n",
+            "Initial training complete!\n"
+          ]
+        }
+      ],
+      "source": [
+        "num_epochs = 50\n",
+        "loss_history_rcnn = []\n",
+        "map_history_rcnn = []\n",
+        "\n",
+        "print(\"Starting Faster R-CNN training...\")\n",
+        "\n",
+        "for epoch in range(num_epochs):\n",
+        "    model.train()\n",
+        "    epoch_loss = 0\n",
+        "\n",
+        "    for images, targets in train_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",
+        "        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",
+        "        epoch_loss += losses.item()\n",
+        "\n",
+        "    average_loss = epoch_loss / len(train_loader)\n",
+        "    loss_history_rcnn.append(average_loss)\n",
+        "\n",
+        "    map_50 = evaluate_model(model, val_loader, device)\n",
+        "    map_history_rcnn.append(map_50)\n",
+        "\n",
+        "    print(f\"Epoch {epoch+1}/{num_epochs} | Average Loss: {average_loss:.4f} | Val mAP@50: {map_50:.2f}%\")\n",
+        "\n",
+        "print(\"Initial training complete!\")"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 13,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "KZw6cXA4MOZ2",
+        "outputId": "beb734de-c705-4e73-9e1d-cc0d77220656"
+      },
+      "outputs": [
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "Model weights successfully saved to faster_rcnn_volleyball.pth\n"
+          ]
+        }
+      ],
+      "source": [
+        "import torch\n",
+        "\n",
+        "save_path = 'faster_rcnn_volleyball.pth'\n",
+        "\n",
+        "torch.save(model.state_dict(), save_path)\n",
+        "\n",
+        "print(f\"Model weights successfully saved to {save_path}\")"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 607
+        },
+        "id": "1t6EKJgkMQcv",
+        "outputId": "58bf9fd5-b331-4f4b-b2af-f1f6f22ea8ce"
+      },
+      "outputs": [
+        {
+          "data": {
+            "image/png": "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",
+            "text/plain": [
+              "<Figure size 1000x600 with 2 Axes>"
+            ]
+          },
+          "metadata": {},
+          "output_type": "display_data"
+        }
+      ],
+      "source": [
+        "import matplotlib.pyplot as plt\n",
+        "\n",
+        "epochs = list(range(1, len(loss_history_rcnn) + 1))\n",
+        "fig, ax1 = plt.subplots(figsize=(10, 6))\n",
+        "\n",
+        "color = 'tab:blue'\n",
+        "ax1.set_xlabel('Epoch', fontsize=12)\n",
+        "ax1.set_ylabel('Average Loss', color=color, fontsize=12)\n",
+        "ax1.plot(epochs, loss_history_rcnn, marker='o', linestyle='-', color=color, label='Training Loss')\n",
+        "ax1.tick_params(axis='y', labelcolor=color)\n",
+        "ax1.grid(True, linestyle='--', alpha=0.7)\n",
+        "\n",
+        "ax2 = ax1.twinx()\n",
+        "color = 'tab:orange'\n",
+        "ax2.set_ylabel('mAP@50 (%)', color=color, fontsize=12)\n",
+        "ax2.plot(epochs, map_history_rcnn, marker='s', linestyle='-', color=color, label='Validation mAP@50')\n",
+        "ax2.tick_params(axis='y', labelcolor=color)\n",
+        "\n",
+        "plt.title('Faster R-CNN Training Loss & Validation Accuracy', fontsize=16, fontweight='bold')\n",
+        "fig.tight_layout()\n",
+        "plt.savefig('faster_rcnn_loss_map_curve.png', dpi=300, bbox_inches='tight')\n",
+        "plt.show()"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "## SSD 300"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "3RwpiNDJMRh9",
+        "outputId": "bda5457d-aad6-4abb-82a6-f6297ede1706"
+      },
+      "outputs": [
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "Loading fresh SSD300 Architecture...\n",
+            "Fresh SSD Model loaded and ready!\n"
+          ]
+        }
+      ],
+      "source": [
+        "import torchvision\n",
+        "import torch\n",
+        "\n",
+        "print(\"Loading fresh SSD300 Architecture...\")\n",
+        "\n",
+        "ssd_model = torchvision.models.detection.ssd300_vgg16(weights_backbone='DEFAULT', num_classes=2)\n",
+        "device = torch.device('cuda') if torch.cuda.is_available() else torch.device('cpu')\n",
+        "ssd_model.to(device)\n",
+        "\n",
+        "params = [p for p in ssd_model.parameters() if p.requires_grad]\n",
+        "optimizer = torch.optim.SGD(params, lr=0.0005, momentum=0.9, weight_decay=0.0005)\n",
+        "\n",
+        "print(\"Fresh SSD Model loaded and ready!\")"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "wD6Gw8qUMUcs",
+        "outputId": "1625b4aa-ed99-44e7-f619-addce769da76"
+      },
+      "outputs": [
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "Starting SSD training (with Gradient Clipping)...\n",
+            "Epoch 1/50 | Average Loss: 43.7998 | Val mAP@50: 0.00%\n",
+            "Epoch 2/50 | Average Loss: 15.2475 | Val mAP@50: 0.00%\n",
+            "Epoch 3/50 | Average Loss: 7.0322 | Val mAP@50: 0.02%\n",
+            "Epoch 4/50 | Average Loss: 5.1990 | Val mAP@50: 0.09%\n",
+            "Epoch 5/50 | Average Loss: 4.8865 | Val mAP@50: 0.30%\n",
+            "Epoch 6/50 | Average Loss: 4.7599 | Val mAP@50: 0.31%\n",
+            "Epoch 7/50 | Average Loss: 4.6417 | Val mAP@50: 0.03%\n",
+            "Epoch 8/50 | Average Loss: 4.5546 | Val mAP@50: 0.40%\n",
+            "Epoch 9/50 | Average Loss: 4.4740 | Val mAP@50: 0.86%\n",
+            "Epoch 10/50 | Average Loss: 4.4065 | Val mAP@50: 1.33%\n",
+            "Epoch 11/50 | Average Loss: 4.3501 | Val mAP@50: 0.84%\n",
+            "Epoch 12/50 | Average Loss: 4.2526 | Val mAP@50: 0.63%\n",
+            "Epoch 13/50 | Average Loss: 4.1664 | Val mAP@50: 1.35%\n",
+            "Epoch 14/50 | Average Loss: 4.0826 | Val mAP@50: 0.32%\n",
+            "Epoch 15/50 | Average Loss: 3.9729 | Val mAP@50: 4.07%\n",
+            "Epoch 16/50 | Average Loss: 3.9096 | Val mAP@50: 5.38%\n",
+            "Epoch 17/50 | Average Loss: 3.7933 | Val mAP@50: 2.77%\n",
+            "Epoch 18/50 | Average Loss: 3.6541 | Val mAP@50: 13.64%\n",
+            "Epoch 19/50 | Average Loss: 3.5708 | Val mAP@50: 8.89%\n",
+            "Epoch 20/50 | Average Loss: 3.4262 | Val mAP@50: 12.69%\n",
+            "Epoch 21/50 | Average Loss: 3.3465 | Val mAP@50: 11.33%\n",
+            "Epoch 22/50 | Average Loss: 3.2322 | Val mAP@50: 14.71%\n",
+            "Epoch 23/50 | Average Loss: 3.1477 | Val mAP@50: 16.29%\n",
+            "Epoch 24/50 | Average Loss: 3.0494 | Val mAP@50: 13.81%\n",
+            "Epoch 25/50 | Average Loss: 2.9497 | Val mAP@50: 19.88%\n",
+            "Epoch 26/50 | Average Loss: 2.8894 | Val mAP@50: 23.73%\n",
+            "Epoch 27/50 | Average Loss: 2.8193 | Val mAP@50: 19.44%\n",
+            "Epoch 28/50 | Average Loss: 2.7603 | Val mAP@50: 26.87%\n",
+            "Epoch 29/50 | Average Loss: 2.6514 | Val mAP@50: 29.17%\n",
+            "Epoch 30/50 | Average Loss: 2.5952 | Val mAP@50: 31.77%\n",
+            "Epoch 31/50 | Average Loss: 2.5447 | Val mAP@50: 34.20%\n",
+            "Epoch 32/50 | Average Loss: 2.4909 | Val mAP@50: 33.91%\n",
+            "Epoch 33/50 | Average Loss: 2.4262 | Val mAP@50: 28.83%\n",
+            "Epoch 34/50 | Average Loss: 2.3547 | Val mAP@50: 29.66%\n",
+            "Epoch 35/50 | Average Loss: 2.2995 | Val mAP@50: 34.68%\n",
+            "Epoch 36/50 | Average Loss: 2.2497 | Val mAP@50: 38.26%\n",
+            "Epoch 37/50 | Average Loss: 2.1928 | Val mAP@50: 38.12%\n",
+            "Epoch 38/50 | Average Loss: 2.1699 | Val mAP@50: 40.21%\n",
+            "Epoch 39/50 | Average Loss: 2.0953 | Val mAP@50: 32.50%\n",
+            "Epoch 40/50 | Average Loss: 2.0637 | Val mAP@50: 37.76%\n",
+            "Epoch 41/50 | Average Loss: 2.0071 | Val mAP@50: 31.47%\n",
+            "Epoch 42/50 | Average Loss: 1.9799 | Val mAP@50: 29.90%\n",
+            "Epoch 43/50 | Average Loss: 1.9353 | Val mAP@50: 43.29%\n",
+            "Epoch 44/50 | Average Loss: 1.8818 | Val mAP@50: 40.70%\n",
+            "Epoch 45/50 | Average Loss: 1.8554 | Val mAP@50: 40.98%\n",
+            "Epoch 46/50 | Average Loss: 1.8207 | Val mAP@50: 43.23%\n",
+            "Epoch 47/50 | Average Loss: 1.7744 | Val mAP@50: 50.82%\n",
+            "Epoch 48/50 | Average Loss: 1.7613 | Val mAP@50: 29.69%\n",
+            "Epoch 49/50 | Average Loss: 1.7117 | Val mAP@50: 48.81%\n",
+            "Epoch 50/50 | Average Loss: 1.6742 | Val mAP@50: 41.12%\n",
+            "SSD Training Complete!\n"
+          ]
+        }
+      ],
+      "source": [
+        "num_epochs = 50\n",
+        "loss_history_ssd = []\n",
+        "map_history_ssd = []\n",
+        "\n",
+        "print(\"Starting SSD training (with Gradient Clipping)...\")\n",
+        "\n",
+        "for epoch in range(num_epochs):\n",
+        "    ssd_model.train()\n",
+        "    epoch_loss = 0\n",
+        "\n",
+        "    for images, targets in train_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 = ssd_model(images, targets)\n",
+        "        losses = sum(loss for loss in loss_dict.values())\n",
+        "\n",
+        "        optimizer.zero_grad()\n",
+        "        losses.backward()\n",
+        "        torch.nn.utils.clip_grad_norm_(ssd_model.parameters(), max_norm=1.0)\n",
+        "        optimizer.step()\n",
+        "        epoch_loss += losses.item()\n",
+        "\n",
+        "    average_loss = epoch_loss / len(train_loader)\n",
+        "    loss_history_ssd.append(average_loss)\n",
+        "\n",
+        "    map_50 = evaluate_model(ssd_model, val_loader, device)\n",
+        "    map_history_ssd.append(map_50)\n",
+        "\n",
+        "    print(f\"Epoch {epoch+1}/{num_epochs} | Average Loss: {average_loss:.4f} | Val mAP@50: {map_50:.2f}%\")\n",
+        "\n",
+        "print(\"SSD Training Complete!\")"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "KHZZWNTzMWNK",
+        "outputId": "c0cf29bf-1fc3-42ef-e33d-c20333b88f51"
+      },
+      "outputs": [
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "Model saved to ssd_volleyball.pth\n"
+          ]
+        }
+      ],
+      "source": [
+        "save_path = 'ssd_volleyball.pth'\n",
+        "torch.save(ssd_model.state_dict(), save_path)\n",
+        "print(f\"Model saved to {save_path}\")"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 607
+        },
+        "id": "e45AADk-MXaq",
+        "outputId": "df3bb02e-3eae-4d76-dd41-4e7fc27c4c08"
+      },
+      "outputs": [
+        {
+          "data": {
+            "image/png": "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",
+            "text/plain": [
+              "<Figure size 1000x600 with 2 Axes>"
+            ]
+          },
+          "metadata": {},
+          "output_type": "display_data"
+        }
+      ],
+      "source": [
+        "import matplotlib.pyplot as plt\n",
+        "\n",
+        "epochs = list(range(1, len(loss_history_ssd) + 1))\n",
+        "fig, ax1 = plt.subplots(figsize=(10, 6))\n",
+        "\n",
+        "color = 'tab:green'\n",
+        "ax1.set_xlabel('Epoch', fontsize=12)\n",
+        "ax1.set_ylabel('Average Loss', color=color, fontsize=12)\n",
+        "ax1.plot(epochs, loss_history_ssd, marker='o', linestyle='-', color=color, label='SSD Training Loss')\n",
+        "ax1.tick_params(axis='y', labelcolor=color)\n",
+        "ax1.grid(True, linestyle='--', alpha=0.7)\n",
+        "\n",
+        "ax2 = ax1.twinx()\n",
+        "color = 'tab:red'\n",
+        "ax2.set_ylabel('mAP@50 (%)', color=color, fontsize=12)\n",
+        "ax2.plot(epochs, map_history_ssd, marker='s', linestyle='-', color=color, label='Validation mAP@50')\n",
+        "ax2.tick_params(axis='y', labelcolor=color)\n",
+        "\n",
+        "plt.title('SSD Training Loss & Validation Accuracy', fontsize=16, fontweight='bold')\n",
+        "fig.tight_layout()\n",
+        "plt.savefig('ssd_loss_map_curve.png', dpi=300, bbox_inches='tight')\n",
+        "plt.show()"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "## RetinaNet\n"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "mJ9Do14IMaqy",
+        "outputId": "53357fb3-6276-45ec-d4ce-5b45d4742d72"
+      },
+      "outputs": [
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "Loading RetinaNet Architecture...\n",
+            "RetinaNet Model loaded and moved to: cuda\n"
+          ]
+        }
+      ],
+      "source": [
+        "import torchvision\n",
+        "import torch\n",
+        "\n",
+        "print(\"Loading RetinaNet Architecture...\")\n",
+        "\n",
+        "retinanet_model = torchvision.models.detection.retinanet_resnet50_fpn(weights_backbone='DEFAULT', num_classes=2)\n",
+        "\n",
+        "device = torch.device('cuda') if torch.cuda.is_available() else torch.device('cpu')\n",
+        "retinanet_model.to(device)\n",
+        "\n",
+        "params = [p for p in retinanet_model.parameters() if p.requires_grad]\n",
+        "optimizer = torch.optim.SGD(params, lr=0.0005, momentum=0.9, weight_decay=0.0005)\n",
+        "\n",
+        "print(f\"RetinaNet Model loaded and moved to: {device}\")"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "GedJTLfzMcBw",
+        "outputId": "d0e22281-31d4-412f-c907-9b6dc0951dda"
+      },
+      "outputs": [
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "Starting RetinaNet training...\n",
+            "Epoch 1/50 | Average Loss: 2.3301 | Val mAP@50: 0.00%\n",
+            "Epoch 2/50 | Average Loss: 1.6121 | Val mAP@50: 0.00%\n",
+            "Epoch 3/50 | Average Loss: 1.4137 | Val mAP@50: 0.06%\n",
+            "Epoch 4/50 | Average Loss: 1.3323 | Val mAP@50: 5.62%\n",
+            "Epoch 5/50 | Average Loss: 1.2642 | Val mAP@50: 8.88%\n",
+            "Epoch 6/50 | Average Loss: 1.1890 | Val mAP@50: 12.74%\n",
+            "Epoch 7/50 | Average Loss: 1.0214 | Val mAP@50: 25.18%\n",
+            "Epoch 8/50 | Average Loss: 0.8286 | Val mAP@50: 36.17%\n",
+            "Epoch 9/50 | Average Loss: 0.7386 | Val mAP@50: 44.42%\n",
+            "Epoch 10/50 | Average Loss: 0.6840 | Val mAP@50: 49.48%\n",
+            "Epoch 11/50 | Average Loss: 0.6430 | Val mAP@50: 48.54%\n",
+            "Epoch 12/50 | Average Loss: 0.6002 | Val mAP@50: 54.59%\n",
+            "Epoch 13/50 | Average Loss: 0.5738 | Val mAP@50: 54.73%\n",
+            "Epoch 14/50 | Average Loss: 0.5533 | Val mAP@50: 57.70%\n",
+            "Epoch 15/50 | Average Loss: 0.5340 | Val mAP@50: 61.20%\n",
+            "Epoch 16/50 | Average Loss: 0.5144 | Val mAP@50: 63.57%\n",
+            "Epoch 17/50 | Average Loss: 0.5009 | Val mAP@50: 69.36%\n",
+            "Epoch 18/50 | Average Loss: 0.4888 | Val mAP@50: 68.28%\n",
+            "Epoch 19/50 | Average Loss: 0.4751 | Val mAP@50: 69.73%\n",
+            "Epoch 20/50 | Average Loss: 0.4649 | Val mAP@50: 70.03%\n",
+            "Epoch 21/50 | Average Loss: 0.4557 | Val mAP@50: 74.76%\n",
+            "Epoch 22/50 | Average Loss: 0.4437 | Val mAP@50: 76.04%\n",
+            "Epoch 23/50 | Average Loss: 0.4355 | Val mAP@50: 78.09%\n",
+            "Epoch 24/50 | Average Loss: 0.4230 | Val mAP@50: 78.49%\n",
+            "Epoch 25/50 | Average Loss: 0.4164 | Val mAP@50: 77.25%\n",
+            "Epoch 26/50 | Average Loss: 0.4090 | Val mAP@50: 83.77%\n",
+            "Epoch 27/50 | Average Loss: 0.3988 | Val mAP@50: 87.15%\n",
+            "Epoch 28/50 | Average Loss: 0.3953 | Val mAP@50: 84.46%\n",
+            "Epoch 29/50 | Average Loss: 0.3917 | Val mAP@50: 84.98%\n",
+            "Epoch 30/50 | Average Loss: 0.3852 | Val mAP@50: 87.45%\n",
+            "Epoch 31/50 | Average Loss: 0.3778 | Val mAP@50: 89.37%\n",
+            "Epoch 32/50 | Average Loss: 0.3671 | Val mAP@50: 88.55%\n",
+            "Epoch 33/50 | Average Loss: 0.3610 | Val mAP@50: 90.62%\n",
+            "Epoch 34/50 | Average Loss: 0.3552 | Val mAP@50: 90.31%\n",
+            "Epoch 35/50 | Average Loss: 0.3483 | Val mAP@50: 90.79%\n",
+            "Epoch 36/50 | Average Loss: 0.3421 | Val mAP@50: 90.86%\n",
+            "Epoch 37/50 | Average Loss: 0.3360 | Val mAP@50: 89.05%\n",
+            "Epoch 38/50 | Average Loss: 0.3316 | Val mAP@50: 92.12%\n",
+            "Epoch 39/50 | Average Loss: 0.3260 | Val mAP@50: 91.62%\n",
+            "Epoch 40/50 | Average Loss: 0.3195 | Val mAP@50: 92.63%\n",
+            "Epoch 41/50 | Average Loss: 0.3160 | Val mAP@50: 92.63%\n",
+            "Epoch 42/50 | Average Loss: 0.3092 | Val mAP@50: 92.92%\n",
+            "Epoch 43/50 | Average Loss: 0.3053 | Val mAP@50: 92.78%\n",
+            "Epoch 44/50 | Average Loss: 0.2948 | Val mAP@50: 92.78%\n",
+            "Epoch 45/50 | Average Loss: 0.2925 | Val mAP@50: 92.37%\n",
+            "Epoch 46/50 | Average Loss: 0.2873 | Val mAP@50: 92.92%\n",
+            "Epoch 47/50 | Average Loss: 0.2798 | Val mAP@50: 91.91%\n",
+            "Epoch 48/50 | Average Loss: 0.2754 | Val mAP@50: 93.03%\n",
+            "Epoch 49/50 | Average Loss: 0.2717 | Val mAP@50: 92.12%\n",
+            "Epoch 50/50 | Average Loss: 0.2662 | Val mAP@50: 92.63%\n",
+            "RetinaNet Training Complete!\n"
+          ]
+        }
+      ],
+      "source": [
+        "num_epochs = 50\n",
+        "loss_history_retinanet = []\n",
+        "map_history_retinanet = []\n",
+        "\n",
+        "print(\"Starting RetinaNet training...\")\n",
+        "\n",
+        "for epoch in range(num_epochs):\n",
+        "    retinanet_model.train()\n",
+        "    epoch_loss = 0\n",
+        "\n",
+        "    for images, targets in train_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 = retinanet_model(images, targets)\n",
+        "        losses = sum(loss for loss in loss_dict.values())\n",
+        "\n",
+        "        optimizer.zero_grad()\n",
+        "        losses.backward()\n",
+        "        torch.nn.utils.clip_grad_norm_(retinanet_model.parameters(), max_norm=1.0)\n",
+        "        optimizer.step()\n",
+        "        epoch_loss += losses.item()\n",
+        "\n",
+        "    average_loss = epoch_loss / len(train_loader)\n",
+        "    loss_history_retinanet.append(average_loss)\n",
+        "\n",
+        "    map_50 = evaluate_model(retinanet_model, val_loader, device)\n",
+        "    map_history_retinanet.append(map_50)\n",
+        "\n",
+        "    print(f\"Epoch {epoch+1}/{num_epochs} | Average Loss: {average_loss:.4f} | Val mAP@50: {map_50:.2f}%\")\n",
+        "\n",
+        "print(\"RetinaNet Training Complete!\")"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 22,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 624
+        },
+        "id": "HB1k6GQ0MdIN",
+        "outputId": "b327d674-d27a-410a-a623-8c1cf20c48e9"
+      },
+      "outputs": [
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "Model saved to retinanet_volleyball.pth\n"
+          ]
+        },
+        {
+          "data": {
+            "image/png": "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",
+            "text/plain": [
+              "<Figure size 1000x600 with 2 Axes>"
+            ]
+          },
+          "metadata": {},
+          "output_type": "display_data"
+        }
+      ],
+      "source": [
+        "import matplotlib.pyplot as plt\n",
+        "\n",
+        "save_path = 'retinanet_volleyball.pth'\n",
+        "torch.save(retinanet_model.state_dict(), save_path)\n",
+        "print(f\"Model saved to {save_path}\")\n",
+        "\n",
+        "epochs = list(range(1, len(loss_history_retinanet) + 1))\n",
+        "fig, ax1 = plt.subplots(figsize=(10, 6))\n",
+        "\n",
+        "color = 'tab:purple'\n",
+        "ax1.set_xlabel('Epoch', fontsize=12)\n",
+        "ax1.set_ylabel('Average Loss', color=color, fontsize=12)\n",
+        "ax1.plot(epochs, loss_history_retinanet, marker='o', linestyle='-', color=color, label='RetinaNet Loss')\n",
+        "ax1.tick_params(axis='y', labelcolor=color)\n",
+        "ax1.grid(True, linestyle='--', alpha=0.7)\n",
+        "\n",
+        "ax2 = ax1.twinx()\n",
+        "color = 'tab:brown'\n",
+        "ax2.set_ylabel('mAP@50 (%)', color=color, fontsize=12)\n",
+        "ax2.plot(epochs, map_history_retinanet, marker='s', linestyle='-', color=color, label='Validation mAP@50')\n",
+        "ax2.tick_params(axis='y', labelcolor=color)\n",
+        "\n",
+        "plt.title('RetinaNet Training Loss & Validation Accuracy', fontsize=16, fontweight='bold')\n",
+        "fig.tight_layout()\n",
+        "plt.savefig('retinanet_loss_map_curve.png', dpi=300, bbox_inches='tight')\n",
+        "plt.show()"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "## YOLOv8"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "%pip install ultralytics -q\n",
+        "\n",
+        "from ultralytics import YOLO\n",
+        "\n",
+        "model = YOLO('yolov8n.pt')\n",
+        "\n",
+        "results = model.train(\n",
+        "    data='dataset.yaml',\n",
+        "    epochs=100,\n",
+        "    imgsz=640,\n",
+        "    batch=16,\n",
+        "    name='volleyball_model'\n",
+        ")"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "from IPython.display import Image, display\n",
+        "\n",
+        "results_img_path = 'runs/detect/volleyball_model/results.png'\n",
+        "\n",
+        "print(\"Training Progress Curves:\")\n",
+        "display(Image(filename=results_img_path))"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "from ultralytics import YOLO\n",
+        "\n",
+        "model = YOLO('yolov8m.pt') \n",
+        "\n",
+        "results = model.train(\n",
+        "    data='dataset.yaml',   \n",
+        "    epochs=50,                \n",
+        "    imgsz=640,                \n",
+        "    batch=16,                 \n",
+        "    name='volleyball_model_medium'\n",
+        ")"
+      ]
+    }
+  ],
+  "metadata": {
+    "accelerator": "GPU",
+    "colab": {
+      "gpuType": "T4",
+      "provenance": []
+    },
+    "kernelspec": {
+      "display_name": "Python 3",
+      "name": "python3"
+    },
+    "language_info": {
+      "name": "python"
+    }
+  },
+  "nbformat": 4,
+  "nbformat_minor": 0
+}
diff --git a/Volleyball Detection with Deep Learning/model/yolov8_medium_volleyball.pt b/Volleyball Detection with Deep Learning/model/yolov8_medium_volleyball.pt
new file mode 100644
index 000000000..7cc7ce3cc
Binary files /dev/null and b/Volleyball Detection with Deep Learning/model/yolov8_medium_volleyball.pt differ
diff --git a/Volleyball Detection with Deep Learning/model/yolov8n_volleyball.pt b/Volleyball Detection with Deep Learning/model/yolov8n_volleyball.pt
new file mode 100644
index 000000000..426cfec7d
Binary files /dev/null and b/Volleyball Detection with Deep Learning/model/yolov8n_volleyball.pt differ