slide2vec 5.6.0__tar.gz → 5.7.0__tar.gz

{slide2vec-5.6.0 → slide2vec-5.7.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: slide2vec
-Version: 5.6.0
+Version: 5.7.0
 Summary: Embedding of whole slide images with Foundation Models
 Author-email: Clément Grisi <clement.grisi@radboudumc.nl>
 License-Expression: Apache-2.0
@@ -15,7 +15,7 @@ Classifier: Programming Language :: Python :: 3.13
 Requires-Python: >=3.10
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: hs2p[asap,cucim,openslide,sam2,vips]>=4.4.0
+Requires-Dist: hs2p[asap,cucim,openslide,sam2,vips]>=4.4.1
 Requires-Dist: omegaconf
 Requires-Dist: matplotlib
 Requires-Dist: numpy<2
@@ -47,6 +47,12 @@ Requires-Dist: einops==0.8.0; extra == "prism"
 Requires-Dist: environs==11.0.0; extra == "prism"
 Requires-Dist: sacremoses==0.1.1; extra == "prism"
 Requires-Dist: xformers==0.0.31; extra == "prism"
+Provides-Extra: prism2
+Requires-Dist: torch>=2.3; extra == "prism2"
+Requires-Dist: transformers==4.51.3; extra == "prism2"
+Requires-Dist: safetensors; extra == "prism2"
+Requires-Dist: einops; extra == "prism2"
+Requires-Dist: flash-attn>=2.6.3; extra == "prism2"
 Provides-Extra: hibou
 Requires-Dist: scipy~=1.8.1; extra == "hibou"
 Requires-Dist: scikit-image~=0.19.3; extra == "hibou"
@@ -58,6 +64,10 @@ Requires-Dist: timm==1.0.3; extra == "titan"
 Requires-Dist: einops==0.6.1; extra == "titan"
 Requires-Dist: einops-exts==0.0.4; extra == "titan"
 Requires-Dist: transformers==4.46.0; extra == "titan"
+Provides-Extra: waiv
+Requires-Dist: transformers<6,>=5.14; extra == "waiv"
+Requires-Dist: safetensors>=0.8; extra == "waiv"
+Requires-Dist: huggingface_hub==1.25.1; extra == "waiv"
 Provides-Extra: fm
 Requires-Dist: omegaconf>=2.3.0; extra == "fm"
 Requires-Dist: matplotlib; extra == "fm"
@@ -65,7 +75,7 @@ Requires-Dist: numpy<2; extra == "fm"
 Requires-Dist: pandas; extra == "fm"
 Requires-Dist: pillow; extra == "fm"
 Requires-Dist: rich; extra == "fm"
-Requires-Dist: hs2p[asap,cucim,openslide,sam2,vips]>=4.4.0; extra == "fm"
+Requires-Dist: hs2p[asap,cucim,openslide,sam2,vips]>=4.4.1; extra == "fm"
 Requires-Dist: wandb; extra == "fm"
 Requires-Dist: torch<2.8,>=2.3; extra == "fm"
 Requires-Dist: torchvision>=0.18.0; extra == "fm"
@@ -132,6 +142,10 @@ pip install git+https://github.com/prov-gigapath/prov-gigapath.git
 
 AtlasPatch-backed tissue segmentation is available through hs2p's `sam2` path in the bundled install.
 
+Waiv encoders use a separately tested Transformers 5 runtime. Install them in
+their own environment with `pip install "slide2vec[waiv]"`; the `waiv` extra is
+incompatible with the existing `fm`, `prism`, and `titan` dependency pins.
+
 ## Python API
 
 ```python
@@ -225,7 +239,8 @@ The package writes explicit artifact directories:
 
 ### Supported Models
 
-`slide2vec` currently ships preset configs for 22 tile-level models and 3 slide-level models.  
+`slide2vec` currently ships presets for 28 tile-level models, 4 slide-level models,
+and 1 patient-level model.
 For the full catalog and preset names, see [`docs/models.md`](docs/models.md).
 
 ## CLI

{slide2vec-5.6.0 → slide2vec-5.7.0}/README.md

@@ -26,6 +26,10 @@ pip install git+https://github.com/prov-gigapath/prov-gigapath.git
 
 AtlasPatch-backed tissue segmentation is available through hs2p's `sam2` path in the bundled install.
 
+Waiv encoders use a separately tested Transformers 5 runtime. Install them in
+their own environment with `pip install "slide2vec[waiv]"`; the `waiv` extra is
+incompatible with the existing `fm`, `prism`, and `titan` dependency pins.
+
 ## Python API
 
 ```python
@@ -119,7 +123,8 @@ The package writes explicit artifact directories:
 
 ### Supported Models
 
-`slide2vec` currently ships preset configs for 22 tile-level models and 3 slide-level models.  
+`slide2vec` currently ships presets for 28 tile-level models, 4 slide-level models,
+and 1 patient-level model.
 For the full catalog and preset names, see [`docs/models.md`](docs/models.md).
 
 ## CLI

{slide2vec-5.6.0 → slide2vec-5.7.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "slide2vec"
-version = "5.6.0"
+version = "5.7.0"
 description = "Embedding of whole slide images with Foundation Models"
 readme = "README.md"
 requires-python = ">=3.10"
@@ -21,7 +21,7 @@ classifiers = [
     "Programming Language :: Python :: 3.13",
 ]
 dependencies = [
-    "hs2p[asap,cucim,openslide,sam2,vips]>=4.4.0",
+    "hs2p[asap,cucim,openslide,sam2,vips]>=4.4.1",
     "omegaconf",
     "matplotlib",
     "numpy<2",
@@ -67,6 +67,13 @@ prism = [
     "sacremoses==0.1.1",
     "xformers==0.0.31",
 ]
+prism2 = [
+    "torch>=2.3",
+    "transformers==4.51.3",
+    "safetensors",
+    "einops",
+    "flash-attn>=2.6.3",
+]
 hibou = [
     "scipy~=1.8.1",
     "scikit-image~=0.19.3",
@@ -81,6 +88,11 @@ titan = [
     "einops-exts==0.0.4",
     "transformers==4.46.0",
 ]
+waiv = [
+    "transformers>=5.14,<6",
+    "safetensors>=0.8",
+    "huggingface_hub==1.25.1",
+]
 fm = [
     "omegaconf>=2.3.0",
     "matplotlib",
@@ -88,7 +100,7 @@ fm = [
     "pandas",
     "pillow",
     "rich",
-    "hs2p[asap,cucim,openslide,sam2,vips]>=4.4.0",
+    "hs2p[asap,cucim,openslide,sam2,vips]>=4.4.1",
     "wandb",
     "torch>=2.3,<2.8",
     "torchvision>=0.18.0",
@@ -168,7 +180,7 @@ no_implicit_reexport = true
 max-line-length = 160
 
 [tool.bumpver]
-current_version = "5.6.0"
+current_version = "5.7.0"
 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.6.0 → slide2vec-5.7.0}/slide2vec/__init__.py

@@ -20,9 +20,10 @@ from slide2vec.artifacts import (
     SlideEmbeddingArtifact,
     TileEmbeddingArtifact,
 )
+from slide2vec.runtime.dense_encode import DenseEncodeGeometry, DenseEncodeKit
 
 
-__version__ = "5.6.0"
+__version__ = "5.7.0"
 
 __all__ = [
     "Model",
@@ -31,6 +32,8 @@ __all__ = [
     "PreprocessingConfig",
     "DenseOptions",
     "DenseImageOptions",
+    "DenseEncodeGeometry",
+    "DenseEncodeKit",
     "SlideRegions",
     "ImageSpec",
     "ExecutionOptions",

{slide2vec-5.6.0 → slide2vec-5.7.0}/slide2vec/api.py

@@ -1,6 +1,7 @@
 
 import copy
 import logging
+import math
 import os
 from dataclasses import dataclass, field, replace
 from contextlib import contextmanager
@@ -39,6 +40,17 @@ from slide2vec.utils.utils import cpu_worker_limit, slurm_cpu_limit
 PathLike = str | Path
 
 
+def _validated_spacing_at_level_0(value: float | None) -> float | None:
+    if value is None:
+        return None
+    if isinstance(value, bool):
+        raise ValueError("spacing_at_level_0 must be a positive, finite value or None")
+    spacing = float(value)
+    if not math.isfinite(spacing) or spacing <= 0:
+        raise ValueError("spacing_at_level_0 must be a positive, finite value or None")
+    return spacing
+
+
 class SlideLike(Protocol):
     sample_id: str
     image_path: PathLike
@@ -310,9 +322,10 @@ class ExecutionOptions:
     #: Forward-pass dtype — ``"fp16"``, ``"bf16"``, ``"fp32"``,
     #: or ``None`` (auto-determined from the model preset).
     precision: str | None = None
-    #: On-disk feature dtype — ``"fp16"``, ``"fp32"``, or ``None`` to follow
-    #: :attr:`precision` (fp16 → fp16, else fp32). Applies to tile, slide, hierarchical,
-    #: and patient artifacts; ``"bf16"`` is rejected (numpy has no bfloat16).
+    #: Feature output dtype — ``"fp16"``, ``"fp32"``, or ``None`` to follow
+    #: :attr:`precision` (fp16 → fp16, else fp32). Applies to live dense grids and to
+    #: tile, slide, hierarchical, and patient artifacts; ``"bf16"`` is rejected because
+    #: persisted features cross a numpy boundary.
     output_dtype: str | None = None
     #: DataLoader prefetch queue depth per worker (default ``4``).
     prefetch_factor: int = 4
@@ -446,16 +459,15 @@ class DenseOptions:
 class DenseImageOptions:
     """Dense ``(d, gh, gw)`` extraction over pre-cropped images.
 
-    One run has one reader regime. ``.png``, ``.jpg``, and ``.jpeg`` inputs
-    (case-insensitive) use Pillow and treat numeric ``spacing_um`` as an assertion about
-    unchanged pixels. hs2p-supported WSI formats form the spacing-readable regime: hs2p
-    resolves source spacing, backend, pyramid level, tolerance, complete-extent read, and
-    area downsampling at the one requested run-level ``spacing_um``. Omitted spacing resolves
-    the encoder's single registry default for spacing-readable inputs and requires an
-    explicit value when no default is available.
+    Every supported source uses hs2p's spacing-aware reader contract. ``.png``, ``.jpg``,
+    and ``.jpeg`` inputs use hs2p's one-level PIL reader and therefore require
+    ``ImageSpec.spacing_at_level_0``; WSI readers may resolve native metadata instead.
+    hs2p resolves source spacing, backend, pyramid level, tolerance, complete-extent read,
+    and permitted area downsampling at the requested run-level ``spacing_um``. Omitted
+    spacing resolves the encoder's single registry default.
 
-    ``ImageSpec.spacing_at_level_0`` overrides level-0 metadata only for spacing-readable
-    sources. ``target_size`` is always a strict post-read declaration, never a fit-to-size
+    ``ImageSpec.spacing_at_level_0`` is the optional caller declaration used by hs2p when
+    resolving level-0 spacing. ``target_size`` is always a strict post-read declaration, never a fit-to-size
     request: each final pixel array must already be exactly this size. Declaring it up front
     lets the effective encoder input be validated (and variable-input constructor settings
     resolved) before model loading or pixel decoding. Differing final geometries therefore
@@ -465,9 +477,8 @@ class DenseImageOptions:
     #: Supervision geometry in pixels the dense grid registers to: a square side length, or
     #: an explicit ``(height, width)`` for non-square images.
     target_size: int | tuple[int, int]
-    #: Positive, finite run-level spacing in µm/px: asserted for raster pixels and requested
-    #: for spacing-readable reads. ``None`` is unknown for raster and resolves the encoder's
-    #: single registry default for spacing-readable inputs.
+    #: Positive, finite requested run spacing in µm/px. ``None`` resolves the encoder's
+    #: single registry default.
     spacing_um: float | None = None
     #: Relative spacing tolerance used by hs2p for spacing-readable level selection; raster
     #: reads have no tolerance result.
@@ -502,7 +513,9 @@ class SlideRegions:
     The dense input unit soma's slide-manifest path hands to
     :meth:`Model.embed_regions_dense`. ``coordinates`` is an ``(N, 2)`` array of level-0
     top-left ``(x, y)`` pixel coordinates; each ROI is read + encoded into one persisted
-    ``(d, gh, gw)`` grid named ``<x>_<y>.pt``. ``annotation`` namespaces the output under a
+    ``(d, gh, gw)`` grid named ``<x>_<y>.pt``. ``spacing_at_level_0`` optionally declares
+    the source image's level-0 spacing when metadata is missing or must be overridden.
+    ``annotation`` namespaces the output under a
     per-class subdirectory (reusing the pooled convention); ``None`` is the flat layout.
     """
 
@@ -510,6 +523,15 @@ class SlideRegions:
     image_path: PathLike
     coordinates: Any
     annotation: str | None = None
+    #: Optional caller declaration for the source's level-0 spacing in µm/px.
+    spacing_at_level_0: float | None = None
+
+    def __post_init__(self) -> None:
+        object.__setattr__(
+            self,
+            "spacing_at_level_0",
+            _validated_spacing_at_level_0(self.spacing_at_level_0),
+        )
 
 
 @dataclass(frozen=True, kw_only=True)
@@ -517,19 +539,25 @@ class ImageSpec:
     """One named image source: ``(sample_id, image_path, spacing_at_level_0)``.
 
     The input unit of :meth:`Model.embed_images` — the Given-geometry counterpart of
-    :class:`SlideRegions`. ``spacing_at_level_0`` represents caller metadata for
-    spacing-readable image sources. The current raster paths reject a non-null value: a
-    pre-cropped PNG/JPEG has no slide pyramid or level-0 read plan to override. ``sample_id``
+    :class:`SlideRegions`. ``spacing_at_level_0`` is the optional finite positive caller
+    declaration used by hs2p to resolve source level-0 spacing. Flat PNG/JPEG sources have
+    no embedded spacing and therefore require it for dense extraction. ``sample_id``
     is the artifact's whole identity, so it must be unique within a run and a valid filename
     component.
     """
 
     sample_id: str
     image_path: PathLike
-    #: Optional caller override for the source's level-0 spacing. Raster image paths reject
-    #: non-null overrides because they have no slide pyramid or level-0 read plan.
+    #: Optional caller declaration for the source's level-0 spacing in µm/px.
     spacing_at_level_0: float | None = None
 
+    def __post_init__(self) -> None:
+        object.__setattr__(
+            self,
+            "spacing_at_level_0",
+            _validated_spacing_at_level_0(self.spacing_at_level_0),
+        )
+
 
 @dataclass(frozen=True, kw_only=True)
 class RunResult:
@@ -646,6 +674,33 @@ class Model:
         # Construction fact, not an encode: see _load_backend_without_transform.
         return int(self._load_backend_without_transform().feature_dim)
 
+    def prepare_dense_encoder(
+        self,
+        *,
+        dense: "DenseImageOptions | DenseOptions",
+        execution: ExecutionOptions | None = None,
+    ):
+        """Prepare live dense encoding for one augmented RGB tensor at a time.
+
+        Only the encoding fields shared by :class:`DenseImageOptions` and
+        :class:`DenseOptions` apply after the augmented-pixel handoff. Source-reading
+        fields (spacing, tolerance, and backend) are intentionally ignored.
+        """
+        from slide2vec.runtime.dense_encode import _prepare_dense_encode_kit
+
+        if not isinstance(dense, (DenseImageOptions, DenseOptions)):
+            raise TypeError(
+                "Model.prepare_dense_encoder(dense=...) expects DenseImageOptions "
+                f"or DenseOptions, got {type(dense).__name__}"
+            )
+        if self.level != "tile":
+            raise ValueError(
+                "Model.prepare_dense_encoder(...) requires a tile-level foundation "
+                f"encoder; model {self.name!r} is registered at level {self.level!r}."
+            )
+        resolved = _coerce_execution_options(execution, model=self)
+        return _prepare_dense_encode_kit(self, dense=dense, execution=resolved)
+
     def embed_tiles(
         self,
         slides: SlideSequence,
@@ -832,7 +887,8 @@ class Model:
         dense transform, and written to ``dense_embeddings/[<class>/]<sample_id>/<x>_<y>.pt``
         plus a geometry sidecar. The run splits its ROIs across all visible GPUs
         (``execution.num_gpus``); ``num_gpus=1`` encodes fully in-process. Resume is
-        automatic — ROIs whose sidecar already exists are skipped. Returns one
+        automatic — only ROIs whose sidecar has the same source-spacing declaration and
+        resolved hs2p read plan are skipped. Returns one
         :class:`~slide2vec.artifacts.DenseRegionArtifact` per input ROI.
 
         The effective encoder input — the padded ROI for a whole-tile run, one
@@ -869,16 +925,14 @@ class Model:
         identity and complete extraction recipe. Returns one
         :class:`~slide2vec.artifacts.DenseImageArtifact` per input image, in input order.
 
-        One run uses one reader regime. Raster inputs are exactly ``.png``, ``.jpg``, and
-        ``.jpeg`` (case-insensitive) and always use Pillow's RGB decoder.
-        ``dense.spacing_um`` asserts the scale those unchanged pixels already have; ``None``
-        records unknown spacing. hs2p-supported WSI inputs are spacing-readable:
+        Every source is opened through hs2p. PNG/JPEG inputs use hs2p's one-level PIL reader
+        and require ``ImageSpec.spacing_at_level_0`` because they have no embedded spacing.
         ``dense.spacing_um`` requests one physical read scale, or ``None`` resolves the
         encoder's single registry default. The parent resolves each source's metadata,
         concrete backend, native level, tolerance result, and final geometry before resume;
         hs2p reads that complete level and area-downsamples when required, but never
-        upsamples. ``ImageSpec.spacing_at_level_0`` overrides source metadata only in this
-        spacing-readable regime and is rejected for raster inputs.
+        upsamples. ``ImageSpec.spacing_at_level_0`` is preserved separately from the
+        resolved source spacing and is passed to every hs2p backend.
 
         Everything after reading is shared with the slide path, including the effective encoder input — the padded image
         for a whole-image run, one patch-aligned window for a sliding one — which is declared

{slide2vec-5.6.0 → slide2vec-5.7.0}/slide2vec/data/tile_reader.py

@@ -310,6 +310,7 @@ class WSIRegionReader:
         gpu_decode: bool = False,
         resize_to_px: int | None = None,
         interpolation: str = "area",
+        spacing_at_level_0: float | None = None,
     ):
         self._image_path = str(image_path)
         self._backend = backend
@@ -319,16 +320,56 @@ class WSIRegionReader:
         self._region_size_px = int(region_size_px)
         self._resize_to_px = int(resize_to_px) if resize_to_px is not None else None
         self._interpolation = interpolation
+        self._spacing_at_level_0 = spacing_at_level_0
         self._out_size_px = (
             self._resize_to_px if self._resize_to_px is not None else self._region_size_px
         )
         self._reader = None
+        self._pil_rgb = None
 
     def _ensure_open(self) -> None:
         if self._reader is None:
-            self._reader = _open_wsi_backend(self._image_path, self._backend, self._gpu_decode)
+            if self._spacing_at_level_0 is None:
+                self._reader = _open_wsi_backend(
+                    self._image_path, self._backend, self._gpu_decode
+                )
+            else:
+                from hs2p.wsi.reader import open_slide
+
+                self._reader = open_slide(
+                    self._image_path,
+                    backend=self._backend,
+                    spacing_override=self._spacing_at_level_0,
+                    gpu_decode=self._gpu_decode,
+                )
+            if self._backend == "pil":
+                from PIL import Image
+
+                with Image.open(self._image_path) as image:
+                    self._pil_rgb = image.convert("RGB")
 
     def _read_regions_batch(self, locations: list[tuple[int, int]]) -> list[np.ndarray]:
+        if self._backend == "pil":
+            if self._pil_rgb is None:
+                raise RuntimeError("PIL dense region reader was not initialized")
+            size = self._region_size_px
+            width, height = self._pil_rgb.size
+            regions = []
+            for x, y in locations:
+                left, top = max(0, x), max(0, y)
+                right, bottom = min(width, x + size), min(height, y + size)
+                canvas = np.full((size, size, 3), 255, dtype=np.uint8)
+                if right > left and bottom > top:
+                    crop = np.asarray(
+                        self._pil_rgb.crop((left, top, right, bottom)),
+                        dtype=np.uint8,
+                    )
+                    canvas[
+                        top - y : bottom - y,
+                        left - x : right - x,
+                    ] = crop
+                regions.append(canvas)
+            return regions
         if self._backend == "cucim":
             return list(
                 self._reader.read_regions(

{slide2vec-5.6.0 → slide2vec-5.7.0}/slide2vec/encoders/models/__init__.py

@@ -20,9 +20,12 @@ from . import (
     phikon,
     prost40m,
     prism,
+    prism2,
+    rudolfv2,
     titan,
     uni,
     virchow,
+    waiv,
 )
 
 __all__ = [
@@ -42,7 +45,10 @@ __all__ = [
     "phikon",
     "prost40m",
     "prism",
+    "prism2",
+    "rudolfv2",
     "titan",
     "uni",
     "virchow",
+    "waiv",
 ]

{slide2vec-5.6.0 → slide2vec-5.7.0}/slide2vec/encoders/models/conch.py

@@ -78,7 +78,7 @@ def _encode_trunk_dense(*, trunk, batch: Tensor, encoder_name: str) -> Tensor:
     output_variants={"default": {"encode_dim": 512}},
     default_output_variant="default",
     input_size=448,
-    supports_variable_input_size=False,
+    supports_variable_input_size=True,
     patch_size=16,
     supported_spacing_um=0.5,
     precision="fp32",
@@ -145,9 +145,8 @@ class CONCH(TileEncoder):
 
     @property
     def patch_size(self) -> tuple[int, int]:
-        # The CONCH vision trunk is a timm ViT-B/16; expose its patch size so the
-        # dense path can resolve the token grid. open_clip builds the trunk without
-        # dynamic_img_size, so dense extraction must use the native 448 window.
+        # The CONCH vision trunk is a dynamic timm ViT-B/16; expose its patch size
+        # so dense and attention paths can resolve each runtime token grid.
         return _patch_size_from_trunk(self._model.visual.trunk)
 
     @property
@@ -165,7 +164,7 @@ class CONCH(TileEncoder):
     output_variants={"default": {"encode_dim": 768}},
     default_output_variant="default",
     input_size=448,
-    supports_variable_input_size=False,
+    supports_variable_input_size=True,
     patch_size=16,
     supported_spacing_um=0.5,
     precision="fp16",

{slide2vec-5.6.0 → slide2vec-5.7.0}/slide2vec/encoders/models/isight.py

@@ -19,11 +19,11 @@ Every numerically-relevant choice mirrors https://github.com/zhihuanglab/iSight
 * Tile features are ``vision_model(..., output_hidden_states=True)
   .hidden_states[-1]`` passed through the learned ``visual_token_projection``
   — ``patch_encoder_with_clam.py:217-219``.
-* Reduction to one vector per tile is the **mean over all 577 tokens**
-  (CLS included) — ``patch_encoder_with_clam.py:254-255``, where the CLS line
-  is immediately overwritten by the token-mean line, and corroborated by
-  ``model_version = v3_all_tokens`` in ``config/config.ini:3``. The dead CLS
-  branch is still offered as the non-default ``cls`` output variant.
+* Reduction to one vector per tile is the **mean over all tokens** (577 at the
+  native 336 x 336 input, CLS included) — ``patch_encoder_with_clam.py:254-255``,
+  where the CLS line is immediately overwritten by the token-mean line, and
+  corroborated by ``model_version = v3_all_tokens`` in ``config/config.ini:3``.
+  The dead CLS branch is still offered as the non-default ``cls`` output variant.
 * Preprocessing is the model's own ``AutoProcessor`` — the reference builds it
   as ``self.patch_processor`` (``patch_encoder_with_clam.py:128``) and applies
   it per tile in ``dataset/hpadataset.py:152``.
@@ -65,12 +65,13 @@ check on the download.
 Slide level is deliberately absent
 ----------------------------------
 iSight's gated attention runs at *token* level, not tile level: ``A`` has shape
-``(n_tiles, n_tokens, 1)`` and is softmaxed over tiles, so each of the 577 token
-positions gets its own distribution over tiles
+``(n_tiles, n_tokens, 1)`` and is softmaxed over tiles, so every token position
+gets its own distribution over tiles
 (``patch_encoder_with_clam.py:230-255``). The pooled result is therefore not a
 function of per-tile ``(N, D)`` vectors, which is what
 :meth:`SlideEncoder.encode_slide` receives. Reproducing it would require caching
-``577 x 1024`` per tile. The heads are also specific to the five HPA tasks, so
+``n_tokens x 1024`` per tile (577 x 1024 at the native input). The heads are
+also specific to the five HPA tasks, so
 the pooled vector is not a general slide representation. Downstream MIL should
 do the pooling instead.
 """
@@ -125,7 +126,7 @@ def _load_isight_state_dict() -> dict[str, Tensor]:
     },
     default_output_variant="token_mean",
     input_size=336,
-    supports_variable_input_size=False,
+    supports_variable_input_size=True,
     patch_size=14,
     supported_spacing_um=0.5,
     precision="fp16",
@@ -208,15 +209,19 @@ class ISight(TileEncoder):
         ])
 
     def _token_features(self, batch: Tensor) -> Tensor:
-        """Projected token sequence ``(B, 577, 1024)`` — patch_encoder_with_clam.py:217-219."""
-        outputs = self._vision(batch, output_hidden_states=True)
+        """Projected ``(B, 1 + H/14 * W/14, 1024)`` token sequence."""
+        outputs = self._vision(
+            batch,
+            output_hidden_states=True,
+            interpolate_pos_encoding=True,
+        )
         return self._projection(outputs.hidden_states[-1])
 
     def encode_tiles(self, batch: Tensor) -> Tensor:
         features = self._token_features(batch)
         if self._output_variant == "cls":
             return features[:, 0]
-        # Mean over all 577 tokens, CLS included — patch_encoder_with_clam.py:255.
+        # Mean over every runtime token, CLS included — 577 at the native input.
         return features.mean(dim=1)
 
     def encode_tiles_dense(self, batch: Tensor) -> Tensor:
@@ -273,7 +278,11 @@ class ISight(TileEncoder):
             )
         # SDPA silently returns attentions=None; flip the PreTrainedModel to eager.
         with hf_eager_attention(self._clip):
-            outputs = self._vision(batch, output_attentions=True)
+            outputs = self._vision(
+                batch,
+                output_attentions=True,
+                interpolate_pos_encoding=True,
+            )
         return attentions_tuple_to_grids(
             outputs.attentions,
             num_prefix_tokens=1,