Detecting very small objects

pip install torch torchvision

import torch
from torchvision.ops import box_iou, batched_nms

# --- 1. Resizing is where most small objects die, before the model even runs.
W, H = 4000, 3000                                   # a drone photo
for target in [640, 1024, 1280]:
    scale = target / max(W, H)
    print(f"resize longest side to {target:>4}: scale {scale:.3f}  "
          f"a 30px object becomes {30 * scale:4.1f}px, a 12px object becomes {12 * scale:4.1f}px")

# --- 2. How many grid cells a small object gets at each detector stride.
print("\ngrid cells covered by an object at each stride:")
print(f"{'object':>10}{'stride 4':>11}{'stride 8':>11}{'stride 16':>11}{'stride 32':>11}")
for size in [8, 16, 32, 64]:
    row = "".join(f"{(size / s) ** 2:>11.2f}" for s in (4, 8, 16, 32))
    print(f"{f'{size}x{size}':>10}" + row)

# --- 3. Anchor coverage: a standard anchor set barely touches a tiny box.
anchors = []
for size in (32, 64, 128, 256, 512):
    for ratio in (0.5, 1.0, 2.0):
        w, h = size * ratio ** 0.5, size / ratio ** 0.5
        anchors.append([100 - w / 2, 100 - h / 2, 100 + w / 2, 100 + h / 2])
anchors = torch.tensor(anchors)
print("\nbest IoU between a perfectly centred standard anchor set and one object:")
for s in [8, 12, 16, 24, 32, 64]:
    gt = torch.tensor([[100. - s / 2, 100. - s / 2, 100. + s / 2, 100. + s / 2]])
    print(f"  {s:>2}x{s:<2} object -> best IoU {box_iou(anchors, gt).max():.3f}")

# --- 4. Tiling: cut the picture up, detect on each piece, put the boxes back.
def tiles(width, height, size=640, overlap=0.2):
    step = int(size * (1 - overlap))
    xs = list(range(0, max(width - size, 0) + 1, step)) or [0]
    ys = list(range(0, max(height - size, 0) + 1, step)) or [0]
    if xs[-1] + size < width:
        xs.append(width - size)
    if ys[-1] + size < height:
        ys.append(height - size)
    return [(x, y) for y in ys for x in xs]

grid = tiles(4000, 3000, size=640, overlap=0.2)
print(f"\n4000x3000 image, 640 tiles, 20 percent overlap: {len(grid)} tiles")
print(f"  first four origins: {grid[:4]}")
print("  each tile is fed at native resolution, so a 12px object stays 12px")

# One object sitting on a tile seam gets found twice, in two coordinate systems.
obj = torch.tensor([1290., 500., 1330., 545.])          # 40x45 px, near a seam
found = []
for (tx, ty) in grid:
    tile = torch.tensor([tx, ty, tx + 640, ty + 640], dtype=torch.float32)
    inter = torch.tensor([max(obj[0], tile[0]), max(obj[1], tile[1]),
                          min(obj[2], tile[2]), min(obj[3], tile[3])])
    if inter[2] > inter[0] and inter[3] > inter[1]:
        local = inter - torch.tensor([tx, ty, tx, ty])   # tile-local coordinates
        found.append(((tx, ty), local, inter))

print(f"\nthe object at {[int(v) for v in obj.tolist()]} falls inside {len(found)} tiles:")
for (tx, ty), local, glob in found:
    print(f"  tile ({tx:>4},{ty:>4})  local {[round(v.item(), 1) for v in local]}"
          f"  -> global {[round(v.item(), 1) for v in glob]}")

boxes = torch.stack([g for _, _, g in found])
scores = torch.tensor([0.81, 0.88])
labels = torch.zeros(len(boxes), dtype=torch.long)
print("\nIoU between the two partial detections:",
      round(box_iou(boxes[:1], boxes[1:]).max().item(), 3))
keep = batched_nms(boxes, scores, labels, 0.4)
print("NMS keeps  :", [[round(v, 1) for v in boxes[i].tolist()] for i in keep.tolist()])
merged = torch.stack([boxes[:, 0].min(), boxes[:, 1].min(),
                      boxes[:, 2].max(), boxes[:, 3].max()])
print("union merge:", [round(v.item(), 1) for v in merged])
print("true box   :", [round(v, 1) for v in obj.tolist()])

import torch
from torchvision.ops import batched_nms

def tiled_detect(detect_fn, image, tile=640, overlap=0.2, batch=8):
    """detect_fn(batch_of_tiles) -> list of (boxes_xyxy, scores, labels) per tile."""
    _, H, W = image.shape
    step = int(tile * (1 - overlap))
    xs = sorted({*range(0, max(W - tile, 0) + 1, step), max(W - tile, 0)})
    ys = sorted({*range(0, max(H - tile, 0) + 1, step), max(H - tile, 0)})
    origins = [(x, y) for y in ys for x in xs]

    all_boxes, all_scores, all_labels = [], [], []
    for i in range(0, len(origins), batch):
        chunk = origins[i:i + batch]
        crops = torch.stack([image[:, y:y + tile, x:x + tile] for x, y in chunk])
        for (x, y), (b, s, l) in zip(chunk, detect_fn(crops)):
            if len(b) == 0:
                continue
            b = b + torch.tensor([x, y, x, y], dtype=b.dtype)   # tile -> image coords
            all_boxes.append(b); all_scores.append(s); all_labels.append(l)

    if not all_boxes:
        return torch.zeros(0, 4), torch.zeros(0), torch.zeros(0, dtype=torch.long)
    boxes = torch.cat(all_boxes); scores = torch.cat(all_scores); labels = torch.cat(all_labels)
    keep = batched_nms(boxes, scores, labels, 0.5)
    return boxes[keep], scores[keep], labels[keep]

# A fake detector so this runs with no weights: it "finds" one box per tile.
def fake_detect(crops):
    n = crops.shape[0]
    return [(torch.tensor([[100., 100., 140., 145.]]),
             torch.tensor([0.9]),
             torch.tensor([0])) for _ in range(n)]

img = torch.zeros(3, 1500, 2000)
b, s, l = tiled_detect(fake_detect, img)
print("tiles processed :", len(sorted({*range(0, 2000 - 640 + 1, 512), 1360})) *
                            len(sorted({*range(0, 1500 - 640 + 1, 512), 860})))
print("detections kept :", len(b))
print("first box       :", [round(v, 1) for v in b[0].tolist()])
print("last box        :", [round(v, 1) for v in b[-1].tolist()])