Practice Questions & Tips

import numpy as np

def conv2d(image, kernel, stride=1, padding=0):
    """Implement 2D convolution from scratch.

    Args:
        image: (H, W) numpy array
        kernel: (kH, kW) numpy array
        stride: step size
        padding: zero-padding around the image

    Returns:
        (out_H, out_W) convolved output
    """
    # Add padding
    if padding > 0:
        image = np.pad(image, padding, mode='constant', constant_values=0)

    H, W = image.shape
    kH, kW = kernel.shape
    out_H = (H - kH) // stride + 1
    out_W = (W - kW) // stride + 1

    output = np.zeros((out_H, out_W))

    for i in range(out_H):
        for j in range(out_W):
            # Extract the receptive field
            region = image[i*stride:i*stride+kH, j*stride:j*stride+kW]
            # Element-wise multiply and sum
            output[i, j] = np.sum(region * kernel)

    return output


# Test with edge detection kernel
image = np.random.rand(8, 8)
sobel_x = np.array([[-1, 0, 1], [-2, 0, 2], [-1, 0, 1]])
edges = conv2d(image, sobel_x, stride=1, padding=1)
print(f"Input: {image.shape}, Output: {edges.shape}")  # Both (8, 8)

import torch
from torch.utils.data import Dataset
from torchvision import transforms as T
from PIL import Image
import os

class CustomImageDataset(Dataset):
    def __init__(self, root_dir, split="train"):
        self.root_dir = root_dir
        self.split = split

        # Collect image paths and labels
        self.samples = []
        self.class_to_idx = {}
        for idx, class_name in enumerate(sorted(os.listdir(root_dir))):
            class_dir = os.path.join(root_dir, class_name)
            if not os.path.isdir(class_dir):
                continue
            self.class_to_idx[class_name] = idx
            for img_name in os.listdir(class_dir):
                if img_name.lower().endswith(('.jpg', '.jpeg', '.png')):
                    self.samples.append((
                        os.path.join(class_dir, img_name), idx
                    ))

        # Different transforms for train vs val
        if split == "train":
            self.transform = T.Compose([
                T.RandomResizedCrop(224, scale=(0.08, 1.0)),
                T.RandomHorizontalFlip(),
                T.ColorJitter(0.4, 0.4, 0.4, 0.1),
                T.RandomGrayscale(p=0.1),
                T.GaussianBlur(kernel_size=3, sigma=(0.1, 2.0)),
                T.ToTensor(),
                T.Normalize([0.485, 0.456, 0.406],
                            [0.229, 0.224, 0.225]),
                T.RandomErasing(p=0.25),
            ])
        else:
            self.transform = T.Compose([
                T.Resize(256),
                T.CenterCrop(224),
                T.ToTensor(),
                T.Normalize([0.485, 0.456, 0.406],
                            [0.229, 0.224, 0.225]),
            ])

    def __len__(self):
        return len(self.samples)

    def __getitem__(self, idx):
        path, label = self.samples[idx]
        image = Image.open(path).convert("RGB")
        image = self.transform(image)
        return image, label


# Usage
train_ds = CustomImageDataset("/data/images", split="train")
val_ds = CustomImageDataset("/data/images", split="val")
print(f"Train: {len(train_ds)} images, {len(train_ds.class_to_idx)} classes")

import numpy as np

def compute_ap(recalls, precisions):
    """Compute Average Precision using all-point interpolation."""
    # Add sentinel values
    recalls = np.concatenate(([0.0], recalls, [1.0]))
    precisions = np.concatenate(([1.0], precisions, [0.0]))

    # Make precision monotonically decreasing (right to left)
    for i in range(len(precisions) - 2, -1, -1):
        precisions[i] = max(precisions[i], precisions[i + 1])

    # Find points where recall changes
    change_points = np.where(recalls[1:] != recalls[:-1])[0] + 1

    # Sum (delta_recall * precision)
    ap = np.sum((recalls[change_points] - recalls[change_points - 1]) *
                precisions[change_points])
    return ap

def compute_map(all_detections, all_ground_truths, iou_threshold=0.5):
    """Compute mAP across all classes.

    Args:
        all_detections: dict of {class: [(image_id, confidence, box), ...]}
        all_ground_truths: dict of {class: {image_id: [box, ...], ...}}

    Returns:
        mAP value
    """
    aps = []

    for cls in all_ground_truths:
        dets = sorted(all_detections.get(cls, []),
                       key=lambda x: x[1], reverse=True)

        # Count total ground truths for this class
        n_gt = sum(len(boxes) for boxes in all_ground_truths[cls].values())
        if n_gt == 0:
            continue

        # Track which GTs have been matched
        matched = {img_id: [False] * len(boxes)
                   for img_id, boxes in all_ground_truths[cls].items()}

        tp = np.zeros(len(dets))
        fp = np.zeros(len(dets))

        for i, (img_id, conf, det_box) in enumerate(dets):
            gt_boxes = all_ground_truths[cls].get(img_id, [])
            best_iou = 0
            best_gt_idx = -1

            for j, gt_box in enumerate(gt_boxes):
                iou = compute_single_iou(det_box, gt_box)
                if iou > best_iou:
                    best_iou = iou
                    best_gt_idx = j

            if best_iou >= iou_threshold and not matched[img_id][best_gt_idx]:
                tp[i] = 1
                matched[img_id][best_gt_idx] = True
            else:
                fp[i] = 1

        tp_cumsum = np.cumsum(tp)
        fp_cumsum = np.cumsum(fp)
        recalls = tp_cumsum / n_gt
        precisions = tp_cumsum / (tp_cumsum + fp_cumsum)

        ap = compute_ap(recalls, precisions)
        aps.append(ap)

    return np.mean(aps) if aps else 0.0