slide2vec 5.1.0__tar.gz → 5.1.1__tar.gz

{slide2vec-5.1.0 → slide2vec-5.1.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: slide2vec
-Version: 5.1.0
+Version: 5.1.1
 Summary: Embedding of whole slide images with Foundation Models
 Author-email: Clément Grisi <clement.grisi@radboudumc.nl>
 License-Expression: Apache-2.0

{slide2vec-5.1.0 → slide2vec-5.1.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "slide2vec"
-version = "5.1.0"
+version = "5.1.1"
 description = "Embedding of whole slide images with Foundation Models"
 readme = "README.md"
 requires-python = ">=3.10"
@@ -167,7 +167,7 @@ no_implicit_reexport = true
 max-line-length = 160
 
 [tool.bumpver]
-current_version = "5.1.0"
+current_version = "5.1.1"
 version_pattern = "MAJOR.MINOR.PATCH"
 commit = false       # We do version bumping in CI, not as a commit
 tag = false          # Git tag already exists — we don't auto-tag

{slide2vec-5.1.0 → slide2vec-5.1.1}/slide2vec/__init__.py

@@ -11,7 +11,7 @@ from slide2vec.api import (
 from slide2vec.artifacts import HierarchicalEmbeddingArtifact, SlideEmbeddingArtifact, TileEmbeddingArtifact
 
 
-__version__ = "5.1.0"
+__version__ = "5.1.1"
 
 __all__ = [
     "Model",

{slide2vec-5.1.0 → slide2vec-5.1.1}/slide2vec/runtime/dense_regions.py

@@ -39,9 +39,31 @@ import torch
 import torch.nn.functional as F
 from PIL import Image
 
+from slide2vec.runtime.batching import autocast_dtype
 from slide2vec.runtime.dense_sliding import encode_dense_sliding
 from slide2vec.runtime.slide_encode import slide_encode_autocast_ctx
 
+
+def _resolve_output_dtype(output_dtype: "torch.dtype | None", precision: str) -> "torch.dtype":
+    """Resolve the dtype emitted grids are materialized in.
+
+    Defaults (``output_dtype is None``) to the model's compute precision — fp16 runs
+    yield fp16 grids — so the engine no longer force-upcasts everything to float32.
+    numpy has no bfloat16, so a bf16 compute precision widens to float32 (its lossless
+    container) and an *explicit* ``torch.bfloat16`` request is rejected: the grid is
+    materialized via ``.numpy()`` and bfloat16 cannot cross that boundary.
+    """
+    if output_dtype is None:
+        compute = autocast_dtype(torch, precision)  # float16 | bfloat16 | None(fp32)
+        return torch.float16 if compute == torch.float16 else torch.float32
+    if output_dtype == torch.bfloat16:
+        raise ValueError(
+            "output_dtype=torch.bfloat16 cannot be materialized as a numpy grid; "
+            "request torch.float16 or torch.float32"
+        )
+    return output_dtype
+
+
 _PAD_MODES = {"reflect", "constant", "zero", "replicate"}
 
 
@@ -161,14 +183,16 @@ def iter_regions_dense(
     attention_include_registers: bool = False,
     batch_size: int = 1,
     precision: str = "fp32",
+    output_dtype: "torch.dtype | None" = None,
     dense_transform: Callable | None = None,
 ) -> Iterator[np.ndarray]:
     """Stream slide regions at ``coordinates`` into dense grids, one per coordinate.
 
-    Yields one ``(d, grid_h, grid_w)`` ``float32`` grid per coordinate, in coordinate
-    order. Regions are read and encoded one ``batch_size`` chunk at a time, so resident
-    host memory is bounded by ``batch_size`` rather than by a slide's ROI count (the loop
-    holds at most one batch of grids resident — no per-slide accumulation).
+    Yields one ``(d, grid_h, grid_w)`` grid per coordinate, in coordinate order, in the
+    model's compute ``precision`` by default (fp16 runs yield fp16 grids; see
+    ``output_dtype``). Regions are read and encoded one ``batch_size`` chunk at a time, so
+    resident host memory is bounded by ``batch_size`` rather than by a slide's ROI count
+    (the loop holds at most one batch of grids resident — no per-slide accumulation).
 
     Injectable core: takes a constructed dense-capable ``model`` (with
     ``encode_tiles_dense`` / ``encode_tiles_attention`` / ``patch_size`` /
@@ -194,8 +218,12 @@ def iter_regions_dense(
             sliding is internal to extraction.
         overlap: fractional window overlap in ``[0, 1)`` for the sliding path (ignored when
             ``window_size is None``); the stride is ``window * (1 - overlap)``.
+        output_dtype: torch dtype the grids are materialized in. ``None`` (default) follows
+            the compute ``precision`` — fp16 → fp16, fp32 → fp32, bf16 → fp32 (numpy has no
+            bfloat16). Pass e.g. ``torch.float32`` to force a lossless cache regardless of
+            precision; an explicit ``torch.bfloat16`` is rejected (cannot cross ``.numpy()``).
 
-    Yields ``float32`` grids in coordinate order; empty ``coordinates`` yields nothing.
+    Yields grids in coordinate order in ``output_dtype``; empty ``coordinates`` yields nothing.
     ``feature_kind`` selects ``encode_tiles_dense`` (patch grid) vs
     ``encode_tiles_attention`` (CLS-attention grid); both produce a ``(C, gh, gw)`` grid and
     share this path. Each yielded grid is a standalone contiguous copy, so it does not pin
@@ -203,6 +231,7 @@ def iter_regions_dense(
     """
     if pad_mode not in _PAD_MODES:
         raise ValueError(f"unsupported pad_mode {pad_mode!r}; expected one of {sorted(_PAD_MODES)}")
+    resolved_output_dtype = _resolve_output_dtype(output_dtype, precision)
     geometry = compute_dense_geometry(target_size=target_size, patch_size=model.patch_size)
     if dense_transform is None:
         dense_transform = model.get_dense_transform()
@@ -262,7 +291,7 @@ def iter_regions_dense(
                     raise ValueError(
                         f"{feature_kind} encode returned a {out.ndim}-D tensor; expected (B, d, gh, gw)."
                     )
-                batch_np = out.detach().float().cpu().numpy()
+                batch_np = out.detach().to(resolved_output_dtype).cpu().numpy()
                 for i in range(batch_np.shape[0]):
                     # Standalone C-contiguous copy: a per-row view would pin the whole
                     # batch alive (the blended sliding output is contiguous, so a view of

{slide2vec-5.1.0 → slide2vec-5.1.1}/slide2vec.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: slide2vec
-Version: 5.1.0
+Version: 5.1.1
 Summary: Embedding of whole slide images with Foundation Models
 Author-email: Clément Grisi <clement.grisi@radboudumc.nl>
 License-Expression: Apache-2.0

{slide2vec-5.1.0 → slide2vec-5.1.1}/tests/test_dense_regions.py

@@ -18,6 +18,7 @@ timm = pytest.importorskip("timm")
 
 from slide2vec.encoders.base import TimmTileEncoder  # noqa: E402
 from slide2vec.runtime.dense_regions import (  # noqa: E402
+    _resolve_output_dtype,
     compute_dense_geometry,
     iter_regions_dense,
     pad_image_to_encoded,
@@ -219,3 +220,45 @@ def test_iter_regions_dense_validates_eagerly_before_any_read(kwargs):
             requested_spacing_um=0.5, target_size=target_size, **kwargs,
         )
     assert wsi.calls == []
+
+
+@pytest.mark.parametrize(
+    "precision,expected",
+    [("fp16", torch.float16), ("fp32", torch.float32), ("bf16", torch.float32)],
+    ids=["fp16->fp16", "fp32->fp32", "bf16->fp32(numpy-safe)"],
+)
+def test_resolve_output_dtype_defaults_follow_precision(precision, expected):
+    # output_dtype=None tracks the compute precision; bf16 widens to fp32 (numpy has no
+    # bfloat16). An explicit dtype overrides; an explicit bfloat16 is rejected.
+    assert _resolve_output_dtype(None, precision) is expected
+    assert _resolve_output_dtype(torch.float32, precision) is torch.float32
+    assert _resolve_output_dtype(torch.float16, precision) is torch.float16
+    with pytest.raises(ValueError):
+        _resolve_output_dtype(torch.bfloat16, precision)
+
+
+@pytest.mark.parametrize("dtype,np_dtype", [(torch.float16, np.float16), (torch.float32, np.float32)])
+def test_iter_regions_dense_honours_output_dtype(dtype, np_dtype):
+    """An explicit output_dtype materializes the grids in that dtype, deterministically."""
+    enc = _encoder()
+    target_size = 64
+    wsi = _FakeWSI(target_h=target_size, target_w=target_size)
+    grids = list(iter_regions_dense(
+        model=enc, device="cpu", wsi=wsi, coordinates=[(0, 0)],
+        requested_spacing_um=0.5, target_size=target_size, output_dtype=dtype,
+    ))
+    assert len(grids) == 1
+    assert grids[0].dtype == np_dtype
+
+
+def test_iter_regions_dense_rejects_bfloat16_output_eagerly():
+    """output_dtype=bfloat16 (uncrossable by .numpy()) raises at the call site, no read."""
+    enc = _encoder()
+    target_size = 64
+    wsi = _FakeWSI(target_h=target_size, target_w=target_size)
+    with pytest.raises(ValueError):
+        iter_regions_dense(
+            model=enc, device="cpu", wsi=wsi, coordinates=[(0, 0)],
+            requested_spacing_um=0.5, target_size=target_size, output_dtype=torch.bfloat16,
+        )
+    assert wsi.calls == []