akashch1512's picture
fix: match v5 checkpoint architecture and benchmark scaled inference
5878871 verified
Raw History Blame Contribute Delete
4.59 kB
"""Test-time augmentation: the 8 elements of D4, optionally x scales.
Nadir imagery has no canonical up, so flips and 90-degree rotations are exact
symmetries of the task — averaging over them is free accuracy. v2 implemented
this and then never ran it: the process crashed before the final eval, so no TTA
number was ever produced.
"""
from __future__ import annotations
import torch
import torch.nn.functional as F
_D4 = [(k, f) for f in (False, True) for k in range(4)]
def _apply(x, k, flip):
x = torch.rot90(x, k, dims=(-2, -1))
return torch.flip(x, dims=(-1,)) if flip else x
def _invert(x, k, flip):
if flip:
x = torch.flip(x, dims=(-1,))
return torch.rot90(x, -k, dims=(-2, -1))
@torch.no_grad()
def tta_predict(model, image, scales=(1.0,), key: str = "fused",
patch: int = 16, amp_dtype=None) -> torch.Tensor:
h, w = image.shape[-2:]
acc = torch.zeros((image.shape[0], 1, h, w), device=image.device, dtype=torch.float32)
n = 0
for s in scales:
if abs(s - 1.0) < 1e-6:
img_s = image
else:
nh = max(patch, int(round(h * s / patch)) * patch)
nw = max(patch, int(round(w * s / patch)) * patch)
img_s = F.interpolate(image, size=(nh, nw), mode="bilinear", align_corners=False)
for k, flip in _D4:
ctx = (torch.autocast("cuda", dtype=amp_dtype)
if (amp_dtype is not None and image.is_cuda)
else torch.autocast("cpu", enabled=False))
with ctx:
pred = model(_apply(img_s, k, flip))[key]
pred = _invert(pred.float(), k, flip)
if pred.shape[-2:] != (h, w):
pred = F.interpolate(pred, size=(h, w), mode="bilinear", align_corners=False)
acc += pred
n += 1
return acc / max(1, n)
def n_views(scales=(1.0,), d4: bool = True) -> int:
"""Forward passes per tile under `tta_predict_parallel`."""
return (len(_D4) if d4 else 1) * max(1, len(scales))
@torch.no_grad()
def tta_predict_parallel(forward, image, scales=(1.0,), patch: int = 16,
d4: bool = True):
"""`tta_predict`, but every D4 view of the batch goes through the net *together*.
The sequential version runs 8 small forwards per batch, which leaves a large
GPU mostly idle. A square tile keeps its shape under rot90/flip, so the 8
views stack along the batch axis and `forward` sees one (8B, 3, S, S) batch
per scale; it is free to split that into whatever fits in memory.
`forward(x) -> (pred, std, seg)`. Average first and second moments across
views so the returned spread includes both bin uncertainty and TTA disagreement.
"""
b, _, h, w = image.shape
transforms = _D4 if d4 else [(0, False)]
acc = torch.zeros((b, 1, h, w), device=image.device, dtype=torch.float32)
acc_m2 = torch.zeros_like(acc)
seg_id, n = None, 0
for s in scales:
if abs(s - 1.0) < 1e-6:
img_s = image
else:
nh = max(patch, int(round(h * s / patch)) * patch)
nw = max(patch, int(round(w * s / patch)) * patch)
img_s = F.interpolate(image, size=(nh, nw), mode="bilinear", align_corners=False)
views = torch.cat([_apply(img_s, k, flip) for k, flip in transforms])
pred, pred_std, seg = forward(views)
for i, (k, flip) in enumerate(transforms):
p = _invert(pred[i * b:(i + 1) * b], k, flip)
p_slice = pred[i * b:(i + 1) * b]
m2_slice = p_slice.square()
if pred_std is not None:
m2_slice = m2_slice + pred_std[i * b:(i + 1) * b].square()
m2 = _invert(m2_slice, k, flip)
if p.shape[-2:] != (h, w):
p = F.interpolate(p, size=(h, w), mode="bilinear", align_corners=False)
m2 = F.interpolate(m2, size=(h, w), mode="bilinear", align_corners=False)
acc += p
acc_m2 += m2
n += 1
# Prefer the native identity labels; scaled-only inference uses its
# identity labels returned to the target grid with nearest sampling.
if seg is not None and (seg_id is None or img_s is image):
seg_id = seg[:b]
if seg_id.shape[-2:] != (h, w):
seg_id = F.interpolate(seg_id[:, None].float(), size=(h, w),
mode="nearest")[:, 0].to(seg.dtype)
mean = acc / max(1, n)
std = (acc_m2 / max(1, n) - mean.square()).clamp_min(0).sqrt()
return mean, std, seg_id