slide2vec 4.0.1__tar.gz → 4.0.2__tar.gz

{slide2vec-4.0.1 → slide2vec-4.0.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: slide2vec
-Version: 4.0.1
+Version: 4.0.2
 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,vips]>=3.1.3
+Requires-Dist: hs2p[asap,cucim,openslide,vips]>=3.1.4
 Requires-Dist: omegaconf
 Requires-Dist: matplotlib
 Requires-Dist: numpy<2
@@ -63,7 +63,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,vips]>=3.1.3; extra == "fm"
+Requires-Dist: hs2p[asap,cucim,openslide,vips]>=3.1.4; 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-4.0.1 → slide2vec-4.0.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "slide2vec"
-version = "4.0.1"
+version = "4.0.2"
 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,vips]>=3.1.3",
+    "hs2p[asap,cucim,openslide,vips]>=3.1.4",
     "omegaconf",
     "matplotlib",
     "numpy<2",
@@ -85,7 +85,7 @@ fm = [
     "pandas",
     "pillow",
     "rich",
-    "hs2p[asap,cucim,openslide,vips]>=3.1.3",
+    "hs2p[asap,cucim,openslide,vips]>=3.1.4",
     "wandb",
     "torch>=2.3,<2.8",
     "torchvision>=0.18.0",
@@ -154,7 +154,7 @@ no_implicit_reexport = true
 max-line-length = 160
 
 [tool.bumpver]
-current_version = "4.0.1"
+current_version = "4.0.2"
 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-4.0.1 → slide2vec-4.0.2}/slide2vec/__init__.py

@@ -2,7 +2,7 @@ from slide2vec.api import EmbeddedSlide, ExecutionOptions, Model, Pipeline, Prep
 from slide2vec.artifacts import HierarchicalEmbeddingArtifact, SlideEmbeddingArtifact, TileEmbeddingArtifact
 
 
-__version__ = "4.0.1"
+__version__ = "4.0.2"
 
 __all__ = [
     "Model",

{slide2vec-4.0.1 → slide2vec-4.0.2}/slide2vec/api.py

@@ -22,7 +22,7 @@ from slide2vec.encoders.validation import validate_encoder_config
 from slide2vec.model_settings import canonicalize_model_name, normalize_precision_name
 from slide2vec.progress import emit_progress
 from slide2vec.runtime_types import LoadedModel
-from slide2vec.utils.utils import slurm_cpu_limit
+from slide2vec.utils.utils import cpu_worker_limit, slurm_cpu_limit
 
 PathLike = str | Path
 
@@ -121,7 +121,7 @@ class ExecutionOptions:
     output_format: str = "pt"
     batch_size: int = 1
     num_workers: int = 0
-    num_preprocessing_workers: int = 8
+    num_preprocessing_workers: int | None = None
     num_gpus: int | None = None
     precision: str | None = None
     prefetch_factor: int = 4
@@ -141,7 +141,11 @@ class ExecutionOptions:
             output_format="pt",
             batch_size=int(cfg.model.batch_size),
             num_workers=int(num_workers),
-            num_preprocessing_workers=int(cfg.speed.num_preprocessing_workers),
+            num_preprocessing_workers=(
+                int(cfg.speed.num_preprocessing_workers)
+                if cfg.speed.num_preprocessing_workers is not None
+                else None
+            ),
             num_gpus=1 if run_on_cpu else (int(configured_num_gpus) if configured_num_gpus is not None else None),
             precision="fp32" if run_on_cpu else requested_precision,
             prefetch_factor=prefetch_factor,
@@ -158,11 +162,13 @@ class ExecutionOptions:
             raise ValueError("ExecutionOptions.num_gpus must be at least 1")
         if self.prefetch_factor < 1:
             raise ValueError("ExecutionOptions.prefetch_factor must be at least 1")
+        cap = cpu_worker_limit()
         cpu_count = os.cpu_count() or 1
         slurm_limit = slurm_cpu_limit()
-        cap = min(cpu_count, slurm_limit) if slurm_limit is not None else cpu_count
         capped_num_workers = min(self.num_workers, cap)
-        capped_num_preprocessing_workers = min(self.num_preprocessing_workers, cap)
+        capped_num_preprocessing_workers = (
+            cap if self.num_preprocessing_workers is None else min(self.num_preprocessing_workers, cap)
+        )
         object.__setattr__(self, "num_workers", capped_num_workers)
         object.__setattr__(self, "num_preprocessing_workers", capped_num_preprocessing_workers)
         logger = logging.getLogger(__name__)

{slide2vec-4.0.1 → slide2vec-4.0.2}/slide2vec/configs/default.yaml

@@ -68,7 +68,7 @@ speed:
   precision: # model inference precision ["fp32", "fp16", "bf16"]; if not set, determined automatically based on model recommendations
   num_dataloader_workers: 8 # number of DataLoader worker processes for reading tiles during embedding (tar path); on-the-fly path derives this automatically from cpu_count // speed.num_cucim_workers
   num_gpus: # number of GPUs to use for feature extraction; defaults to all available GPUs
-  num_preprocessing_workers: 8 # number of workers for hs2p tiling (WSI reading, JPEG encoding, tar writing)
+  num_preprocessing_workers: # number of workers for hs2p tiling (WSI reading, JPEG encoding, tar writing); defaults to the CPU budget at runtime
   num_cucim_workers: 4 # number of internal cucim threads per read_region call (embedding path, on-the-fly only); DataLoader workers are auto-set to cpu_count // num_cucim_workers
   prefetch_factor_embedding: 4 # prefetch factor for tile embedding dataloaders
   persistent_workers_embedding: true # keep DataLoader workers alive across epochs/batches

{slide2vec-4.0.1 → slide2vec-4.0.2}/slide2vec/data/tile_reader.py

@@ -1,4 +1,5 @@
 from collections import defaultdict
+from contextlib import nullcontext
 import time
 from pathlib import Path
 
@@ -6,7 +7,9 @@ import numpy as np
 import torch
 
 from hs2p import TilingResult
+from hs2p.utils.stderr import run_with_filtered_stderr
 from hs2p.wsi.streaming.plans import build_supertile_index
+from slide2vec.utils.log_utils import suppress_c_stderr
 
 
 class SuperTileBatchSampler:
@@ -139,15 +142,17 @@ class WSITileReader:
                 torch.empty((0, 3, ts, ts), dtype=torch.uint8),
                 {"reader_open_ms": 0.0, "reader_read_ms": 0.0},
             )
-        was_closed = self._reader is None
-        open_start = time.perf_counter()
-        self._ensure_open()
-        reader_open_ms = (time.perf_counter() - open_start) * 1000.0 if was_closed else 0.0
-        read_start = time.perf_counter()
-        if self._use_supertiles:
-            tensor = self._read_batch_supertiles(tile_indices)
-        else:
-            tensor = self._read_batch_simple(tile_indices)
+        stderr_context = suppress_c_stderr() if self._backend == "cucim" else nullcontext()
+        with stderr_context:
+            was_closed = self._reader is None
+            open_start = time.perf_counter()
+            self._ensure_open()
+            reader_open_ms = (time.perf_counter() - open_start) * 1000.0 if was_closed else 0.0
+            read_start = time.perf_counter()
+            if self._use_supertiles:
+                tensor = self._read_batch_supertiles(tile_indices)
+            else:
+                tensor = self._read_batch_simple(tile_indices)
         reader_read_ms = (time.perf_counter() - read_start) * 1000.0
         return tensor, {"reader_open_ms": reader_open_ms, "reader_read_ms": reader_read_ms}
 
@@ -260,11 +265,16 @@ class OnTheFlyBatchTileCollator:
                 torch.empty((0, 3, self.tile_size, self.tile_size), dtype=torch.uint8),
                 {"worker_batch_ms": 0.0, "reader_open_ms": 0.0, "reader_read_ms": 0.0},
             )
-        worker_start = time.perf_counter()
-        tile_indices = np.asarray(batch_indices, dtype=np.int64)
-        tensor, timing = self._reader.read_batch_with_timing(tile_indices)
-        timing["worker_batch_ms"] = (time.perf_counter() - worker_start) * 1000.0
-        return torch.as_tensor(tile_indices, dtype=torch.long), tensor, timing
+        def _run_batch():
+            worker_start = time.perf_counter()
+            tile_indices = np.asarray(batch_indices, dtype=np.int64)
+            tensor, timing = self._reader.read_batch_with_timing(tile_indices)
+            timing["worker_batch_ms"] = (time.perf_counter() - worker_start) * 1000.0
+            return torch.as_tensor(tile_indices, dtype=torch.long), tensor, timing
+
+        if getattr(self._reader, "_backend", None) == "cucim":
+            return run_with_filtered_stderr(_run_batch)
+        return _run_batch()
 
 
 class WSIRegionReader:
@@ -320,12 +330,14 @@ class WSIRegionReader:
                 torch.empty((0, 3, self._region_size_px, self._region_size_px), dtype=torch.uint8),
                 {"reader_open_ms": 0.0, "reader_read_ms": 0.0},
             )
-        was_closed = self._reader is None
-        open_start = time.perf_counter()
-        self._ensure_open()
-        reader_open_ms = (time.perf_counter() - open_start) * 1000.0 if was_closed else 0.0
-        read_start = time.perf_counter()
-        regions = self._read_regions_batch(locations)
+        stderr_context = suppress_c_stderr() if self._backend == "cucim" else nullcontext()
+        with stderr_context:
+            was_closed = self._reader is None
+            open_start = time.perf_counter()
+            self._ensure_open()
+            reader_open_ms = (time.perf_counter() - open_start) * 1000.0 if was_closed else 0.0
+            read_start = time.perf_counter()
+            regions = self._read_regions_batch(locations)
         reader_read_ms = (time.perf_counter() - read_start) * 1000.0
         batch = np.stack([np.asarray(region)[:, :, :3] for region in regions], axis=0)
         tensor = torch.from_numpy(batch).permute(0, 3, 1, 2).contiguous()
@@ -385,17 +397,22 @@ class OnTheFlyHierarchicalBatchCollator:
                 torch.empty((0, 3, self._tile_size, self._tile_size), dtype=torch.uint8),
                 {"worker_batch_ms": 0.0, "reader_open_ms": 0.0, "reader_read_ms": 0.0},
             )
-        worker_start = time.perf_counter()
-        flat_indices = np.asarray(batch_indices, dtype=np.int64)
-        requested_regions = self._region_index[flat_indices]
-        unique_regions, inverse = np.unique(requested_regions, return_inverse=True)
-        locations = [self._region_locations[int(region)] for region in unique_regions]
-        region_tensor, timing = self._reader.read_batch_with_timing(locations)
-        unfolded = _unfold_region_tensor_uint8(region_tensor, self._tile_size)
-        subtile_indices = self._subtile_index_within_region[flat_indices]
-        out = unfolded[torch.as_tensor(inverse, dtype=torch.long), torch.as_tensor(subtile_indices, dtype=torch.long)]
-        timing["worker_batch_ms"] = (time.perf_counter() - worker_start) * 1000.0
-        return torch.as_tensor(flat_indices, dtype=torch.long), out, timing
+        def _run_batch():
+            worker_start = time.perf_counter()
+            flat_indices = np.asarray(batch_indices, dtype=np.int64)
+            requested_regions = self._region_index[flat_indices]
+            unique_regions, inverse = np.unique(requested_regions, return_inverse=True)
+            locations = [self._region_locations[int(region)] for region in unique_regions]
+            region_tensor, timing = self._reader.read_batch_with_timing(locations)
+            unfolded = _unfold_region_tensor_uint8(region_tensor, self._tile_size)
+            subtile_indices = self._subtile_index_within_region[flat_indices]
+            out = unfolded[torch.as_tensor(inverse, dtype=torch.long), torch.as_tensor(subtile_indices, dtype=torch.long)]
+            timing["worker_batch_ms"] = (time.perf_counter() - worker_start) * 1000.0
+            return torch.as_tensor(flat_indices, dtype=torch.long), out, timing
+
+        if getattr(self._reader, "_backend", None) == "cucim":
+            return run_with_filtered_stderr(_run_batch)
+        return _run_batch()
 
 
 def _unfold_region_tensor_uint8(region_tensor: torch.Tensor, tile_size: int) -> torch.Tensor:

{slide2vec-4.0.1 → slide2vec-4.0.2}/slide2vec/inference.py

@@ -17,6 +17,7 @@ import logging
 import pandas as pd
 import torch
 from hs2p import SlideSpec, FilterConfig, PreviewConfig, SegmentationConfig, TilingConfig, load_tiling_result, tile_slides
+from hs2p.utils.stderr import run_with_filtered_stderr
 import numpy as np
 from transformers.image_processing_utils import BaseImageProcessor
 
@@ -58,7 +59,7 @@ from slide2vec.utils.tiling_io import (
     load_tiling_result_from_row,
     _optional_float,
 )
-from slide2vec.utils.utils import slurm_cpu_limit
+from slide2vec.utils.utils import cpu_worker_limit, slurm_cpu_limit
 
 
 @dataclass(frozen=True, kw_only=True)
@@ -174,17 +175,58 @@ def _num_embedding_items(tiling_result, preprocessing: PreprocessingConfig | Non
 
 def _resolve_on_the_fly_num_workers(num_cucim_workers: int) -> tuple[int, str]:
     cpu_count = os.cpu_count() or 1
-    worker_budget = cpu_count
+    worker_budget = cpu_worker_limit()
     details = [f"cpu_count={cpu_count}"]
     slurm_limit = slurm_cpu_limit()
     if slurm_limit is not None:
-        worker_budget = min(worker_budget, slurm_limit)
         details.append(f"slurm_cpu_limit={slurm_limit}")
     effective_num_workers = max(1, worker_budget // num_cucim_workers)
     details.append(f"num_cucim_workers={num_cucim_workers}")
     return effective_num_workers, " // ".join(details)
 
 
+def _redirect_worker_output() -> None:
+    worker_log_path = os.path.join(
+        tempfile.gettempdir(),
+        "slide2vec-cucim-workers.log",
+    )
+    worker_log_fd = os.open(
+        worker_log_path,
+        os.O_WRONLY | os.O_CREAT | os.O_APPEND,
+        0o644,
+    )
+    try:
+        os.dup2(worker_log_fd, 1)
+        os.dup2(worker_log_fd, 2)
+    finally:
+        os.close(worker_log_fd)
+
+
+def _configure_cucim_worker_stderr(loader_kwargs: dict[str, Any], *, backend: str) -> None:
+    if backend != "cucim" or int(loader_kwargs.get("num_workers", 0)) <= 0:
+        return
+    existing_worker_init = loader_kwargs.get("worker_init_fn")
+
+    def _worker_init(worker_id: int) -> None:
+        _redirect_worker_output()
+        if existing_worker_init is not None:
+            existing_worker_init(worker_id)
+
+    loader_kwargs["worker_init_fn"] = _worker_init
+
+
+def _should_suppress_cucim_dataloader_stderr(dataloader) -> bool:
+    if int(getattr(dataloader, "num_workers", 0)) <= 0:
+        return False
+    collate_fn = getattr(dataloader, "collate_fn", None)
+    reader = getattr(collate_fn, "_reader", None)
+    return getattr(reader, "_backend", None) == "cucim"
+
+
+def _uses_cuda_runtime(device) -> bool:
+    return str(device).startswith("cuda") and torch.cuda.is_available()
+
+
 def _make_slide_spec(
     *,
     sample_id: str,
@@ -1105,7 +1147,7 @@ def _compute_tile_embeddings_for_slide(
     autocast_dtype = _autocast_dtype(torch, execution.precision)
     autocast_context = (
         torch.autocast(device_type="cuda", dtype=autocast_dtype)
-        if autocast_dtype is not None and str(loaded.device).startswith("cuda")
+        if autocast_dtype is not None and _uses_cuda_runtime(loaded.device)
         else nullcontext()
     )
     resolved_indices = np.arange(_num_tiles(tiling_result), dtype=np.int64)
@@ -1163,6 +1205,7 @@ def _compute_tile_embeddings_for_slide(
         tiling_result,
     )
     loader_kwargs = _embedding_dataloader_kwargs(loaded, execution)
+    resolved_backend = _resolve_slide_backend(preprocessing, tiling_result)
     if preprocessing.on_the_fly and preprocessing.read_tiles_from is None:
         effective_num_workers, worker_context = _resolve_on_the_fly_num_workers(preprocessing.num_cucim_workers)
         if effective_num_workers != execution.num_workers:
@@ -1175,6 +1218,7 @@ def _compute_tile_embeddings_for_slide(
         if effective_num_workers == 0:
             loader_kwargs.pop("persistent_workers", None)
             loader_kwargs.pop("prefetch_factor", None)
+        _configure_cucim_worker_stderr(loader_kwargs, backend=resolved_backend)
     if batch_sampler is not None:
         loader_kwargs["batch_sampler"] = batch_sampler
     else:
@@ -1185,15 +1229,21 @@ def _compute_tile_embeddings_for_slide(
         collate_fn=collate_fn,
         **loader_kwargs,
     )
-    tile_embeddings = _run_forward_pass(
-        dataloader,
-        loaded,
-        autocast_context,
-        batch_preprocessor=batch_preprocessor,
-        sample_id=slide.sample_id,
-        total_items=len(dataset),
-        unit_label="tile",
-    )
+    def _compute_embeddings():
+        return _run_forward_pass(
+            dataloader,
+            loaded,
+            autocast_context,
+            batch_preprocessor=batch_preprocessor,
+            sample_id=slide.sample_id,
+            total_items=len(dataset),
+            unit_label="tile",
+        )
+
+    if resolved_backend == "cucim":
+        tile_embeddings = run_with_filtered_stderr(_compute_embeddings)
+    else:
+        tile_embeddings = _compute_embeddings()
     if _supertile_reorder is not None:
         inverse = np.argsort(_supertile_reorder, kind="stable")
         tile_embeddings = tile_embeddings[torch.as_tensor(inverse, dtype=torch.long)]
@@ -1240,6 +1290,7 @@ def _compute_hierarchical_embeddings_for_slide(
     )
     loader_kwargs = _embedding_dataloader_kwargs(loaded, execution)
     effective_num_workers, worker_context = _resolve_on_the_fly_num_workers(preprocessing.num_cucim_workers)
+    resolved_backend = _resolve_slide_backend(preprocessing, tiling_result)
     if effective_num_workers != execution.num_workers:
         logging.getLogger(__name__).info(
             f"on-the-fly hierarchical mode: setting DataLoader num_workers={effective_num_workers} "
@@ -1250,6 +1301,10 @@ def _compute_hierarchical_embeddings_for_slide(
     if effective_num_workers == 0:
         loader_kwargs.pop("persistent_workers", None)
         loader_kwargs.pop("prefetch_factor", None)
+    _configure_cucim_worker_stderr(
+        loader_kwargs,
+        backend=resolved_backend,
+    )
     loader_kwargs["batch_sampler"] = collate_fn.build_batch_sampler(
         batch_size=execution.batch_size,
         dataset_indices=np.asarray(resolved_indices, dtype=np.int64),
@@ -1262,19 +1317,25 @@ def _compute_hierarchical_embeddings_for_slide(
     autocast_dtype = _autocast_dtype(torch, execution.precision)
     autocast_context = (
         torch.autocast(device_type="cuda", dtype=autocast_dtype)
-        if autocast_dtype is not None and str(loaded.device).startswith("cuda")
+        if autocast_dtype is not None and _uses_cuda_runtime(loaded.device)
         else nullcontext()
     )
-    batch_flat_indices, flat_embeddings = _run_forward_pass(
-        dataloader,
-        loaded,
-        autocast_context,
-        batch_preprocessor=batch_preprocessor,
-        sample_id=slide.sample_id,
-        total_items=len(dataset),
-        unit_label="tile",
-        return_indices=True,
-    )
+    def _compute_embeddings():
+        return _run_forward_pass(
+            dataloader,
+            loaded,
+            autocast_context,
+            batch_preprocessor=batch_preprocessor,
+            sample_id=slide.sample_id,
+            total_items=len(dataset),
+            unit_label="tile",
+            return_indices=True,
+        )
+
+    if resolved_backend == "cucim":
+        batch_flat_indices, flat_embeddings = run_with_filtered_stderr(_compute_embeddings)
+    else:
+        batch_flat_indices, flat_embeddings = _compute_embeddings()
     result = torch.empty(
         (index.num_regions * index.tiles_per_region, int(flat_embeddings.shape[-1])),
         dtype=flat_embeddings.dtype,
@@ -1316,10 +1377,15 @@ def _compute_hierarchical_embedding_shard_for_slide(
     )
     loader_kwargs = _embedding_dataloader_kwargs(loaded, execution)
     effective_num_workers, _worker_context = _resolve_on_the_fly_num_workers(preprocessing.num_cucim_workers)
+    resolved_backend = _resolve_slide_backend(preprocessing, tiling_result)
     loader_kwargs["num_workers"] = effective_num_workers
     if effective_num_workers == 0:
         loader_kwargs.pop("persistent_workers", None)
         loader_kwargs.pop("prefetch_factor", None)
+    _configure_cucim_worker_stderr(
+        loader_kwargs,
+        backend=resolved_backend,
+    )
     loader_kwargs["batch_sampler"] = collate_fn.build_batch_sampler(
         batch_size=execution.batch_size,
         dataset_indices=resolved_indices,
@@ -1328,19 +1394,25 @@ def _compute_hierarchical_embedding_shard_for_slide(
     autocast_dtype = _autocast_dtype(torch, execution.precision)
     autocast_context = (
         torch.autocast(device_type="cuda", dtype=autocast_dtype)
-        if autocast_dtype is not None and str(loaded.device).startswith("cuda")
+        if autocast_dtype is not None and _uses_cuda_runtime(loaded.device)
         else nullcontext()
     )
-    batch_flat_indices, flat_embeddings = _run_forward_pass(
-        dataloader,
-        loaded,
-        autocast_context,
-        batch_preprocessor=batch_preprocessor,
-        sample_id=slide.sample_id,
-        total_items=len(dataset),
-        unit_label="tile",
-        return_indices=True,
-    )
+    def _compute_embeddings():
+        return _run_forward_pass(
+            dataloader,
+            loaded,
+            autocast_context,
+            batch_preprocessor=batch_preprocessor,
+            sample_id=slide.sample_id,
+            total_items=len(dataset),
+            unit_label="tile",
+            return_indices=True,
+        )
+
+    if resolved_backend == "cucim":
+        batch_flat_indices, flat_embeddings = run_with_filtered_stderr(_compute_embeddings)
+    else:
+        batch_flat_indices, flat_embeddings = _compute_embeddings()
     return batch_flat_indices.numpy(), flat_embeddings
 
 
@@ -1616,7 +1688,7 @@ def _write_hierarchical_embedding_artifact(
 def _embedding_dataloader_kwargs(loaded: LoadedModel, execution: ExecutionOptions) -> dict[str, Any]:
     kwargs: dict[str, Any] = {
         "num_workers": execution.num_workers,
-        "pin_memory": str(loaded.device).startswith("cuda"),
+        "pin_memory": _uses_cuda_runtime(loaded.device),
     }
     if execution.num_workers > 0:
         kwargs["persistent_workers"] = bool(execution.persistent_workers)
@@ -1836,7 +1908,7 @@ class _BatchPrefetcher:
         raise ValueError("Expected the embedding dataloader to yield (indices, image) or (indices, image, timing)")
 
     def _make_copy_stream(self):
-        if not str(self.loaded.device).startswith("cuda"):
+        if not _uses_cuda_runtime(self.loaded.device):
             return None
         return torch.cuda.Stream(device=self.loaded.device)
 
@@ -1867,7 +1939,7 @@ class _BatchPrefetcher:
             if torch.is_tensor(prepared) and prepared.device != self.loaded.device:
                 prepared = prepared.to(
                     self.loaded.device,
-                    non_blocking=str(self.loaded.device).startswith("cuda"),
+                    non_blocking=_uses_cuda_runtime(self.loaded.device),
                 )
         preprocess_ms = (time.perf_counter() - preprocess_start) * 1000.0
         return prepared, preprocess_ms
@@ -1947,7 +2019,13 @@ def _run_forward_pass(
     batch_indices = [] if return_indices else None
     processed = 0
     batch_index = 0
-    prefetcher = _BatchPrefetcher(dataloader, loaded, batch_preprocessor)
+    prefetcher_context = (
+        suppress_c_stderr()
+        if _should_suppress_cucim_dataloader_stderr(dataloader)
+        else nullcontext()
+    )
+    with prefetcher_context:
+        prefetcher = _BatchPrefetcher(dataloader, loaded, batch_preprocessor)
     with torch.inference_mode(), autocast_context:
         for prepared_batch in prefetcher:
             image = prepared_batch.image
@@ -2185,6 +2263,7 @@ def _prepare_tiled_slides(
     _record_slide_metadata_in_process_list(
         process_list_path,
         slide_records,
+        preprocessing=preprocessing,
         tiling_artifacts=tiling_artifacts,
     )
     process_df = load_tiling_process_df(process_list_path)
@@ -2298,6 +2377,7 @@ def _record_slide_metadata_in_process_list(
     process_list_path: Path,
     slide_records: Sequence[SlideSpec],
     *,
+    preprocessing: PreprocessingConfig,
     tiling_artifacts: Sequence[Any],
 ) -> None:
     def _resolve_path_str(value: Any) -> str | None:
@@ -2319,18 +2399,40 @@ def _record_slide_metadata_in_process_list(
         for artifact in tiling_artifacts
     }
     process_df = pd.read_csv(process_list_path)
+    if "requested_backend" not in process_df.columns:
+        process_df["requested_backend"] = [None] * len(process_df)
+    if "backend" not in process_df.columns:
+        process_df["backend"] = [None] * len(process_df)
     if "spacing_at_level_0" not in process_df.columns:
         process_df["spacing_at_level_0"] = [None] * len(process_df)
     if "mask_preview_path" not in process_df.columns:
         process_df["mask_preview_path"] = [None] * len(process_df)
     if "tiling_preview_path" not in process_df.columns:
         process_df["tiling_preview_path"] = [None] * len(process_df)
+    requested_backend = str(preprocessing.backend)
+    process_df["requested_backend"] = process_df["requested_backend"].where(
+        process_df["requested_backend"].notna(),
+        requested_backend,
+    )
     if spacing_by_sample_id:
         mapped_spacing = process_df["sample_id"].astype(str).map(spacing_by_sample_id)
         process_df["spacing_at_level_0"] = process_df["spacing_at_level_0"].where(
             process_df["spacing_at_level_0"].notna(),
             mapped_spacing,
         )
+    backend_by_sample_id = {}
+    for row in process_df.to_dict("records"):
+        sample_id = str(row["sample_id"])
+        try:
+            tiling_result = load_tiling_result_from_row(row)
+        except Exception:
+            continue
+        backend = getattr(tiling_result, "backend", None)
+        if backend is not None:
+            backend_by_sample_id[sample_id] = backend
+    if backend_by_sample_id:
+        mapped_backend = process_df["sample_id"].astype(str).map(backend_by_sample_id)
+        process_df["backend"] = process_df["backend"].where(process_df["backend"].notna(), mapped_backend)
     mapped_mask_preview_paths = process_df["sample_id"].astype(str).map(mask_preview_by_sample_id)
     process_df["mask_preview_path"] = process_df["mask_preview_path"].where(
         process_df["mask_preview_path"].notna(),

{slide2vec-4.0.1 → slide2vec-4.0.2}/slide2vec/utils/tiling_io.py

@@ -11,6 +11,8 @@ BASE_PROCESS_COLUMNS = (
     "sample_id",
     "image_path",
     "mask_path",
+    "requested_backend",
+    "backend",
     "tiling_status",
     "num_tiles",
     "coordinates_npz_path",
@@ -22,6 +24,8 @@ BASE_TILING_ORDERED_COLUMNS = (
     "sample_id",
     "image_path",
     "mask_path",
+    "requested_backend",
+    "backend",
     "spacing_at_level_0",
     "tiling_status",
     "num_tiles",
@@ -37,6 +41,8 @@ BASE_EMBEDDING_ORDERED_COLUMNS = (
     "sample_id",
     "image_path",
     "mask_path",
+    "requested_backend",
+    "backend",
     "spacing_at_level_0",
     "tiling_status",
     "num_tiles",
@@ -160,12 +166,14 @@ def load_embedding_process_df(
 
 
 def load_tiling_result_from_row(row):
+    coordinates_npz_path = _optional_path(row.get("coordinates_npz_path"))
+    coordinates_meta_path = Path(row["coordinates_meta_path"])
     tiling_result = load_tiling_result(
-        coordinates_npz_path=Path(row["coordinates_npz_path"]),
-        coordinates_meta_path=Path(row["coordinates_meta_path"]),
+        coordinates_npz_path=coordinates_npz_path,
+        coordinates_meta_path=coordinates_meta_path,
     )
-    setattr(tiling_result, "coordinates_npz_path", Path(row["coordinates_npz_path"]))
-    setattr(tiling_result, "coordinates_meta_path", Path(row["coordinates_meta_path"]))
+    setattr(tiling_result, "coordinates_npz_path", coordinates_npz_path)
+    setattr(tiling_result, "coordinates_meta_path", coordinates_meta_path)
     setattr(tiling_result, "tiles_tar_path", _optional_path(row.get("tiles_tar_path")))
     setattr(tiling_result, "mask_preview_path", _optional_path(row.get("mask_preview_path")))
     setattr(tiling_result, "tiling_preview_path", _optional_path(row.get("tiling_preview_path")))