slide2vec 6.1.1__tar.gz → 6.3.0__tar.gz

{slide2vec-6.1.1 → slide2vec-6.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: slide2vec
-Version: 6.1.1
+Version: 6.3.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]>=5.0.2
+Requires-Dist: hs2p[asap,cucim,openslide,sam2,tifffile,vips]>=5.1.0
 Requires-Dist: omegaconf
 Requires-Dist: matplotlib
 Requires-Dist: numpy<2
@@ -75,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]>=5.0.2; extra == "fm"
+Requires-Dist: hs2p[asap,cucim,openslide,sam2,tifffile,vips]>=5.1.0; extra == "fm"
 Requires-Dist: wandb; extra == "fm"
 Requires-Dist: torch<2.8,>=2.3; extra == "fm"
 Requires-Dist: torchvision>=0.18.0; extra == "fm"

{slide2vec-6.1.1 → slide2vec-6.3.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "slide2vec"
-version = "6.1.1"
+version = "6.3.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]>=5.0.2",
+    "hs2p[asap,cucim,openslide,sam2,tifffile,vips]>=5.1.0",
     "omegaconf",
     "matplotlib",
     "numpy<2",
@@ -100,7 +100,7 @@ fm = [
     "pandas",
     "pillow",
     "rich",
-    "hs2p[asap,cucim,openslide,sam2,vips]>=5.0.2",
+    "hs2p[asap,cucim,openslide,sam2,tifffile,vips]>=5.1.0",
     "wandb",
     "torch>=2.3,<2.8",
     "torchvision>=0.18.0",
@@ -180,7 +180,7 @@ no_implicit_reexport = true
 max-line-length = 160
 
 [tool.bumpver]
-current_version = "6.1.1"
+current_version = "6.3.0"
 version_pattern = "MAJOR.MINOR.PATCH"
 commit = false
 tag = false

{slide2vec-6.1.1 → slide2vec-6.3.0}/slide2vec/__init__.py

@@ -31,7 +31,7 @@ from slide2vec.encoders import (
 )
 
 
-__version__ = "6.1.1"
+__version__ = "6.3.0"
 
 __all__ = [
     "Model",

{slide2vec-6.1.1 → slide2vec-6.3.0}/slide2vec/api.py

@@ -153,8 +153,10 @@ class PreprocessingConfig:
     #: explicitly (e.g. ``"openslide"``) when a precomputed tissue or annotation mask needs
     #: a different decoder than its slide — hs2p no longer silently falls back to another
     #: reader, so a mask the slide backend cannot decode fails unless overridden here.
-    #: Accepts the same values as :attr:`backend` plus ``"pil"`` for PNG/JPEG masks;
-    #: ``"auto"`` selects PIL for these masks. Ignored for slides with no source mask.
+    #: Accepts the same values as :attr:`backend` plus ``"pil"`` for PNG/JPEG masks and
+    #: ``"tifffile"`` for lossless label reads; ``"auto"`` selects PIL for PNG/JPEG masks
+    #: and ``"tifffile"`` for TIFF masks whose samples are not 8-bit unsigned.
+    #: Ignored for slides with no source mask.
     #: Masks need no spacing metadata, but must align to the slide's field of view and
     #: contain only declared label IDs. See :doc:`preprocessing` for hs2p 5 validation.
     mask_backend: str = "auto"
@@ -179,6 +181,10 @@ class PreprocessingConfig:
     read_tiles_from: Path | None = None
     #: Read and decode tiles on demand rather than pre-loading into memory.
     on_the_fly: bool = True
+    #: Write the extracted tiles to ``tiles/<sample_id>.tiles.tar`` next to the coordinate
+    #: artifacts. Tiles are also written when ``on_the_fly`` is ``False`` and
+    #: ``read_tiles_from`` is unset, because embedding then reads them from the archive.
+    save_tiles: bool = False
     #: Decode tiles on the GPU via CuCIM / nvImageCodec when ``True``.
     gpu_decode: bool = False
     #: Dynamically adjust batch size based on tile count.
@@ -285,6 +291,7 @@ class PreprocessingConfig:
                 Path(read_tiles_from) if read_tiles_from else None
             ),
             on_the_fly=on_the_fly,
+            save_tiles=bool(cfg.save_tiles),
             gpu_decode=gpu_decode,
             adaptive_batching=adaptive_batching,
             use_supertiles=bool(tiling.use_supertiles),
@@ -336,7 +343,8 @@ class ExecutionOptions:
     save_tile_embeddings: bool = False
     #: Persist slide embeddings to disk when running a patient-level model.
     save_slide_embeddings: bool = False
-    #: Persist encoder latent representations when available.
+    #: Return and persist the slide encoder's latent representations (PRISM). Encoders
+    #: without latents ignore it.
     save_latents: bool = False
 
     @classmethod
@@ -622,10 +630,13 @@ class EmbeddedSlide:
     mask_preview_path: Path | None = None
     #: Path to the tiling preview image, if generated.
     tiling_preview_path: Path | None = None
-    #: Encoder latent representations when available; ``None`` otherwise.
+    #: Slide encoder latent representations when ``ExecutionOptions.save_latents`` is set
+    #: and the encoder has them (PRISM: shape ``(512, 1280)``); ``None`` otherwise.
     latents: Any | None = None
     #: Factual square tensor side length immediately before tile encoding.
     encoder_input_size_px: int | None = None
+    #: Record of the image transform applied before tile encoding (JSON data).
+    transform: dict[str, Any] | None = None
 
 
 class Model:
@@ -892,8 +903,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 — only ROIs whose sidecar has the same source-spacing declaration and
-        resolved hs2p read plan are skipped. Returns one
+        automatic — only ROIs whose sidecar has the same source-spacing declaration,
+        resolved hs2p read plan and feature identity are skipped. Returns one
         :class:`~slide2vec.artifacts.DenseRegionArtifact` per input ROI.
 
         The effective encoder input — the padded ROI for a whole-tile run, one
@@ -971,8 +982,9 @@ class Model:
         to ``image_embeddings/<sample_id>.pt`` plus a provenance sidecar. The run splits its
         images across all visible GPUs (``execution.num_gpus``); ``num_gpus=1`` encodes
         fully in-process. Resume is automatic — images whose sidecar already exists are
-        skipped. Returns one :class:`~slide2vec.artifacts.ImageEmbeddingArtifact` per input
-        image, in input order.
+        skipped, and a sidecar that records a different feature identity raises. Returns
+        one :class:`~slide2vec.artifacts.ImageEmbeddingArtifact` per input image, in input
+        order.
 
         Unlike the pooled and dense paths there is no geometry to declare: the images are
         heterogeneously sized (2048x1536 beside 96x96) and were never requested, so the

{slide2vec-6.1.1 → slide2vec-6.3.0}/slide2vec/artifacts.py

@@ -316,13 +316,15 @@ def _write_dense_grid(
 ) -> np.ndarray:
     """Publish one dense grid: payload atomically, then the sidecar. Returns the array.
 
-    The single write order every dense artifact follows (D6), whatever named it: payload to
-    a temp file in the destination directory → ``os.replace`` into place (atomic on the same
-    filesystem) → then the ``.meta.json`` sidecar. A payload present without its sidecar
-    therefore unambiguously means an incomplete unit, and resume treats the sidecar as the
-    done-marker.
+    The single write order every dense artifact follows (D6), whatever named it: remove any
+    existing sidecar → payload to a temp file in the destination directory → ``os.replace``
+    into place (atomic on the same filesystem) → then the ``.meta.json`` sidecar. A payload
+    present without its sidecar therefore unambiguously means an incomplete unit, and resume
+    treats the sidecar as the done-marker. Removing the old sidecar first keeps a rewrite
+    interrupted between the two writes from pairing it with the new payload.
     """
     grid_array = _ensure_array(grid)
+    metadata_path.unlink(missing_ok=True)
     write_atomically(payload_path, lambda tmp_path: torch.save(_ensure_tensor(grid), tmp_path))
     _write_metadata(metadata_path, metadata)
     return grid_array

{slide2vec-6.1.1 → slide2vec-6.3.0}/slide2vec/cli.py

@@ -2,7 +2,7 @@ import argparse
 
 from slide2vec.api import ExecutionOptions, Model, Pipeline, PreprocessingConfig
 from slide2vec.progress import activate_progress_reporter, create_cli_progress_reporter
-from slide2vec.utils.config import setup, hf_login
+from slide2vec.utils.config import setup
 
 
 def get_args_parser(add_help: bool = True):
@@ -24,7 +24,6 @@ def parse_args(argv=None):
 
 def build_model_and_pipeline(args):
     cfg, _cfg_path = setup(args)
-    hf_login()
     model = Model.from_preset(
         cfg.model.name,
         output_variant=cfg.model.output_variant,

{slide2vec-6.1.1 → slide2vec-6.3.0}/slide2vec/configs/default.yaml

@@ -26,7 +26,7 @@ tiling:
   read_coordinates_from: # path to an existing directory containing pre-extracted `.coordinates.npz` / `.coordinates.meta.json` artifacts to reuse instead of starting tiling from scratch
   read_tiles_from: # path to an existing directory containing pre-extracted `.tiles.tar` tile stores to reuse instead of starting tiling from scratch
   backend: "auto" # backend to use for slide reading; "auto" tries cucim -> vips -> openslide -> asap. Pin a backend for stable decoder selection across upgrades.
-  mask_backend: "auto" # backend for reading source masks (precomputed tissue / annotation), resolved independently from the mask path; "auto" probes openability like `backend`. Set explicitly (e.g. "openslide") when a mask needs a different decoder than its slide — hs2p (>=4.3.0) no longer silently falls back
+  mask_backend: "auto" # backend for reading source masks (precomputed tissue / annotation), resolved independently from the mask path; "auto" probes openability like `backend`. Set explicitly (e.g. "openslide") when a mask needs a different decoder than its slide — hs2p never silently falls back. "auto" selects "tifffile" for TIFF masks whose samples are not 8-bit unsigned (e.g. 16-bit labels)
   independent_sampling: true # selection strategy when annotation sampling is active. true: sample each class independently against its own binary mask (independent selection); false: sample once over the union of active classes, then post-filter per class by coverage (joint selection). Ignored when the masks vocabulary is left at the tissue-only default.
   masks:
     # Annotation-mask vocabulary forwarded to hs2p's sampling resolver. The shipped default

{slide2vec-6.1.1 → slide2vec-6.3.0}/slide2vec/distributed/dense_worker.py

@@ -27,6 +27,7 @@ def get_args_parser(add_help: bool = True):
 def main(argv=None) -> int:
     from slide2vec.progress import emit_progress
     from slide2vec.runtime.dense_shard import run_dense_shard
+    from slide2vec.runtime.feature_identity import dense_feature_identity
     from slide2vec.runtime.dense_stage import (
         region_specs_from_request,
         resolve_output_torch_dtype,
@@ -68,6 +69,7 @@ def main(argv=None) -> int:
             dense=dense,
             batch_size=int(execution.batch_size),
             device=loaded.device,
+            identity=dense_feature_identity(model, dense=dense, execution=execution),
             precision=execution.precision,
             output_dtype=resolve_output_torch_dtype(execution),
             num_workers=execution.resolved_num_workers_per_gpu(),

{slide2vec-6.1.1 → slide2vec-6.3.0}/slide2vec/distributed/direct_embed_worker.py

@@ -55,6 +55,7 @@ def main(argv=None) -> int:
         work_unit_shard_stem,
     )
     from slide2vec.runtime.embedding import tiling_result_annotation
+    from slide2vec.runtime.feature_identity import transform_record
 
     load_successful_tiled_slides_fn = getattr(inference, "load_successful_tiled_slides", None)
     if not callable(load_successful_tiled_slides_fn):
@@ -84,6 +85,8 @@ def main(argv=None) -> int:
             shard_stem = work_unit_shard_stem(*decode_work_unit(work_unit))
             slide, tiling_result = paired_by_unit[work_unit]
             loaded = model._load_backend()
+            # The parent writes the sidecar without loading the encoder; hand it the record.
+            transform = transform_record(getattr(loaded, "transforms", None))
             if is_hierarchical_preprocessing(preprocessing):
                 geometry = resolve_hierarchical_geometry(preprocessing, tiling_result)
                 index = build_hierarchical_index(
@@ -113,6 +116,7 @@ def main(argv=None) -> int:
                     "flat_index": torch.as_tensor(shard_indices, dtype=torch.long),
                     "tile_embeddings": tile_embeddings.detach().cpu() if torch.is_tensor(tile_embeddings) else torch.as_tensor(tile_embeddings),
                     "encoder_input_size_px": getattr(loaded, "encoder_input_size_px", None),
+                    "transform": transform,
                 }
                 torch.save(payload, coordination_dir / f"{shard_stem}.hier.rank{global_rank}.pt")
             else:
@@ -140,6 +144,7 @@ def main(argv=None) -> int:
                     "tile_index": torch.as_tensor(tile_indices, dtype=torch.long),
                     "tile_embeddings": tile_embeddings.detach().cpu() if torch.is_tensor(tile_embeddings) else torch.as_tensor(tile_embeddings),
                     "encoder_input_size_px": getattr(loaded, "encoder_input_size_px", None),
+                    "transform": transform,
                 }
                 torch.save(payload, coordination_dir / f"{shard_stem}.tiles.rank{global_rank}.pt")
             return 0
@@ -156,6 +161,7 @@ def main(argv=None) -> int:
                 "slide_embedding": _to_cpu_payload(embedded_slide.slide_embedding),
                 "latents": _to_cpu_payload(embedded_slide.latents),
                 "encoder_input_size_px": embedded_slide.encoder_input_size_px,
+                "transform": embedded_slide.transform,
             }
             # Stem by (sample_id, annotation) so two classes of one slide never overwrite each
             # other; flat units keep the bare-sample_id filename for backward compatibility.

{slide2vec-6.1.1 → slide2vec-6.3.0}/slide2vec/distributed/image_worker.py

@@ -26,6 +26,7 @@ def get_args_parser(add_help: bool = True):
 
 def main(argv=None) -> int:
     from slide2vec.progress import emit_progress
+    from slide2vec.runtime.feature_identity import pooled_feature_identity
     from slide2vec.runtime.image_shard import run_image_shard
     from slide2vec.runtime.image_specs import image_specs_from_request
     from slide2vec.runtime.model_settings import resolve_output_precision
@@ -60,6 +61,7 @@ def main(argv=None) -> int:
             out_dir=output_dir,
             batch_size=int(execution.batch_size),
             output_precision=resolve_output_precision(execution.output_dtype, execution.precision),
+            identity=pooled_feature_identity(model, execution=execution),
             output_format=execution.output_format,
             precision=execution.precision,
             num_workers=execution.resolved_image_num_workers_per_gpu(),

{slide2vec-6.1.1 → slide2vec-6.3.0}/slide2vec/encoders/base.py

@@ -390,6 +390,20 @@ def attentions_tuple_to_grids(
     return torch.cat(grids, dim=1)
 
 
+class ProcessorTransform:
+    """Apply a Hugging Face processor to one image.
+
+    A class rather than a closure so the processor stays readable: the sidecar's
+    transform record is read from it.
+    """
+
+    def __init__(self, processor) -> None:
+        self.processor = processor
+
+    def __call__(self, image) -> Tensor:
+        return self.processor(images=image, return_tensors="pt")["pixel_values"].squeeze(0)
+
+
 class Encoder(ABC):
     """Shared lifecycle contract for all encoders."""
 
@@ -527,6 +541,19 @@ class SlideEncoder(Encoder):
         """Pool tile-level features into a single slide-level embedding."""
         ...
 
+    def encode_slide_with_latents(
+        self,
+        tile_features: Tensor,
+        coordinates: Tensor | None = None,
+        *,
+        tile_size_lv0: int | None = None,
+    ) -> tuple[Tensor, Tensor | None]:
+        """Return the slide embedding and the encoder's latent representations.
+
+        Encoders that have latents (PRISM) override this; the default returns ``None``.
+        """
+        return self.encode_slide(tile_features, coordinates, tile_size_lv0=tile_size_lv0), None
+
 
 class PatientEncoder(Encoder):
     """Base class for encoders that aggregate slide embeddings into patient embeddings."""

{slide2vec-6.1.1 → slide2vec-6.3.0}/slide2vec/encoders/models/__init__.py

@@ -14,6 +14,7 @@ from . import (
     hoptimus,
     isight,
     lunit,
+    mettle,
     midnight,
     moozy,
     mstar,
@@ -40,6 +41,7 @@ __all__ = [
     "hoptimus",
     "isight",
     "lunit",
+    "mettle",
     "midnight",
     "moozy",
     "mstar",

{slide2vec-6.1.1 → slide2vec-6.3.0}/slide2vec/encoders/models/dinov2.py

@@ -16,9 +16,17 @@ Structurally it is a plain :class:`TimmTileEncoder` (mirroring ``lunit`` /
 ``prost40m`` / ``uni``): the dense (``encode_tiles_dense``) and attention
 (``encode_tiles_attention``) paths are inherited unchanged from the timm ViT
 base, so the control is dense-extraction- and attention-capable exactly like the
-pathology encoders. ``dynamic_img_size=True`` lets the (natively 518px) backbone
-run at the 224px detection tile geometry via positional-embedding interpolation,
-a no-op at the native size (verified in the shared dense-extraction suite).
+pathology encoders. ``dynamic_img_size=True`` lets the natively 518px backbone
+run at other patch-aligned sizes via positional-embedding interpolation.
+
+Input size follows Meta's DINOv2 evaluation recipe
+(``make_classification_eval_transform``: bicubic Resize 256 -> CenterCrop 224
+-> ImageNet normalization), not timm's 518px checkpoint config. The registry
+``input_size`` is 224, the size the encoder sees; 256 would make declared runs
+encode 256px. Declared pooled runs read and encode 224px tiles with
+normalization only (112 µm at the default 0.5 µm/px, 16x16 tokens). Native
+518px is an explicit request with ``allow_non_recommended_settings=True``.
+Given pre-cropped tiles use Meta's Resize 256 -> CenterCrop 224 recipe.
 
 Spacing note: a natural-image model has **no** intrinsic micron-per-pixel
 spacing, so it declares ``supported_spacing_um=None`` — it is *spacing-agnostic*
@@ -26,15 +34,17 @@ and :func:`validate_encoder_config` never rejects a requested spacing for it
 (unlike the pathology encoders, which are validated at a specific spacing). It
 still needs *a* spacing to tile a slide, so ``default_spacing_um=0.5`` sets the
 tiling default: 0.5 µm/px is the task-spacing the pathology tile encoders
-declare. Declared pooled runs read and encode the requested tile size with
-normalization only: 518px by default, or 224px for matched-resolution
-experiments when requested explicitly with ``allow_non_recommended_settings=True``.
-Given pre-cropped tiles still use the shipped Resize 518 -> CenterCrop 518
-transform. Because it is agnostic, sweeping other task-spacings (e.g. 0.25)
+declare. Because it is agnostic, sweeping other task-spacings (e.g. 0.25)
 needs no ``allow_non_recommended_settings`` escape hatch — any requested spacing
 is accepted as-is.
 """
 
+from typing import Callable
+
+import torch
+from timm.data import IMAGENET_DEFAULT_MEAN, IMAGENET_DEFAULT_STD
+from torchvision.transforms import v2
+
 from slide2vec.encoders.base import TimmTileEncoder
 from slide2vec.encoders.registry import register_encoder
 
@@ -43,7 +53,7 @@ from slide2vec.encoders.registry import register_encoder
     "dinov2-vitb14",
     output_variants={"default": {"encode_dim": 768}},
     default_output_variant="default",
-    input_size=518,
+    input_size=224,
     supports_variable_input_size=True,
     patch_size=14,
     supported_spacing_um=None,  # spacing-agnostic: no intrinsic µm/px, so no validation constraint
@@ -56,5 +66,17 @@ class DINOv2ViTB14(TimmTileEncoder):
         super().__init__(
             "vit_base_patch14_dinov2.lvd142m",
             output_variant=output_variant,
-            dynamic_img_size=True,  # enable dense extraction; no-op at native size
+            dynamic_img_size=True,  # 224 default, 518 opt-in and dense sizes; no-op at native 518
         )
+
+    def get_transform(self) -> Callable:
+        # Meta's DINOv2 eval recipe for given pre-cropped images; timm's packaged
+        # pretrained_cfg would instead Resize 518 -> CenterCrop 518. Declared runs
+        # use get_normalization_transform() and encode exactly the requested size.
+        return v2.Compose([
+            v2.ToImage(),
+            v2.Resize(256, interpolation=v2.InterpolationMode.BICUBIC, antialias=True),
+            v2.CenterCrop(224),
+            v2.ToDtype(torch.float32, scale=True),
+            v2.Normalize(mean=IMAGENET_DEFAULT_MEAN, std=IMAGENET_DEFAULT_STD),
+        ])

{slide2vec-6.1.1 → slide2vec-6.3.0}/slide2vec/encoders/models/gigapath.py

@@ -3,6 +3,8 @@
 from typing import Callable
 
 import torch
+from huggingface_hub import hf_hub_download
+from huggingface_hub.errors import LocalEntryNotFoundError
 from torchvision.transforms import v2
 
 from slide2vec.encoders.base import (
@@ -13,6 +15,18 @@ from slide2vec.encoders.base import (
 )
 from slide2vec.encoders.registry import register_encoder
 
+_HF_REPO_ID = "prov-gigapath/prov-gigapath"
+_HF_SLIDE_CHECKPOINT = "slide_encoder.pth"
+
+
+def _slide_checkpoint_path() -> str:
+    # A default hf_hub_download queries the Hub on every call, even when cached.
+    try:
+        return hf_hub_download(repo_id=_HF_REPO_ID, filename=_HF_SLIDE_CHECKPOINT, local_files_only=True)
+    except LocalEntryNotFoundError:
+        return hf_hub_download(repo_id=_HF_REPO_ID, filename=_HF_SLIDE_CHECKPOINT)
+
+
 # Prov-GigaPath model card transform (given pre-cropped images only): resize to 256,
 # center-crop to the model's native 224, ImageNet normalization. timm's packaged
 # pretrained_cfg reports crop_pct=1.0 -> the timm default would instead Resize(224),
@@ -38,12 +52,12 @@ _GIGAPATH_STD = (0.229, 0.224, 0.225)
     patch_size=16,
     supported_spacing_um=0.5,
     precision="fp16",
-    source="prov-gigapath/prov-gigapath",
+    source=_HF_REPO_ID,
 )
 class GigaPath(TimmTileEncoder):
     def __init__(self, *, output_variant: str | None = None):
         super().__init__(
-            "hf_hub:prov-gigapath/prov-gigapath",
+            f"hf_hub:{_HF_REPO_ID}",
             output_variant=output_variant,
             dynamic_img_size=True,
         )
@@ -70,17 +84,17 @@ class GigaPath(TimmTileEncoder):
     default_output_variant="default",
     supported_spacing_um=0.5,
     precision="fp16",
-    source="prov-gigapath/prov-gigapath",
+    source=_HF_REPO_ID,
 )
 class GigaPathSlideEncoder(SlideEncoder):
     def __init__(self, *, output_variant: str | None = None):
         from gigapath.slide_encoder import create_model
 
-        self._model = create_model(
-            "hf_hub:prov-gigapath/prov-gigapath",
-            "gigapath_slide_enc12l768d",
-            1536,
-        )
+        # create_model given an "hf_hub:" name force-downloads into ~/.cache/ on every
+        # load, ignoring HF_HOME; a local path skips that download.
+        checkpoint_path = _slide_checkpoint_path()
+        # create_model returns the module in training mode (dropout and drop-path active).
+        self._model = create_model(checkpoint_path, "gigapath_slide_enc12l768d", 1536).eval()
         self._device = preferred_default_device()
         self._output_variant = resolve_requested_output_variant(output_variant)
 

{slide2vec-6.1.1 → slide2vec-6.3.0}/slide2vec/encoders/models/isight.py

@@ -84,6 +84,7 @@ from torchvision.transforms import v2
 from transformers import AutoProcessor, CLIPConfig, CLIPModel
 
 from slide2vec.encoders.base import (
+    ProcessorTransform,
     TileEncoder,
     attentions_tuple_to_grids,
     hf_eager_attention,
@@ -190,12 +191,7 @@ class ISight(TileEncoder):
         bicubic resize to 336, a 336 center crop, and OpenAI CLIP
         mean/std — the resize and crop are no-ops on tiles already cut at 336.
         """
-        processor = AutoProcessor.from_pretrained(_BASE_MODEL)
-
-        def transform(image):
-            return processor(images=image, return_tensors="pt")["pixel_values"].squeeze(0)
-
-        return transform
+        return ProcessorTransform(AutoProcessor.from_pretrained(_BASE_MODEL))
 
     def get_normalization_transform(self) -> Callable:
         image_processor = AutoProcessor.from_pretrained(_BASE_MODEL).image_processor

slide2vec-6.3.0/slide2vec/encoders/models/lunit.py

@@ -0,0 +1,55 @@
+"""Lunit ViT-S/8 tile encoder implementation.
+
+The ``1aurent`` hub ``config.json`` carries timm's stock ``vit_small_patch8_224.dino``
+data config (ImageNet mean/std, crop_pct 0.9). Lunit publishes no transform, so the
+geometry keeps that config (``Resize(248)`` -> ``CenterCrop(224)``), but both
+transforms normalize with Lunit's ViT-S training stats, as documented by kaiko-ai/eva
+(https://github.com/kaiko-ai/eva/blob/main/src/eva/vision/models/networks/backbones/pathology/lunit.py).
+"""
+
+from typing import Callable
+
+import torch
+from torchvision import transforms
+from torchvision.transforms import v2
+
+from slide2vec.encoders.base import TimmTileEncoder
+from slide2vec.encoders.registry import register_encoder
+
+_LUNIT_MEAN = (0.70322989, 0.53606487, 0.66096631)
+_LUNIT_STD = (0.21716536, 0.26081574, 0.20723464)
+
+
+@register_encoder(
+    "lunit",
+    output_variants={"default": {"encode_dim": 384}},
+    default_output_variant="default",
+    input_size=224,
+    supports_variable_input_size=True,
+    patch_size=8,
+    supported_spacing_um=0.5,
+    precision="fp32",
+    source="1aurent/vit_small_patch8_224.lunit_dino",
+)
+class LunitTileEncoder(TimmTileEncoder):
+    def __init__(self, *, output_variant: str | None = None):
+        super().__init__(
+            "hf_hub:1aurent/vit_small_patch8_224.lunit_dino",
+            output_variant=output_variant,
+            dynamic_img_size=True,  # enable dense extraction; no-op at native size
+        )
+
+    def get_transform(self) -> Callable:
+        return transforms.Compose([
+            transforms.Resize(248, interpolation=transforms.InterpolationMode.BICUBIC),
+            transforms.CenterCrop(224),
+            transforms.ToTensor(),
+            transforms.Normalize(mean=_LUNIT_MEAN, std=_LUNIT_STD),
+        ])
+
+    def get_normalization_transform(self) -> Callable:
+        return v2.Compose([
+            v2.ToImage(),
+            v2.ToDtype(torch.float32, scale=True),
+            v2.Normalize(mean=_LUNIT_MEAN, std=_LUNIT_STD),
+        ])