def convert_box_format(box, from_fmt='xyxy', to_fmt='xywh'):
    """Convert between (x_min,y_min,x_max,y_max) and (x_center,y_center,w,h)."""
    if from_fmt == 'xyxy' and to_fmt == 'xywh':
        x_min, y_min, x_max, y_max = box
        w = x_max - x_min
        h = y_max - y_min
        x_c = x_min + w / 2
        y_c = y_min + h / 2
        return [x_c, y_c, w, h]
    elif from_fmt == 'xywh' and to_fmt == 'xyxy':
        x_c, y_c, w, h = box
        return [x_c - w/2, y_c - h/2, x_c + w/2, y_c + h/2]

# Example: a box from (100,150) to (300,400)
box_xyxy = [100, 150, 300, 400]
box_xywh = convert_box_format(box_xyxy, 'xyxy', 'xywh')
print(f"Corner format:  {box_xyxy}")   # [100, 150, 300, 400]
print(f"Center format:  {box_xywh}")   # [200.0, 275.0, 200, 250]

def compute_iou(box1, box2):
    """
    Compute IoU between two boxes in (x_min, y_min, x_max, y_max) format.
    Returns a float in [0, 1].
    """
    x1 = max(box1[0], box2[0])
    y1 = max(box1[1], box2[1])
    x2 = min(box1[2], box2[2])
    y2 = min(box1[3], box2[3])

    # Intersection area (clamp to 0 if boxes don't overlap)
    inter_area = max(0, x2 - x1) * max(0, y2 - y1)

    # Areas of each box
    area1 = (box1[2] - box1[0]) * (box1[3] - box1[1])
    area2 = (box2[2] - box2[0]) * (box2[3] - box2[1])

    # Union = sum of areas minus intersection
    union_area = area1 + area2 - inter_area

    if union_area == 0:
        return 0.0
    return inter_area / union_area


# Example 1: Perfect overlap
box_pred = [100, 100, 300, 300]
box_gt   = [100, 100, 300, 300]
print(f"IoU (perfect):  {compute_iou(box_pred, box_gt):.3f}")  # 1.000

# Example 2: 50% overlap
box_pred = [100, 100, 300, 300]
box_gt   = [200, 100, 400, 300]
print(f"IoU (partial):  {compute_iou(box_pred, box_gt):.3f}")  # 0.333

# Example 3: No overlap
box_pred = [100, 100, 200, 200]
box_gt   = [300, 300, 400, 400]
print(f"IoU (no overlap): {compute_iou(box_pred, box_gt):.3f}")  # 0.000

def nms(boxes, scores, iou_threshold=0.5):
    """
    Non-Maximum Suppression.
    boxes: list of [x_min, y_min, x_max, y_max]
    scores: confidence score for each box
    Returns: indices of kept boxes
    """
    # Sort boxes by score (highest first)
    order = sorted(range(len(scores)), key=lambda i: scores[i], reverse=True)
    keep = []

    while order:
        # Always keep the highest-confidence remaining box
        i = order[0]
        keep.append(i)
        remaining = []

        # Remove boxes with high IoU with box i
        for j in order[1:]:
            if compute_iou(boxes[i], boxes[j]) < iou_threshold:
                remaining.append(j)  # keep low-overlap boxes

        order = remaining  # continue with surviving boxes

    return keep


# Example: 5 boxes predicting the same car
boxes = [
    [100, 100, 300, 300],   # idx 0: score 0.95
    [105, 102, 305, 298],   # idx 1: score 0.88 (overlaps 0)
    [98,  99,  295, 302],   # idx 2: score 0.80 (overlaps 0)
    [400, 400, 550, 550],   # idx 3: score 0.72 (different object)
    [102, 103, 302, 299],   # idx 4: score 0.60 (overlaps 0)
]
scores = [0.95, 0.88, 0.80, 0.72, 0.60]

kept = nms(boxes, scores, iou_threshold=0.5)
print(f"Kept box indices: {kept}")
# Kept box indices: [0, 3]
# Box 0 (car 1, highest confidence) and box 3 (car 2, different location)

import torch
import torchvision
from torchvision.models.detection import fasterrcnn_resnet50_fpn
from torchvision.models.detection import FasterRCNN_ResNet50_FPN_Weights

# Load Faster R-CNN pretrained on COCO (80 classes)
model = fasterrcnn_resnet50_fpn(
    weights=FasterRCNN_ResNet50_FPN_Weights.DEFAULT
)
model.eval()

# Run inference on a dummy image (batch of 1)
dummy_image = torch.rand(3, 600, 800)   # C x H x W
with torch.no_grad():
    predictions = model([dummy_image])

pred = predictions[0]
print(f"Boxes:   {pred['boxes'].shape}")    # (N, 4) detected boxes
print(f"Labels:  {pred['labels'].shape}")   # (N,) class indices
print(f"Scores:  {pred['scores'].shape}")   # (N,) confidence scores

# Filter to high-confidence detections
high_conf = pred['scores'] > 0.5
boxes  = pred['boxes'][high_conf]
labels = pred['labels'][high_conf]
scores = pred['scores'][high_conf]
print(f"High-confidence detections: {boxes.shape[0]}")

# Install: pip install ultralytics
from ultralytics import YOLO
from PIL import Image
import requests, io

# Load YOLOv8 nano — smallest, fastest model
model = YOLO('yolov8n.pt')   # downloads ~6MB weights

# Run inference on an image URL
results = model('https://ultralytics.com/images/bus.jpg')

# Inspect results
result = results[0]
print(f"Image size: {result.orig_shape}")
print(f"Detected {len(result.boxes)} objects:\n")

for box in result.boxes:
    class_id   = int(box.cls)
    class_name = model.names[class_id]
    confidence = float(box.conf)
    coords     = box.xyxy[0].tolist()   # [x_min, y_min, x_max, y_max]
    print(f"  {class_name:12s}  conf={confidence:.2f}  box={[int(c) for c in coords]}")

# Save annotated image
result.save('detection_output.jpg')

from ultralytics import YOLO
import time

# Compare different YOLOv8 sizes (nano to extra-large)
models_to_compare = {
    'yolov8n': 'Nano  (3M params, fastest)',
    'yolov8s': 'Small (11M params)',
    'yolov8m': 'Medium (26M params)',
    'yolov8l': 'Large (44M params)',
    'yolov8x': 'Extra-large (68M params, most accurate)',
}

for model_name, description in models_to_compare.items():
    print(f"{model_name}: {description}")

# In practice:
# yolov8n: ~300 FPS on GPU  (real-time edge deployment)
# yolov8m: ~120 FPS on GPU  (balanced production use)
# yolov8x: ~40 FPS on GPU   (maximum accuracy)

import torch
import torch.nn as nn
import torch.nn.functional as F

class SimpleFPN(nn.Module):
    """A minimal Feature Pyramid Network to illustrate the concept."""

    def __init__(self, in_channels_list, out_channels=256):
        """
        in_channels_list: number of channels at each backbone stage,
                          e.g., [256, 512, 1024, 2048] for ResNet
        out_channels: unified channel count for all pyramid levels
        """
        super().__init__()
        # Lateral convolutions: 1x1 to unify channel counts
        self.lateral_convs = nn.ModuleList([
            nn.Conv2d(in_ch, out_channels, kernel_size=1)
            for in_ch in in_channels_list
        ])
        # Output convolutions: 3x3 to smooth the merged features
        self.output_convs = nn.ModuleList([
            nn.Conv2d(out_channels, out_channels, kernel_size=3, padding=1)
            for _ in in_channels_list
        ])

    def forward(self, features):
        """
        features: list of feature maps from backbone stages
                  [C2, C3, C4, C5] from large to small resolution
        Returns: list of FPN feature maps [P2, P3, P4, P5]
        """
        # Apply lateral convolutions to all stages
        laterals = [conv(f) for conv, f in zip(self.lateral_convs, features)]

        # Top-down pathway: merge from deepest to shallowest
        for i in range(len(laterals) - 2, -1, -1):
            # Upsample deeper layer and add to shallower layer
            upsampled = F.interpolate(laterals[i + 1],
                                      size=laterals[i].shape[-2:],
                                      mode='nearest')
            laterals[i] = laterals[i] + upsampled

        # Apply output convolutions
        outputs = [conv(lat) for conv, lat in zip(self.output_convs, laterals)]
        return outputs


# Simulate backbone feature maps from ResNet stages
batch_size = 2
backbone_features = [
    torch.randn(batch_size, 256,  80, 80),   # C2: large, shallow
    torch.randn(batch_size, 512,  40, 40),   # C3
    torch.randn(batch_size, 1024, 20, 20),   # C4
    torch.randn(batch_size, 2048, 10, 10),   # C5: small, deep
]

fpn = SimpleFPN(in_channels_list=[256, 512, 1024, 2048], out_channels=256)
pyramid_features = fpn(backbone_features)

for i, feat in enumerate(pyramid_features):
    print(f"P{i+2}: shape {feat.shape}  — detects {'large' if i < 2 else 'small'} objects")

import torch
import torch.nn as nn
import torch.nn.functional as F


class DoubleConv(nn.Module):
    """Two consecutive (Conv → BN → ReLU) blocks — the basic U-Net unit."""
    def __init__(self, in_channels, out_channels):
        super().__init__()
        self.block = nn.Sequential(
            nn.Conv2d(in_channels, out_channels, 3, padding=1, bias=False),
            nn.BatchNorm2d(out_channels),
            nn.ReLU(inplace=True),
            nn.Conv2d(out_channels, out_channels, 3, padding=1, bias=False),
            nn.BatchNorm2d(out_channels),
            nn.ReLU(inplace=True),
        )

    def forward(self, x):
        return self.block(x)


class UNet(nn.Module):
    """
    Standard U-Net for semantic segmentation.
    Encoder path: downsample with MaxPool
    Decoder path: upsample with bilinear interpolation + skip connections
    """
    def __init__(self, in_channels=3, num_classes=2, features=[64, 128, 256, 512]):
        super().__init__()

        # Encoder: series of DoubleConv + MaxPool
        self.encoders = nn.ModuleList()
        self.pools    = nn.ModuleList()
        in_ch = in_channels
        for feat in features:
            self.encoders.append(DoubleConv(in_ch, feat))
            self.pools.append(nn.MaxPool2d(2, 2))
            in_ch = feat

        # Bottleneck
        self.bottleneck = DoubleConv(features[-1], features[-1] * 2)

        # Decoder: upsample + concatenate skip + DoubleConv
        self.upconvs  = nn.ModuleList()
        self.decoders = nn.ModuleList()
        for feat in reversed(features):
            # Upsample from features[-1]*2 → feat
            self.upconvs.append(
                nn.ConvTranspose2d(feat * 2, feat, kernel_size=2, stride=2)
            )
            # After concatenation with skip: feat * 2 input channels
            self.decoders.append(DoubleConv(feat * 2, feat))

        # Final 1×1 conv: produce per-pixel class scores
        self.output_conv = nn.Conv2d(features[0], num_classes, 1)

    def forward(self, x):
        skip_connections = []

        # Encoder path
        for enc, pool in zip(self.encoders, self.pools):
            x = enc(x)
            skip_connections.append(x)
            x = pool(x)

        x = self.bottleneck(x)

        # Decoder path (reversed)
        skip_connections.reverse()
        for up, dec, skip in zip(self.upconvs, self.decoders, skip_connections):
            x = up(x)
            # Handle case where spatial dims don't match exactly
            if x.shape != skip.shape:
                x = F.interpolate(x, size=skip.shape[2:])
            x = torch.cat([skip, x], dim=1)  # concatenate along channel dim
            x = dec(x)

        return self.output_conv(x)


# Test U-Net
model = UNet(in_channels=3, num_classes=5)  # 5-class segmentation
total_params = sum(p.numel() for p in model.parameters()) / 1e6
print(f"U-Net parameters: {total_params:.1f}M")

x = torch.randn(2, 3, 256, 256)   # batch of 2, RGB, 256×256
logits = model(x)
print(f"Input:  {x.shape}")
print(f"Output: {logits.shape}")   # (2, 5, 256, 256) — per-pixel class scores

import torch
import torchvision
from torchvision.models.detection import maskrcnn_resnet50_fpn
from torchvision.models.detection import MaskRCNN_ResNet50_FPN_Weights

# Load Mask R-CNN pretrained on COCO
model = maskrcnn_resnet50_fpn(weights=MaskRCNN_ResNet50_FPN_Weights.DEFAULT)
model.eval()

# COCO class names (80 classes)
COCO_CLASSES = [
    '__background__', 'person', 'bicycle', 'car', 'motorcycle', 'airplane',
    'bus', 'train', 'truck', 'boat', 'traffic light', 'fire hydrant',
    'stop sign', 'parking meter', 'bench', 'bird', 'cat', 'dog', 'horse',
    'sheep', 'cow', 'elephant', 'bear', 'zebra', 'giraffe',
    # ... 80 total
]

# Inference
image_tensor = torch.rand(3, 480, 640)  # dummy C x H x W image
with torch.no_grad():
    predictions = model([image_tensor])

pred = predictions[0]
# pred contains: 'boxes', 'labels', 'scores', 'masks'

high_conf = pred['scores'] > 0.7
masks  = pred['masks'][high_conf]    # shape: (N, 1, H, W) — float masks
boxes  = pred['boxes'][high_conf]    # shape: (N, 4)
labels = pred['labels'][high_conf]   # shape: (N,)
scores = pred['scores'][high_conf]   # shape: (N,)

print(f"Detected {len(boxes)} high-confidence instances")
print(f"Mask tensor shape: {masks.shape}")    # (N, 1, 480, 640)

# Convert soft masks to binary
binary_masks = (masks > 0.5).squeeze(1)   # (N, H, W)  boolean
print(f"Binary mask shape: {binary_masks.shape}")

# Visualize with matplotlib (conceptual)
for i, (box, label_id, score) in enumerate(zip(boxes, labels, scores)):
    class_name = COCO_CLASSES[label_id] if label_id < len(COCO_CLASSES) else 'unknown'
    print(f"  Instance {i}: {class_name} (score={score:.2f})")

from transformers import pipeline, DetrImageProcessor, DetrForObjectDetection
from PIL import Image
import requests, torch

# Option 1: High-level pipeline (easiest)
detector = pipeline("object-detection", model="facebook/detr-resnet-50")

# Load an image
url = "http://images.cocodataset.org/val2017/000000039769.jpg"
image = Image.open(requests.get(url, stream=True).raw)

# Detect objects
results = detector(image)
for obj in results:
    label = obj['label']
    score = obj['score']
    box   = obj['box']
    print(f"  {label:12s}  score={score:.2f}  box={box}")

# Option 2: Manual DETR (more control)
processor = DetrImageProcessor.from_pretrained("facebook/detr-resnet-50")
model = DetrForObjectDetection.from_pretrained("facebook/detr-resnet-50")

inputs = processor(images=image, return_tensors="pt")
with torch.no_grad():
    outputs = model(**inputs)

# Convert outputs to bounding boxes
target_sizes = torch.tensor([image.size[::-1]])  # (H, W)
detr_results = processor.post_process_object_detection(
    outputs, threshold=0.9, target_sizes=target_sizes
)[0]

print(f"\nDETR high-confidence detections: {len(detr_results['boxes'])}")

# Model comparison on COCO val2017
# (representative published numbers — actual results vary with training setup)

detection_benchmarks = {
    "Faster R-CNN (R50-FPN)": {"mAP@0.5": 58.1, "mAP@0.5:0.95": 37.0, "FPS": 15},
    "YOLOv8n":                {"mAP@0.5": 52.9, "mAP@0.5:0.95": 37.3, "FPS": 312},
    "YOLOv8x":                {"mAP@0.5": 68.9, "mAP@0.5:0.95": 53.9, "FPS": 52},
    "DETR (R50)":             {"mAP@0.5": 63.3, "mAP@0.5:0.95": 42.0, "FPS": 28},
}

print(f"{'Model':<30} {'mAP@0.5':>8} {'mAP@.5:.95':>12} {'FPS':>6}")
print("-" * 60)
for model_name, metrics in detection_benchmarks.items():
    print(f"{model_name:<30} {metrics['mAP@0.5']:>8.1f} "
          f"{metrics['mAP@0.5:0.95']:>12.1f} {metrics['FPS']:>6}")