slide2vec 4.0.2__tar.gz → 4.0.4__tar.gz

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

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

{slide2vec-4.0.2 → slide2vec-4.0.4}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "slide2vec"
-version = "4.0.2"
+version = "4.0.4"
 description = "Embedding of whole slide images with Foundation Models"
 readme = "README.md"
 requires-python = ">=3.10"
@@ -154,7 +154,7 @@ no_implicit_reexport = true
 max-line-length = 160
 
 [tool.bumpver]
-current_version = "4.0.2"
+current_version = "4.0.4"
 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.2 → slide2vec-4.0.4}/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.2"
+__version__ = "4.0.4"
 
 __all__ = [
     "Model",

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

@@ -120,7 +120,7 @@ class ExecutionOptions:
     output_dir: Path | None = None
     output_format: str = "pt"
     batch_size: int = 1
-    num_workers: int = 0
+    num_workers: int | None = None
     num_preprocessing_workers: int | None = None
     num_gpus: int | None = None
     precision: str | None = None
@@ -140,7 +140,7 @@ class ExecutionOptions:
             output_dir=Path(cfg.output_dir),
             output_format="pt",
             batch_size=int(cfg.model.batch_size),
-            num_workers=int(num_workers),
+            num_workers=int(num_workers) if num_workers is not None else None,
             num_preprocessing_workers=(
                 int(cfg.speed.num_preprocessing_workers)
                 if cfg.speed.num_preprocessing_workers is not None
@@ -165,23 +165,30 @@ class ExecutionOptions:
         cap = cpu_worker_limit()
         cpu_count = os.cpu_count() or 1
         slurm_limit = slurm_cpu_limit()
-        capped_num_workers = min(self.num_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__)
         cap_source = f"slurm_cpu_limit={slurm_limit}" if slurm_limit is not None else f"cpu_count={cpu_count}"
+        resolved_num_workers = self.resolved_num_workers()
+        num_workers_label = (
+            f"{resolved_num_workers} (requested=auto)"
+            if self.num_workers is None
+            else str(resolved_num_workers)
+        )
         logger.info(
-            "ExecutionOptions: num_workers=%d, num_preprocessing_workers=%d "
-            "(cap=%d via %s)",
-            capped_num_workers,
+            "ExecutionOptions: num_workers=%s, num_preprocessing_workers=%d "
+            "(preprocessing cap=%d via %s)",
+            num_workers_label,
             capped_num_preprocessing_workers,
             cap,
             cap_source,
         )
 
+    def resolved_num_workers(self) -> int:
+        return cpu_worker_limit() if self.num_workers is None else int(self.num_workers)
+
     def with_output_dir(self, output_dir: PathLike | None) -> "ExecutionOptions":
         if output_dir is None:
             return self

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

@@ -66,9 +66,9 @@ tiling:
 
 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_dataloader_workers: # number of DataLoader worker processes for reading tiles during embedding; defaults to auto (job CPU budget, except cuCIM on-the-fly uses cpu_budget // speed.num_cucim_workers)
   num_gpus: # number of GPUs to use for feature extraction; defaults to all available GPUs
-  num_preprocessing_workers: # number of workers for hs2p tiling (WSI reading, JPEG encoding, tar writing); defaults to the CPU budget at runtime
+  num_preprocessing_workers: # number of workers for hs2p tiling (WSI reading, JPEG encoding, tar writing); defaults to the runtime CPU budget capped at 64
   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.2 → slide2vec-4.0.4}/slide2vec/inference.py

@@ -39,7 +39,11 @@ from slide2vec.artifacts import (
     write_tile_embedding_metadata,
     write_tile_embeddings,
 )
-from slide2vec.encoders.registry import encoder_registry, resolve_preprocessing_defaults
+from slide2vec.encoders.registry import (
+    encoder_registry,
+    resolve_encoder_output,
+    resolve_preprocessing_defaults,
+)
 from slide2vec.model_settings import canonicalize_model_name
 from slide2vec.runtime_types import LoadedModel
 from slide2vec.progress import (
@@ -386,6 +390,8 @@ def embed_slides(
                         persist_tile_embeddings=persist_tile_embeddings,
                         persist_hierarchical_embeddings=persist_hierarchical_embeddings,
                         include_slide_embeddings=include_slide_embeddings,
+                        encoder_name=model.name,
+                        output_variant=_resolved_process_list_output_variant(model),
                         tile_artifacts=tile_artifacts,
                         hierarchical_artifacts=hierarchical_artifacts,
                         slide_artifacts=slide_artifacts,
@@ -717,6 +723,8 @@ def run_pipeline(
             persist_tile_embeddings=persist_tile_embeddings,
             persist_hierarchical_embeddings=persist_hierarchical_embeddings,
             include_slide_embeddings=include_slide_embeddings,
+            encoder_name=model.name,
+            output_variant=_resolved_process_list_output_variant(model),
             tile_artifacts=tile_artifacts,
             hierarchical_artifacts=hierarchical_artifacts,
             slide_artifacts=slide_artifacts,
@@ -903,6 +911,8 @@ def _build_incremental_persist_callback(
                 persist_tile_embeddings=persist_tile_embeddings,
                 persist_hierarchical_embeddings=persist_hierarchical_embeddings,
                 include_slide_embeddings=include_slide_embeddings,
+                encoder_name=model.name,
+                output_variant=_resolved_process_list_output_variant(model),
                 tile_artifacts=[tile_artifact] if isinstance(tile_artifact, TileEmbeddingArtifact) else [],
                 hierarchical_artifacts=[tile_artifact] if isinstance(tile_artifact, HierarchicalEmbeddingArtifact) else [],
                 slide_artifacts=[slide_artifact] if slide_artifact is not None else [],
@@ -1054,6 +1064,8 @@ def _collect_distributed_pipeline_artifacts(
         persist_tile_embeddings=persist_tile_embeddings,
         persist_hierarchical_embeddings=persist_hierarchical_embeddings,
         include_slide_embeddings=include_slide_embeddings,
+        encoder_name=model.name,
+        output_variant=_resolved_process_list_output_variant(model),
         tile_artifacts=tile_artifacts,
         hierarchical_artifacts=hierarchical_artifacts,
         slide_artifacts=slide_artifacts,
@@ -1206,7 +1218,7 @@ def _compute_tile_embeddings_for_slide(
     )
     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:
+    if preprocessing.on_the_fly and preprocessing.read_tiles_from is None and resolved_backend == "cucim":
         effective_num_workers, worker_context = _resolve_on_the_fly_num_workers(preprocessing.num_cucim_workers)
         if effective_num_workers != execution.num_workers:
             logging.getLogger(__name__).info(
@@ -1289,18 +1301,19 @@ def _compute_hierarchical_embeddings_for_slide(
         target_tile_size_px=int(geometry["target_tile_size_px"]),
     )
     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} "
-            f"({worker_context}); "
-            f"ignoring speed.num_dataloader_workers={execution.num_workers}"
-        )
-    loader_kwargs["num_workers"] = effective_num_workers
-    if effective_num_workers == 0:
-        loader_kwargs.pop("persistent_workers", None)
-        loader_kwargs.pop("prefetch_factor", None)
+    if resolved_backend == "cucim":
+        effective_num_workers, worker_context = _resolve_on_the_fly_num_workers(preprocessing.num_cucim_workers)
+        if effective_num_workers != execution.num_workers:
+            logging.getLogger(__name__).info(
+                f"on-the-fly hierarchical mode: setting DataLoader num_workers={effective_num_workers} "
+                f"({worker_context}); "
+                f"ignoring speed.num_dataloader_workers={execution.num_workers}"
+            )
+        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,
@@ -1376,12 +1389,13 @@ def _compute_hierarchical_embedding_shard_for_slide(
         target_tile_size_px=int(geometry["target_tile_size_px"]),
     )
     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)
+    if resolved_backend == "cucim":
+        effective_num_workers, _worker_context = _resolve_on_the_fly_num_workers(preprocessing.num_cucim_workers)
+        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,
@@ -1686,11 +1700,12 @@ def _write_hierarchical_embedding_artifact(
 
 
 def _embedding_dataloader_kwargs(loaded: LoadedModel, execution: ExecutionOptions) -> dict[str, Any]:
+    resolved_num_workers = execution.resolved_num_workers()
     kwargs: dict[str, Any] = {
-        "num_workers": execution.num_workers,
+        "num_workers": resolved_num_workers,
         "pin_memory": _uses_cuda_runtime(loaded.device),
     }
-    if execution.num_workers > 0:
+    if resolved_num_workers > 0:
         kwargs["persistent_workers"] = bool(execution.persistent_workers)
         kwargs["prefetch_factor"] = int(execution.prefetch_factor)
     return kwargs
@@ -2245,6 +2260,17 @@ def _should_persist_tile_embeddings(model, execution: ExecutionOptions) -> bool:
     return True
 
 
+def _resolved_process_list_output_variant(model) -> str | None:
+    requested_output_variant = getattr(model, "_output_variant", None)
+    if not hasattr(model, "name") or model.name not in encoder_registry:
+        return requested_output_variant
+    resolved = resolve_encoder_output(
+        model.name,
+        requested_output_variant=requested_output_variant,
+    )
+    return str(resolved["output_variant"])
+
+
 def _prepare_tiled_slides(
     slide_records: Sequence[SlideSpec],
     preprocessing: PreprocessingConfig,
@@ -3043,7 +3069,7 @@ def deserialize_preprocessing(payload: dict[str, Any]) -> PreprocessingConfig:
 def deserialize_execution(payload: dict[str, Any]) -> ExecutionOptions:
     output_dir = payload["output_dir"] if "output_dir" in payload else None
     batch_size = payload["batch_size"] if "batch_size" in payload else None
-    num_workers = payload["num_workers"] if "num_workers" in payload else 0
+    num_workers = payload["num_workers"] if "num_workers" in payload else None
     num_gpus = payload["num_gpus"] if "num_gpus" in payload else 1
     precision = payload["precision"] if "precision" in payload else "fp32"
     prefetch_factor = payload["prefetch_factor"] if "prefetch_factor" in payload else 4
@@ -3058,7 +3084,7 @@ def deserialize_execution(payload: dict[str, Any]) -> ExecutionOptions:
         output_dir=Path(output_dir) if output_dir is not None else None,
         output_format=payload["output_format"] if "output_format" in payload else "pt",
         batch_size=batch_size,
-        num_workers=int(num_workers),
+        num_workers=int(num_workers) if num_workers is not None else None,
         num_gpus=int(num_gpus),
         precision=precision,
         prefetch_factor=int(prefetch_factor),
@@ -3163,6 +3189,8 @@ def _update_process_list_after_embedding(
     persist_tile_embeddings: bool,
     persist_hierarchical_embeddings: bool,
     include_slide_embeddings: bool,
+    encoder_name: str,
+    output_variant: str | None,
     tile_artifacts: Sequence[TileEmbeddingArtifact],
     hierarchical_artifacts: Sequence[HierarchicalEmbeddingArtifact],
     slide_artifacts: Sequence[SlideEmbeddingArtifact],
@@ -3177,6 +3205,12 @@ def _update_process_list_after_embedding(
         df["feature_status"] = ["tbp"] * len(df)
     if "feature_path" not in df.columns:
         df["feature_path"] = [None] * len(df)
+    if "encoder_name" not in df.columns:
+        df["encoder_name"] = [None] * len(df)
+    if "output_variant" not in df.columns:
+        df["output_variant"] = [None] * len(df)
+    if "feature_kind" not in df.columns:
+        df["feature_kind"] = [None] * len(df)
     if include_slide_embeddings and "aggregation_status" not in df.columns:
         df["aggregation_status"] = ["tbp"] * len(df)
     tile_success_ids = {artifact.sample_id for artifact in tile_artifacts}
@@ -3184,28 +3218,34 @@ def _update_process_list_after_embedding(
     slide_success_ids = {artifact.sample_id for artifact in slide_artifacts}
     if slide_artifacts:
         feature_path_by_sample_id = {artifact.sample_id: _resolve_path_str(artifact.path) for artifact in slide_artifacts}
+        feature_kind = "slide"
+        feature_success_ids = slide_success_ids
     elif persist_hierarchical_embeddings:
         feature_path_by_sample_id = {
             artifact.sample_id: _resolve_path_str(artifact.path) for artifact in hierarchical_artifacts
         }
+        feature_kind = "hierarchical"
+        feature_success_ids = hierarchical_success_ids
     elif persist_tile_embeddings:
         feature_path_by_sample_id = {
             artifact.sample_id: _resolve_path_str(artifact.path) for artifact in tile_artifacts
         }
+        feature_kind = "tile"
+        feature_success_ids = tile_success_ids
     else:
         feature_path_by_sample_id = {}
+        feature_kind = None
+        feature_success_ids = {slide.sample_id for slide in successful_slides}
     for slide in successful_slides:
         mask = df["sample_id"].astype(str) == slide.sample_id
-        if persist_hierarchical_embeddings:
-            feature_status = "success" if slide.sample_id in hierarchical_success_ids else "error"
-        elif persist_tile_embeddings:
-            feature_status = "success" if slide.sample_id in tile_success_ids else "error"
-        else:
-            feature_status = "success"
+        feature_status = "success" if slide.sample_id in feature_success_ids else "error"
         df.loc[mask, "feature_status"] = feature_status
         mapped_feature_path = feature_path_by_sample_id.get(slide.sample_id)
         if mapped_feature_path is not None:
             df.loc[mask, "feature_path"] = mapped_feature_path
+            df.loc[mask, "encoder_name"] = encoder_name
+            df.loc[mask, "output_variant"] = output_variant
+            df.loc[mask, "feature_kind"] = feature_kind
         if include_slide_embeddings:
             df.loc[mask, "aggregation_status"] = (
                 "success" if slide.sample_id in slide_success_ids else "error"

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

@@ -53,6 +53,9 @@ BASE_EMBEDDING_ORDERED_COLUMNS = (
     "tiling_preview_path",
     "feature_status",
     "feature_path",
+    "encoder_name",
+    "output_variant",
+    "feature_kind",
     "error",
     "traceback",
 )
@@ -157,6 +160,12 @@ def load_embedding_process_df(
         df["feature_status"] = ["tbp"] * len(df)
     if "feature_path" not in df.columns:
         df["feature_path"] = [None] * len(df)
+    if "encoder_name" not in df.columns:
+        df["encoder_name"] = [None] * len(df)
+    if "output_variant" not in df.columns:
+        df["output_variant"] = [None] * len(df)
+    if "feature_kind" not in df.columns:
+        df["feature_kind"] = [None] * len(df)
     if include_aggregation_status and "aggregation_status" not in df.columns:
         df["aggregation_status"] = ["tbp"] * len(df)
     ordered_columns = list(BASE_EMBEDDING_ORDERED_COLUMNS)

{slide2vec-4.0.2 → slide2vec-4.0.4}/slide2vec/utils/utils.py

@@ -90,7 +90,8 @@ def cpu_worker_limit() -> int:
     """Return the largest safe worker count for CPU-bound tiling work."""
     cpu_count = os.cpu_count() or 1
     slurm_limit = slurm_cpu_limit()
-    return min(cpu_count, slurm_limit) if slurm_limit is not None else cpu_count
+    available = min(cpu_count, slurm_limit) if slurm_limit is not None else cpu_count
+    return min(available, 64)
 
 
 def _parse_positive_cpu_value(value: str) -> int | None:

{slide2vec-4.0.2 → slide2vec-4.0.4}/slide2vec.egg-info/PKG-INFO

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

{slide2vec-4.0.2 → slide2vec-4.0.4}/tests/test_hs2p_package_cutover.py

@@ -133,12 +133,18 @@ def test_load_embedding_process_df_accepts_hs2p_process_list_columns(tmp_path: P
         "tiling_preview_path",
         "feature_status",
         "feature_path",
+        "encoder_name",
+        "output_variant",
+        "feature_kind",
         "aggregation_status",
         "error",
         "traceback",
     ]
     assert df.loc[0, "feature_status"] == "tbp"
     assert pd.isna(df.loc[0, "feature_path"])
+    assert pd.isna(df.loc[0, "encoder_name"])
+    assert pd.isna(df.loc[0, "output_variant"])
+    assert pd.isna(df.loc[0, "feature_kind"])
 
 
 def test_load_tiling_process_df_rejects_legacy_mask_columns(tmp_path: Path):

{slide2vec-4.0.2 → slide2vec-4.0.4}/tests/test_output_consistency.py

@@ -60,8 +60,7 @@ MODEL_PARAMS = dict(
 # -- speed --
 SPEED_PARAMS = dict(
     precision="fp16",       # override (default: fp32)
-    num_workers=4,           # override (default: 8)
-    num_workers_embedding=4, # override (default: 8)
+    num_dataloader_workers=0,  # keep the Prism subprocess path single-process to avoid worker SHM pressure
 )
 
 # ---------------------------------------------------------------------------

{slide2vec-4.0.2 → slide2vec-4.0.4}/tests/test_regression_core.py

@@ -310,9 +310,45 @@ def test_execution_options_defaults_preprocessing_workers_to_cpu_budget(monkeypa
 
     assert api.ExecutionOptions().num_preprocessing_workers == 24
 
+def test_execution_options_preserves_explicit_dataloader_workers(monkeypatch):
+    import slide2vec.api as api
+
+    monkeypatch.setattr(api, "cpu_worker_limit", lambda: 2)
+    monkeypatch.setattr(api, "slurm_cpu_limit", lambda: 2)
+
+    execution = api.ExecutionOptions(num_workers=3)
+
+    assert execution.num_workers == 3
+    assert execution.num_preprocessing_workers == 2
+
+def test_cpu_worker_limit_caps_large_cpu_budget_to_sixty_four(monkeypatch):
+    import slide2vec.utils.utils as utils
+
+    monkeypatch.setattr(utils.os, "cpu_count", lambda: 128)
+    monkeypatch.setattr(utils, "slurm_cpu_limit", lambda: 96)
+
+    assert utils.cpu_worker_limit() == 64
+
 def test_execution_options_default_batch_size_is_one():
     assert ExecutionOptions().batch_size == 1
 
+def test_execution_options_default_num_workers_is_auto():
+    assert ExecutionOptions().num_workers is None
+
+def test_execution_options_logs_resolved_auto_num_workers(monkeypatch, caplog):
+    import slide2vec.api as api
+
+    monkeypatch.setattr(api, "cpu_worker_limit", lambda: 18)
+    monkeypatch.setattr(api, "slurm_cpu_limit", lambda: 18)
+    monkeypatch.setattr(api.os, "cpu_count", lambda: 64)
+
+    with caplog.at_level("INFO"):
+        execution = api.ExecutionOptions()
+
+    assert execution.num_workers is None
+    assert "ExecutionOptions: num_workers=18 (requested=auto)" in caplog.text
+    assert "num_workers=auto" not in caplog.text
+
 def test_execution_options_from_config_maps_cli_fields(tmp_path: Path):
     cfg = SimpleNamespace(
         output_dir=str(tmp_path),
@@ -368,6 +404,24 @@ def test_execution_options_from_config_defaults_preprocessing_workers_to_cpu_bud
 
     assert execution.num_preprocessing_workers == 18
 
+def test_execution_options_from_config_preserves_auto_num_workers(tmp_path: Path):
+    cfg = SimpleNamespace(
+        output_dir=str(tmp_path),
+        model=SimpleNamespace(batch_size=4, save_tile_embeddings=False, save_latents=False),
+        speed=SimpleNamespace(
+            precision="fp16",
+            num_dataloader_workers=None,
+            num_preprocessing_workers=None,
+            num_gpus=3,
+            prefetch_factor_embedding=5,
+            persistent_workers_embedding=False,
+        ),
+    )
+
+    execution = ExecutionOptions.from_config(cfg)
+
+    assert execution.num_workers is None
+
 def test_execution_options_from_config_defaults_to_all_available_gpus_when_unset(monkeypatch, tmp_path: Path):
     import slide2vec.api as api
 

{slide2vec-4.0.2 → slide2vec-4.0.4}/tests/test_regression_inference.py

@@ -176,6 +176,8 @@ def test_collect_distributed_pipeline_artifacts_runs_stage_collects_and_updates(
         persist_tile_embeddings,
         persist_hierarchical_embeddings,
         include_slide_embeddings,
+        encoder_name,
+        output_variant,
         tile_artifacts,
         hierarchical_artifacts,
         slide_artifacts,
@@ -186,6 +188,8 @@ def test_collect_distributed_pipeline_artifacts_runs_stage_collects_and_updates(
             "persist_tile_embeddings": persist_tile_embeddings,
             "persist_hierarchical_embeddings": persist_hierarchical_embeddings,
             "include_slide_embeddings": include_slide_embeddings,
+            "encoder_name": encoder_name,
+            "output_variant": output_variant,
             "tile_artifacts": tile_artifacts,
             "hierarchical_artifacts": hierarchical_artifacts,
             "slide_artifacts": slide_artifacts,
@@ -220,6 +224,8 @@ def test_collect_distributed_pipeline_artifacts_runs_stage_collects_and_updates(
     assert captured["update"]["persist_tile_embeddings"] is True
     assert captured["update"]["persist_hierarchical_embeddings"] is False
     assert captured["update"]["include_slide_embeddings"] is True
+    assert captured["update"]["encoder_name"] == "prism"
+    assert captured["update"]["output_variant"] == "default"
     assert captured["update"]["tile_artifacts"] == ["tile-artifact"]
     assert captured["update"]["hierarchical_artifacts"] == []
     assert captured["update"]["slide_artifacts"] == ["slide-artifact"]
@@ -292,9 +298,18 @@ def test_has_complete_local_embedding_outputs_uses_hierarchical_artifacts_for_hi
     )
 
 
-@pytest.mark.parametrize("persist_hierarchical_embeddings", [False, True])
-def test_update_process_list_after_embedding_writes_feature_path(
+@pytest.mark.parametrize(
+    ("persist_hierarchical_embeddings", "include_slide_embeddings", "expected_feature_kind"),
+    [
+        (False, False, "tile"),
+        (True, False, "hierarchical"),
+        (False, True, "slide"),
+    ],
+)
+def test_update_process_list_after_embedding_writes_feature_provenance(
     persist_hierarchical_embeddings: bool,
+    include_slide_embeddings: bool,
+    expected_feature_kind: str,
     tmp_path: Path,
 ):
     import slide2vec.inference as inference
@@ -306,7 +321,19 @@ def test_update_process_list_after_embedding_writes_feature_path(
         "slide-a,/tmp/slide-a.svs,,asap,asap,,success,1,/tmp/slide-a.coordinates.npz,/tmp/slide-a.coordinates.meta.json,tbp,,\n",
         encoding="utf-8",
     )
-    if persist_hierarchical_embeddings:
+    slide_artifacts = []
+    if include_slide_embeddings:
+        artifact = write_slide_embeddings(
+            "slide-a",
+            np.zeros((4,), dtype=np.float32),
+            output_dir=tmp_path,
+            output_format="pt",
+            metadata={"image_path": "/tmp/slide-a.svs"},
+        )
+        tile_artifacts = []
+        hierarchical_artifacts = []
+        slide_artifacts = [artifact]
+    elif persist_hierarchical_embeddings:
         artifact = write_hierarchical_embeddings(
             "slide-a",
             np.zeros((1, 2, 4), dtype=np.float32),
@@ -332,15 +359,20 @@ def test_update_process_list_after_embedding_writes_feature_path(
         successful_slides=[slide],
         persist_tile_embeddings=not persist_hierarchical_embeddings,
         persist_hierarchical_embeddings=persist_hierarchical_embeddings,
-        include_slide_embeddings=False,
+        include_slide_embeddings=include_slide_embeddings,
+        encoder_name="virchow2" if not include_slide_embeddings else "prism",
+        output_variant="cls" if not include_slide_embeddings else "default",
         tile_artifacts=tile_artifacts,
         hierarchical_artifacts=hierarchical_artifacts,
-        slide_artifacts=[],
+        slide_artifacts=slide_artifacts,
     )
 
     recorded = pd.read_csv(process_list_path).set_index("sample_id")
     assert recorded.loc["slide-a", "feature_status"] == "success"
     assert recorded.loc["slide-a", "feature_path"] == str(artifact.path)
+    assert recorded.loc["slide-a", "encoder_name"] == ("virchow2" if not include_slide_embeddings else "prism")
+    assert recorded.loc["slide-a", "output_variant"] == ("cls" if not include_slide_embeddings else "default")
+    assert recorded.loc["slide-a", "feature_kind"] == expected_feature_kind
 
 
 def test_model_embed_slide_updates_process_list_feature_status_and_path_in_distributed_path(
@@ -2033,6 +2065,128 @@ def test_serialize_execution_preserves_loader_optimization_fields():
     assert restored.precision == "bf16"
 
 
+def test_deserialize_execution_defaults_num_workers_to_auto():
+    import slide2vec.inference as inference
+
+    restored = inference.deserialize_execution({"batch_size": 4, "num_gpus": 1})
+
+    assert restored.num_workers is None
+
+
+def test_deserialize_execution_preserves_auto_num_workers():
+    import slide2vec.inference as inference
+
+    restored = inference.deserialize_execution({"batch_size": 4, "num_workers": None, "num_gpus": 1})
+
+    assert restored.num_workers is None
+
+
+def test_embedding_dataloader_kwargs_resolve_auto_mode_to_cpu_budget(monkeypatch):
+    import slide2vec.api as api
+    import slide2vec.inference as inference
+    torch = pytest.importorskip("torch")
+
+    monkeypatch.setattr(api, "cpu_worker_limit", lambda: 24)
+
+    loaded = inference.LoadedModel(
+        name="test",
+        level="tile",
+        model=object(),
+        transforms=object(),
+        feature_dim=3,
+        device=torch.device("cpu"),
+    )
+
+    kwargs = inference._embedding_dataloader_kwargs(
+        loaded,
+        ExecutionOptions(num_workers=None, num_gpus=1),
+    )
+
+    assert kwargs["num_workers"] == 24
+    assert kwargs["persistent_workers"] is True
+    assert kwargs["prefetch_factor"] == 4
+
+
+def test_compute_tile_embeddings_for_slide_uses_cpu_budget_for_auto_workers_on_non_cucim_on_the_fly(monkeypatch):
+    import slide2vec.api as api
+    import slide2vec.inference as inference
+    torch = pytest.importorskip("torch")
+
+    captured = {}
+
+    class DummyLoader:
+        def __init__(self, dataset, **kwargs):
+            captured["kwargs"] = kwargs
+
+        def __iter__(self):
+            yield (
+                torch.tensor([0, 1], dtype=torch.long),
+                torch.zeros((2, 3, 4, 4), dtype=torch.uint8),
+                {"worker_batch_ms": 0.0, "reader_open_ms": 0.0, "reader_read_ms": 0.0},
+            )
+
+        def __len__(self):
+            return 1
+
+    class DummyEncoder:
+        pretrained_cfg = {}
+
+    class DummyModel:
+        encoder = DummyEncoder()
+
+        def encode_tiles(self, image):
+            return torch.ones((image.shape[0], 3), dtype=torch.float32, device=image.device)
+
+    class DummyCollator:
+        ordered_indices = None
+
+        def __init__(self, **kwargs):
+            captured["wsd_collator_kwargs"] = kwargs
+
+        def __call__(self, batch_indices):
+            tile_indices = torch.as_tensor(batch_indices, dtype=torch.long)
+            batch = torch.zeros((len(batch_indices), 3, 4, 4), dtype=torch.uint8)
+            return tile_indices, batch, {"worker_batch_ms": 0.0, "reader_open_ms": 0.0, "reader_read_ms": 0.0}
+
+    monkeypatch.setattr(inference, "OnTheFlyBatchTileCollator", DummyCollator)
+    monkeypatch.setattr(torch.utils.data, "DataLoader", DummyLoader)
+    monkeypatch.setattr(inference, "_build_batch_preprocessor", lambda *args, **kwargs: lambda batch: batch.float())
+    monkeypatch.setattr(api, "cpu_worker_limit", lambda: 24)
+
+    loaded = inference.LoadedModel(
+        name="prov-gigapath",
+        level="tile",
+        model=DummyModel(),
+        transforms=object(),
+        feature_dim=3,
+        device=torch.device("cpu"),
+    )
+
+    result = inference._compute_tile_embeddings_for_slide(
+        loaded,
+        SimpleNamespace(level="tile"),
+        make_slide("slide-a"),
+        SimpleNamespace(
+            x=np.array([0, 10]),
+            y=np.array([5, 15]),
+            backend="asap",
+            target_spacing_um=0.5,
+            target_tile_size_px=4,
+            read_spacing_um=0.5,
+            read_tile_size_px=4,
+            tile_size_lv0=224,
+        ),
+        preprocessing=replace(DEFAULT_PREPROCESSING, on_the_fly=True, backend="auto", num_cucim_workers=4),
+        execution=ExecutionOptions(batch_size=2, num_workers=None, num_gpus=1),
+    )
+
+    assert result.shape == (2, 3)
+    assert captured["kwargs"]["num_workers"] == 24
+    assert captured["kwargs"]["persistent_workers"] is True
+    assert captured["kwargs"]["prefetch_factor"] == 4
+    assert captured["wsd_collator_kwargs"]["backend"] == "asap"
+
+
 def test_compute_tile_embeddings_for_slide_uses_batched_loader_knobs(monkeypatch):
     import slide2vec.inference as inference
     torch = pytest.importorskip("torch")
@@ -2541,6 +2695,9 @@ def test_compute_tile_embeddings_for_slide_uses_resolved_wsd_backend_when_auto(m
     )
 
     assert result.shape == (2, 3)
+    assert captured["kwargs"]["num_workers"] == 8
+    assert captured["kwargs"]["persistent_workers"] is True
+    assert captured["kwargs"]["prefetch_factor"] == 4
     assert captured["wsd_collator_kwargs"]["backend"] == "asap"