attr-eomt 1.2.0__tar.gz → 1.2.1__tar.gz

{attr_eomt-1.2.0 → attr_eomt-1.2.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: attr-eomt
-Version: 1.2.0
+Version: 1.2.1
 Summary: Standalone EoMT (Encoder-only Mask Transformer) for instance segmentation, with DINOv2 init, COCO training/validation and inference.
 Project-URL: Homepage, https://github.com/imagra93/attr-eomt
 Project-URL: Documentation, https://imagra93.github.io/attr-eomt

{attr_eomt-1.2.0 → attr_eomt-1.2.1}/eomt/preprocess.py

@@ -13,10 +13,14 @@ needs to map masks back to the original image (see :func:`make_preprocess_meta`)
 
 from __future__ import annotations
 
+import functools
+
 import numpy as np
 
 IMAGENET_MEAN = np.array([0.485, 0.456, 0.406], dtype=np.float32)
 IMAGENET_STD = np.array([0.229, 0.224, 0.225], dtype=np.float32)
+#: Fixed-point precision of PIL's 8-bit resampling (Pillow's Resample.c).
+_PIL_PRECISION_BITS = 32 - 8 - 2
 
 
 def make_preprocess_meta(letterbox: bool, content_hw: tuple[int, int], input_size: int) -> dict:
@@ -67,6 +71,47 @@ def preprocess_numpy(
     return chw, make_preprocess_meta(True, (nh, nw), input_size)
 
 
+@functools.lru_cache(maxsize=64)
+def _pil_bilinear_taps(in_size: int, out_size: int) -> tuple[np.ndarray, np.ndarray]:
+    """PIL's fixed-point bilinear coefficients for resizing ``in_size`` px to ``out_size``.
+
+    Mirrors ``precompute_coeffs`` and ``normalize_coeffs_8bpc`` of Pillow's Resample.c. Returns the input index and
+    the integer weight of every tap, both ``(out_size, taps)``; padding taps have weight 0.
+    """
+    scale = in_size / out_size
+    filterscale = max(scale, 1.0)
+    support = filterscale  # the bilinear filter's support is 1
+    center = (np.arange(out_size) + 0.5) * scale
+    xmin = np.maximum((center - support + 0.5).astype(np.int64), 0)  # C's (int) truncation
+    xmax = np.minimum((center + support + 0.5).astype(np.int64), in_size)
+    x = xmin[:, None] + np.arange(int(np.ceil(support)) * 2 + 1)
+    w = np.maximum(1.0 - np.abs((x - center[:, None] + 0.5) * (1.0 / filterscale)), 0.0) * (x < xmax[:, None])
+    total = np.cumsum(w, axis=1)[:, -1:]  # summed in order, as PIL does
+    w = np.divide(w, total, out=np.zeros_like(w), where=total != 0)
+    return np.minimum(x, in_size - 1), np.floor(0.5 + w * (1 << _PIL_PRECISION_BITS)).astype(np.int32)
+
+
+def _pil_resize(x, nh: int, nw: int):
+    """Resize a ``(C, H, W)`` int32 image as PIL's ``Image.resize(..., BILINEAR)`` does an 8-bit one, bit for bit:
+    a horizontal then a vertical pass, each rounded to uint8."""
+    import torch
+
+    half = 1 << (_PIL_PRECISION_BITS - 1)
+    if nw != x.shape[2]:
+        idx, k = (torch.from_numpy(a).to(x.device) for a in _pil_bilinear_taps(x.shape[2], nw))
+        acc = torch.full((x.shape[0], x.shape[1], nw), half, dtype=torch.int32, device=x.device)
+        for t in range(k.shape[1]):
+            acc += x[:, :, idx[:, t]] * k[:, t]
+        x = (acc >> _PIL_PRECISION_BITS).clamp_(0, 255)
+    if nh != x.shape[1]:
+        idx, k = (torch.from_numpy(a).to(x.device) for a in _pil_bilinear_taps(x.shape[1], nh))
+        acc = torch.full((x.shape[0], nh, x.shape[2]), half, dtype=torch.int32, device=x.device)
+        for t in range(k.shape[1]):
+            acc += x[:, idx[:, t], :] * k[:, t, None]
+        x = (acc >> _PIL_PRECISION_BITS).clamp_(0, 255)
+    return x
+
+
 def preprocess_torch(
     img_rgb_hwc: np.ndarray,
     input_size: int,
@@ -76,13 +121,12 @@ def preprocess_torch(
     std=None,
     device="cpu",
 ):
-    """:func:`preprocess_numpy` run with torch on ``device`` (e.g. the model's GPU).
+    """:func:`preprocess_numpy` run with torch on ``device`` (e.g. the model's GPU), with the same result.
 
-    The resize is an antialiased bilinear one rounded to uint8, as PIL's, so the result matches
-    :func:`preprocess_numpy` within one grey level. Returns ``(chw_float32_tensor, meta)``.
+    The resize reproduces PIL's fixed-point bilinear one, so the output equals :func:`preprocess_numpy`'s.
+    Returns ``(chw_float32_tensor, meta)``.
     """
     import torch
-    import torch.nn.functional as F  # noqa: N812
 
     h, w = img_rgb_hwc.shape[:2]
     if letterbox:
@@ -90,10 +134,11 @@ def preprocess_torch(
         nh, nw = max(1, round(h * scale)), max(1, round(w * scale))
     else:
         nh, nw = input_size, input_size
-    x = torch.from_numpy(np.ascontiguousarray(img_rgb_hwc)).to(device).permute(2, 0, 1)[None].float()
-    x = F.interpolate(x, size=(nh, nw), mode="bilinear", antialias=True, align_corners=False).round_()
+    x = torch.from_numpy(np.ascontiguousarray(img_rgb_hwc)).to(device).permute(2, 0, 1).to(torch.int32)
+    x = _pil_resize(x, nh, nw).float()
     mean = torch.as_tensor(IMAGENET_MEAN if mean is None else mean, dtype=torch.float32, device=device).view(3, 1, 1)
     std = torch.as_tensor(IMAGENET_STD if std is None else std, dtype=torch.float32, device=device).view(3, 1, 1)
+    levels = torch.full((3, 1, 1), 255.0, device=device)  # not a scalar, which torch would divide by as x * (1 / 255)
     chw = x.new_zeros((3, input_size, input_size))  # 0 == mean post-normalize
-    chw[:, :nh, :nw] = (x[0] / 255.0 - mean) / std
+    chw[:, :nh, :nw] = (x / levels - mean) / std
     return chw, make_preprocess_meta(letterbox, (nh, nw), input_size)

{attr_eomt-1.2.0 → attr_eomt-1.2.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "attr-eomt"
-version = "1.2.0"
+version = "1.2.1"
 description = "Standalone EoMT (Encoder-only Mask Transformer) for instance segmentation, with DINOv2 init, COCO training/validation and inference."
 readme = "README.md"
 requires-python = ">=3.10"

{attr_eomt-1.2.0 → attr_eomt-1.2.1}/tests/test_smoke.py

@@ -514,18 +514,23 @@ def test_preprocess_letterbox_meta_and_padding():
     assert not meta2["letterbox"] and meta2["content_hw"] == (20, 20)
 
 
+@pytest.mark.parametrize("device", ["cpu", pytest.param("cuda", marks=pytest.mark.skipif(
+    not torch.cuda.is_available(), reason="no GPU"))])
 @pytest.mark.parametrize("letterbox", [True, False])
-def test_preprocess_torch_matches_preprocess_numpy_within_one_grey_level(letterbox):
+@pytest.mark.parametrize("shape, size", [((97, 151), 64), ((720, 1280), 644), ((300, 200), 644), ((5, 900), 140)])
+def test_preprocess_torch_equals_preprocess_numpy(shape, size, letterbox, device):
+    """Downscaled, upscaled and extreme aspect ratios: the same input as PIL's, value for value."""
     import numpy as np
 
-    from eomt.preprocess import IMAGENET_STD, preprocess_numpy, preprocess_torch
+    from eomt.preprocess import preprocess_numpy, preprocess_torch
 
-    img = np.random.default_rng(0).integers(0, 255, (97, 151, 3), dtype=np.uint8)
-    chw, meta = preprocess_torch(img, 64, letterbox=letterbox)
-    expected, expected_meta = preprocess_numpy(img, 64, letterbox=letterbox)
-    assert chw.shape == (3, 64, 64) and chw.dtype == torch.float32 and meta == expected_meta
-    diff = np.abs(chw.numpy() - expected) * IMAGENET_STD.reshape(3, 1, 1) * 255  # in grey levels
-    assert diff.max() <= 1.01 and diff.mean() < 0.25
+    img = np.random.default_rng(0).integers(0, 256, (*shape, 3), dtype=np.uint8)
+    chw, meta = preprocess_torch(img, size, letterbox=letterbox, mean=(0.5, 0.4, 0.3), std=(0.2, 0.3, 0.25),
+                                 device=device)
+    expected, expected_meta = preprocess_numpy(img, size, letterbox=letterbox, mean=(0.5, 0.4, 0.3),
+                                               std=(0.2, 0.3, 0.25))
+    assert chw.shape == (3, size, size) and chw.dtype == torch.float32 and meta == expected_meta
+    assert np.array_equal(chw.cpu().numpy(), expected)
 
 
 def test_letterbox_inverse_crops_content_not_padding():

{attr_eomt-1.2.0 → attr_eomt-1.2.1}/tests/test_tta.py

@@ -178,7 +178,7 @@ def test_device_preprocessed_views_find_the_same_instances():
     cpu = predict_views(_Blobs(), img, cfg, imgsz=IMGSZ, conf_thres=0.3)
     dev = predict_views(_Blobs(), img, cfg, imgsz=IMGSZ, conf_thres=0.3, device_preprocess=True)
     assert dev["num_detections"] == cpu["num_detections"] == 1
-    assert torch.allclose(dev["scores"], cpu["scores"]) and _same(dev["masks"], cpu["masks"])
+    assert torch.equal(dev["scores"], cpu["scores"]) and torch.equal(dev["masks"], cpu["masks"])
 
 
 def test_predict_image_with_tta_keeps_the_result_contract():