initial commit

deployment/app.py

@@ -0,0 +1,131 @@
+import os
+import torch
+import torchvision.transforms as transforms
+import torchvision.models.detection as detection
+from flask import Flask, request, render_template, send_from_directory, url_for, Response
+from PIL import Image
+import cv2
+import numpy as np
+
+# Initialize Flask app
+app = Flask(__name__)
+UPLOAD_FOLDER = os.path.abspath(os.path.join("deployment", "static", "uploads"))
+OUTPUT_FOLDER = os.path.abspath(os.path.join("deployment", "outputs"))
+
+# Ensure directories exist
+os.makedirs(UPLOAD_FOLDER, exist_ok=True)
+os.makedirs(OUTPUT_FOLDER, exist_ok=True)
+
+# Define class names
+CLASS_NAMES = {
+    0: "vehicle", 1: "bicycle", 2: "bus", 3: "car", 4: "lorry"
+}
+NUM_CLASSES = len(CLASS_NAMES) + 1  # Include background class
+
+# Load Faster R-CNN model
+def load_model(model_path, num_classes):
+    model = detection.fasterrcnn_resnet50_fpn(weights=None, num_classes=num_classes)
+    model.load_state_dict(torch.load(model_path, map_location='cpu'))
+    model.eval()
+    return model
+
+model_path = os.path.join("models", "fasterrcnn_model.pth")
+model = load_model(model_path, NUM_CLASSES)
+
+# Image preprocessing
+def preprocess_image(image):
+    transform = transforms.Compose([transforms.ToTensor()])
+    return transform(image).unsqueeze(0)
+
+# Draw predictions
+def draw_predictions(image, prediction):
+    boxes, scores, labels = prediction['boxes'], prediction['scores'], prediction['labels']
+    for i in range(len(boxes)):
+        if scores[i] > 0.5:  # Confidence threshold
+            x1, y1, x2, y2 = map(int, boxes[i].tolist())
+            class_name = CLASS_NAMES.get(labels[i].item(), f"Class {labels[i].item()}")
+            cv2.rectangle(image, (x1, y1), (x2, y2), (0, 255, 0), 2)
+            cv2.putText(image, f"{class_name}: {scores[i]:.2f}", (x1, y1 - 10),
+                        cv2.FONT_HERSHEY_SIMPLEX, 0.5, (0, 255, 0), 2)
+    return image
+
+# Home route (upload and detect)
+@app.route('/', methods=['GET', 'POST'])
+def upload_and_predict():
+    if request.method == 'POST':
+        file = request.files['file']
+        if file:
+            filename = file.filename
+            upload_path = os.path.join(UPLOAD_FOLDER, filename)
+            result_path = os.path.join(OUTPUT_FOLDER, filename)
+            file.save(upload_path)
+
+            print(f"✅ Uploaded file saved at: {upload_path}")
+
+            # Run inference
+            img = Image.open(upload_path).convert("RGB")
+            img_tensor = preprocess_image(img)
+
+            with torch.no_grad():
+                prediction = model(img_tensor)[0]
+
+            # Draw results
+            image_cv = cv2.imread(upload_path)
+            if image_cv is None:
+                print(f"❌ ERROR: OpenCV could not read {upload_path}")
+            else:
+                result_image = draw_predictions(image_cv, prediction)
+                cv2.imwrite(result_path, result_image)
+                print(f"✅ Result image saved at: {result_path}")
+
+            return render_template('index.html', 
+                                   uploaded_image=url_for('uploaded_file', filename=filename), 
+                                   result_image=url_for('output_file', filename=filename))
+
+    return render_template('index.html')
+
+# Serve uploaded images correctly
+@app.route('/uploads/<filename>')
+def uploaded_file(filename):
+    return send_from_directory(os.path.abspath(UPLOAD_FOLDER), filename)
+
+# Serve output images correctly
+@app.route('/outputs/<filename>')
+def output_file(filename):
+    return send_from_directory(os.path.abspath(OUTPUT_FOLDER), filename)
+
+
+# Real-time webcam detection
+def generate_frames():
+    cap = cv2.VideoCapture(0)
+    while cap.isOpened():
+        success, frame = cap.read()
+        if not success:
+            break
+
+        # Convert frame and preprocess
+        img = Image.fromarray(cv2.cvtColor(frame, cv2.COLOR_BGR2RGB))
+        img_tensor = preprocess_image(img)
+
+        # Run inference
+        with torch.no_grad():
+            prediction = model(img_tensor)[0]
+
+        # Draw results
+        frame = draw_predictions(frame, prediction)
+
+        # Convert to JPEG
+        _, buffer = cv2.imencode('.jpg', frame)
+        frame_bytes = buffer.tobytes()
+
+        yield (b'--frame\r\n'
+               b'Content-Type: image/jpeg\r\n\r\n' + frame_bytes + b'\r\n')
+
+    cap.release()
+
+@app.route('/video_feed')
+def video_feed():
+    return Response(generate_frames(), mimetype='multipart/x-mixed-replace; boundary=frame')
+
+if __name__ == '__main__':
+    app.run(debug=True)

deployment/static/style.css

@@ -0,0 +1,44 @@
+body {
+    font-family: Arial, sans-serif;
+    background-color: #f4f4f4;
+    text-align: center;
+    padding: 20px;
+}
+
+h2 {
+    color: #333;
+}
+
+form {
+    background: white;
+    padding: 20px;
+    border-radius: 8px;
+    box-shadow: 0px 0px 10px rgba(0, 0, 0, 0.1);
+    display: inline-block;
+    margin: 20px;
+}
+
+input[type="file"] {
+    margin: 10px 0;
+}
+
+button {
+    background-color: #28a745;
+    color: white;
+    border: none;
+    padding: 10px 15px;
+    border-radius: 5px;
+    cursor: pointer;
+    font-size: 16px;
+}
+
+button:hover {
+    background-color: #218838;
+}
+
+img {
+    margin-top: 15px;
+    max-width: 80%;
+    border-radius: 8px;
+    box-shadow: 0px 0px 10px rgba(0, 0, 0, 0.2);
+}

deployment/templates/index.html

@@ -0,0 +1,76 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>Faster R-CNN Object Detection</title>
+    <style>
+        body {
+            font-family: Arial, sans-serif;
+            text-align: center;
+            background-color: #f4f4f4;
+            padding: 20px;
+        }
+        h1 {
+            color: #333;
+        }
+        .container {
+            background: white;
+            padding: 20px;
+            border-radius: 10px;
+            box-shadow: 0 0 10px rgba(0, 0, 0, 0.1);
+            max-width: 600px;
+            margin: auto;
+        }
+        input[type="file"] {
+            margin: 20px 0;
+        }
+        .image-container {
+            margin-top: 20px;
+        }
+        img {
+            max-width: 100%;
+            border: 2px solid #ddd;
+            border-radius: 5px;
+        }
+        .btn {
+            display: inline-block;
+            padding: 10px 20px;
+            font-size: 16px;
+            background-color: #007bff;
+            color: white;
+            border: none;
+            cursor: pointer;
+            border-radius: 5px;
+            margin-top: 10px;
+        }
+        .btn:hover {
+            background-color: #0056b3;
+        }
+    </style>
+</head>
+<body>
+    <div class="container">
+        <h1>Faster R-CNN Object Detection</h1>
+        
+        <form action="/" method="post" enctype="multipart/form-data">
+            <input type="file" name="file" required>
+            <button type="submit" class="btn">Upload & Detect</button>
+        </form>
+
+        {% if uploaded_image %}
+        <div class="image-container">
+            <h2>Uploaded Image</h2>
+            <img src="{{ uploaded_image }}" alt="Uploaded Image">
+        </div>
+        {% endif %}
+
+        {% if result_image %}
+        <div class="image-container">
+            <h2>Detection Results</h2>
+            <img src="{{ result_image }}" alt="Detected Image">
+        </div>
+        {% endif %}
+    </div>
+</body>
+</html>

models/fasterrcnn_model.pth

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:115326c8ea7e52e62ed0d14c5fa5d9ee67bdeac5324f8a0a559cd1b29d95bba6
+size 165811943

requirements.txt

@@ -0,0 +1,9 @@
+torch 
+torchvision 
+torchaudio
+pycocotools
+matplotlib
+numpy
+pandas
+opencv-python
+tqdm

scripts/dataset.py

@@ -0,0 +1,57 @@
+import os
+import torch
+import torchvision.transforms as transforms
+from torch.utils.data import Dataset
+from pycocotools.coco import COCO
+from PIL import Image
+
+class COCODataset(Dataset):
+    def __init__(self, root, annotation_file, transforms=None):
+        self.root = root
+        self.coco = COCO(annotation_file)
+        self.transforms = transforms
+        
+        self.image_ids = list(self.coco.imgs.keys())
+
+    def __getitem__(self, idx):
+        image_id = self.image_ids[idx]
+        image_info = self.coco.imgs[image_id]
+        image_path = os.path.join(self.root, image_info["file_name"])
+        
+        image = Image.open(image_path).convert("RGB")
+
+        annotations = self.coco.loadAnns(self.coco.getAnnIds(imgIds=image_id))
+        
+        boxes = []
+        labels = []
+        
+        for ann in annotations:
+            xmin = ann["bbox"][0]
+            ymin = ann["bbox"][1]
+            width = ann["bbox"][2]
+            height = ann["bbox"][3]
+            
+            boxes.append([xmin, ymin, xmin + width, ymin + height])
+            labels.append(ann["category_id"])  # Ensure category_id starts from 1
+        
+        if len(boxes) == 0:
+            boxes = torch.zeros((0, 4), dtype=torch.float32)
+            labels = torch.zeros((0,), dtype=torch.int64)
+        else:
+            boxes = torch.tensor(boxes, dtype=torch.float32)
+            labels = torch.tensor(labels, dtype=torch.int64)
+
+        target = {"boxes": boxes, "labels": labels, "image_id": torch.tensor([image_id])}
+
+        if self.transforms:
+            image = self.transforms(image)
+
+        return image, target
+
+    def __len__(self):
+        return len(self.image_ids)
+
+def get_transforms():
+    return transforms.Compose([
+        transforms.ToTensor()
+    ])

scripts/inference.py

@@ -0,0 +1,143 @@
+import torch
+import torchvision.transforms as transforms
+import torchvision.models.detection as detection
+from PIL import Image
+import cv2
+import numpy as np
+
+# Define class names
+CLASS_NAMES = {
+    0: "vehicle", 1: "bicycle", 2: "bus", 3: "car", 4: "lorry"
+}
+NUM_CLASSES = len(CLASS_NAMES) + 1  # Include background class
+
+# Global flag to stop detection when clicking the window
+stop_detection = False
+
+# Load Faster R-CNN model
+def load_model(model_path, num_classes):
+    model = detection.fasterrcnn_resnet50_fpn(weights=None, num_classes=num_classes)
+
+    # Load the trained model
+    checkpoint = torch.load(model_path, map_location="cpu")
+    model.load_state_dict(checkpoint)
+
+    model.eval()
+    return model
+
+# Transform input image
+def preprocess_image(image):
+    transform = transforms.Compose([transforms.ToTensor()])
+    return transform(image).unsqueeze(0)
+
+# Run inference on an image
+def run_inference_on_image(image_path, model):
+    img = Image.open(image_path).convert("RGB")
+    img_tensor = preprocess_image(img)
+
+    with torch.no_grad():
+        prediction = model(img_tensor)[0]
+
+    draw_predictions(image_path, prediction)
+
+# Draw predictions on an image
+def draw_predictions(image_path, prediction):
+    image = cv2.imread(image_path)
+    boxes, scores, labels = prediction['boxes'], prediction['scores'], prediction['labels']
+
+    for i in range(len(boxes)):
+        if scores[i] > 0.5:  # Confidence threshold
+            x1, y1, x2, y2 = map(int, boxes[i].tolist())
+            class_id = labels[i].item()
+            class_name = CLASS_NAMES.get(class_id, f"Class {class_id}")
+            cv2.rectangle(image, (x1, y1), (x2, y2), (0, 255, 0), 2)
+            cv2.putText(image, f"{class_name}: {scores[i]:.2f}", (x1, y1 - 10),
+                        cv2.FONT_HERSHEY_SIMPLEX, 0.5, (0, 255, 0), 2)
+
+    cv2.imshow("Detection Result", image)
+    cv2.waitKey(0)
+    cv2.destroyAllWindows()
+
+# Mouse click event function to stop real-time detection
+def stop_real_time_detection(event, x, y, flags, param):
+    global stop_detection
+    if event == cv2.EVENT_LBUTTONDOWN:  # Detect left mouse button click
+        stop_detection = True
+
+# Real-time detection with webcam
+def real_time_detection(model):
+    global stop_detection
+    stop_detection = False  # Reset flag before starting detection
+
+    cap = cv2.VideoCapture(0)
+    if not cap.isOpened():
+        print("❌ Error: Could not open webcam.")
+        return
+
+    print("🎥 Starting real-time object detection. Click the window to close.")
+
+    cv2.namedWindow("Real-time Detection")  # Name the OpenCV window
+    cv2.setMouseCallback("Real-time Detection", stop_real_time_detection)  # Set mouse click callback
+
+    while True:
+        ret, frame = cap.read()
+        if not ret:
+            print("❌ Error: Failed to capture frame.")
+            break
+
+        img = Image.fromarray(cv2.cvtColor(frame, cv2.COLOR_BGR2RGB))
+        img_tensor = preprocess_image(img)
+
+        with torch.no_grad():
+            prediction = model(img_tensor)[0]
+
+        draw_predictions_live(frame, prediction)
+
+        cv2.imshow("Real-time Detection", frame)
+
+        # FIX: Process window events so OpenCV does not freeze
+        if cv2.waitKey(1) & 0xFF == ord('q'):  # Press 'q' to exit (optional)
+            break
+
+        if stop_detection:  # If window is clicked, stop detection
+            print("🛑 Stopping real-time detection...")
+            break
+
+    cap.release()
+    cv2.destroyAllWindows()  # FIX: Close OpenCV windows properly
+    cv2.waitKey(1)  # FIX: Ensure window is destroyed
+
+# Draw predictions on live video feed
+def draw_predictions_live(frame, prediction):
+    boxes, scores, labels = prediction['boxes'], prediction['scores'], prediction['labels']
+
+    for i in range(len(boxes)):
+        if scores[i] > 0.5:
+            x1, y1, x2, y2 = map(int, boxes[i].tolist())
+            class_id = labels[i].item()
+            class_name = CLASS_NAMES.get(class_id, f"Class {class_id}")
+            cv2.rectangle(frame, (x1, y1), (x2, y2), (0, 255, 0), 2)
+            cv2.putText(frame, f"{class_name}: {scores[i]:.2f}", (x1, y1 - 10),
+                        cv2.FONT_HERSHEY_SIMPLEX, 0.5, (0, 255, 0), 2)
+
+if __name__ == "__main__":
+    model = load_model("models/fasterrcnn_model.pth", NUM_CLASSES)
+
+    while True:
+        print("\nOptions:")
+        print("1 - Run object detection on an image")
+        print("2 - Run real-time object detection (Click to exit)")
+        print("q - Quit")
+
+        choice = input("Enter your choice: ").strip().lower()
+
+        if choice == "1":
+            image_path = input("Enter the path of the test image: ").strip()
+            run_inference_on_image(image_path, model)
+        elif choice == "2":
+            real_time_detection(model)
+        elif choice == "q":
+            print("👋 Exiting program.")
+            break
+        else:
+            print("⚠️ Invalid choice! Please enter '1', '2', or 'q'.")

scripts/train.py

@@ -0,0 +1,127 @@
+import torch
+import torchvision
+import matplotlib.pyplot as plt
+from torchvision.models.detection.faster_rcnn import FastRCNNPredictor
+from torchvision.models.detection import fasterrcnn_resnet50_fpn, FasterRCNN_ResNet50_FPN_Weights
+from torch.utils.data import DataLoader
+from torchmetrics.detection.mean_ap import MeanAveragePrecision
+from torchvision import transforms as T
+from scripts.dataset import COCODataset, get_transforms
+
+# Paths to dataset
+DATASET_ROOT = "dataset/train"
+ANNOTATION_FILE = "dataset/annotations/instances_train.json"
+
+# Function to get the model with fixed NMS
+def get_model(num_classes):
+    model = fasterrcnn_resnet50_fpn(weights=FasterRCNN_ResNet50_FPN_Weights.COCO_V1)
+    
+    # Replace the classifier with a new one (custom num_classes)
+    in_features = model.roi_heads.box_predictor.cls_score.in_features
+    model.roi_heads.box_predictor = FastRCNNPredictor(in_features, num_classes)
+
+    # Fix excessive bounding boxes by lowering NMS
+    model.rpn.nms_thresh = 0.3  # Default ~0.7
+    model.roi_heads.nms_thresh = 0.3
+    
+    return model
+
+# Define dataset and data loader
+dataset = COCODataset(root=DATASET_ROOT, annotation_file=ANNOTATION_FILE, transforms=get_transforms())
+dataloader = DataLoader(dataset, batch_size=4, shuffle=True, collate_fn=lambda batch: tuple(zip(*batch)))
+
+# Device configuration
+device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+
+# Define the number of classes (5 classes + 1 background)
+num_classes = 6  
+model = get_model(num_classes).to(device)
+
+# Optimizer and learning rate scheduler
+params = [p for p in model.parameters() if p.requires_grad]
+optimizer = torch.optim.AdamW(params, lr=0.002, weight_decay=0.0001)
+lr_scheduler = torch.optim.lr_scheduler.CosineAnnealingLR(optimizer, T_max=10)
+
+# Initialize Mean Average Precision (mAP) metric
+metric = MeanAveragePrecision()
+
+# Function to evaluate the model
+def evaluate_model(model, dataloader, device):
+    model.eval()
+    metric.reset()
+
+    with torch.no_grad():
+        for images, targets in dataloader:
+            images = [img.to(device) for img in images]
+            targets = [{k: v.to(device) for k, v in t.items()} for t in targets]
+
+            outputs = model(images)
+            preds = [{"boxes": o["boxes"].cpu(), "scores": o["scores"].cpu(), "labels": o["labels"].cpu()} for o in outputs]
+            gts = [{"boxes": t["boxes"].cpu(), "labels": t["labels"].cpu()} for t in targets]
+
+            metric.update(preds, gts)
+
+    result = metric.compute()
+    return result["map"].item(), result["map_50"].item(), result["map_75"].item()
+
+# Lists to store training loss and accuracy
+losses_list = []
+mAP_list = []
+mAP50_list = []
+mAP75_list = []
+
+# Training loop
+num_epochs = 15
+for epoch in range(num_epochs):
+    model.train()
+    epoch_loss = 0.0
+
+    for images, targets in dataloader:
+        images = [image.to(device) for image in images]
+        targets = [{k: v.to(device) for k, v in target.items()} for target in targets]
+
+        optimizer.zero_grad()
+        loss_dict = model(images, targets)
+        losses = sum(loss for loss in loss_dict.values())
+        epoch_loss += losses.item()
+
+        losses.backward()
+        torch.nn.utils.clip_grad_norm_(model.parameters(), max_norm=2.0)
+        optimizer.step()
+
+    lr_scheduler.step()
+    losses_list.append(epoch_loss)
+
+    # Compute mAP
+    mAP, mAP50, mAP75 = evaluate_model(model, dataloader, device)
+    mAP_list.append(mAP)
+    mAP50_list.append(mAP50)
+    mAP75_list.append(mAP75)
+
+    print(f"Epoch {epoch+1}/{num_epochs}, Loss: {epoch_loss:.4f}")
+    print(f"Epoch {epoch+1}: mAP: {mAP:.4f}, mAP@50: {mAP50:.4f}, mAP@75: {mAP75:.4f}")
+
+# Save model
+torch.save(model.state_dict(), "models/fasterrcnn_model.pth")
+print("Training complete! Model saved as 'fasterrcnn_model.pth'.")
+
+# Plot Loss Graph
+plt.figure(figsize=(10, 5))
+plt.plot(range(1, num_epochs + 1), losses_list, marker='o', linestyle='-')
+plt.xlabel("Epochs")
+plt.ylabel("Loss")
+plt.title("Training Loss over Epochs")
+plt.grid()
+plt.show()
+
+# Plot mAP Graphs
+plt.figure(figsize=(10, 5))
+plt.plot(range(1, num_epochs + 1), mAP_list, marker='o', linestyle='-', label="mAP")
+plt.plot(range(1, num_epochs + 1), mAP50_list, marker='s', linestyle='-', label="mAP@50")
+plt.plot(range(1, num_epochs + 1), mAP75_list, marker='d', linestyle='-', label="mAP@75")
+plt.xlabel("Epochs")
+plt.ylabel("Accuracy")
+plt.title("mAP over Epochs")
+plt.legend()
+plt.grid()
+plt.show()