slide2vec 3.1.0__tar.gz → 3.2.1__tar.gz

{slide2vec-3.1.0/slide2vec.egg-info → slide2vec-3.2.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: slide2vec
-Version: 3.1.0
+Version: 3.2.1
 Summary: Embedding of whole slide images with Foundation Models
 Home-page: https://github.com/clemsgrs/slide2vec
 Author: Clément Grisi
@@ -20,13 +20,14 @@ Classifier: Programming Language :: Python :: 3.13
 Requires-Python: >=3.10
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: hs2p<3,>=2.4.1
+Requires-Dist: hs2p<3,>=2.5.1
 Requires-Dist: omegaconf
 Requires-Dist: h5py
 Requires-Dist: matplotlib
 Requires-Dist: numpy<2
 Requires-Dist: pandas
 Requires-Dist: pillow
+Requires-Dist: PyTurboJPEG
 Requires-Dist: rich
 Requires-Dist: tqdm
 Requires-Dist: torch
@@ -37,8 +38,7 @@ Requires-Dist: wholeslidedata<0.0.16
 Requires-Dist: einops
 Requires-Dist: timm
 Provides-Extra: cucim
-Requires-Dist: hs2p[cucim]<3,>=2.4.1; extra == "cucim"
-Requires-Dist: PyTurboJPEG; extra == "cucim"
+Requires-Dist: hs2p[cucim]<3,>=2.5.1; extra == "cucim"
 Provides-Extra: models
 Requires-Dist: huggingface-hub; extra == "models"
 Requires-Dist: sacremoses; extra == "models"
@@ -80,38 +80,37 @@ pip install "slide2vec[models]"
 ## Python API
 
 ```python
-from slide2vec import Model, PreprocessingConfig
+from slide2vec import Model
+from slide2vec.utils.config import hf_login
 
-model = Model.from_pretrained("virchow2", level="tile")
-preprocessing = PreprocessingConfig(
-    target_spacing_um=0.5,
-    target_tile_size_px=224,
-    tissue_threshold=0.1,
-)
-embedded = model.embed_slide(
-    "/path/to/slide.svs",
-    preprocessing=preprocessing,
-)
+hf_login()
+
+model = Model.from_preset("virchow2")
+embedded = model.embed_slide("/path/to/slide.svs")
 
 tile_embeddings = embedded.tile_embeddings
 coordinates = embedded.coordinates
 ```
 
-By default, `ExecutionOptions()` uses all available GPUs. Set `ExecutionOptions(num_gpus=4)` when you want to cap the sharding explicitly.
-
 Use `Pipeline(...)` for manifest-driven batch processing when you want artifacts written to disk instead of only in-memory outputs:
 
 ```python
-from slide2vec import ExecutionOptions, Pipeline
+from slide2vec import ExecutionOptions, Pipeline, PreprocessingConfig
 
 pipeline = Pipeline(
     model=model,
-    preprocessing=preprocessing,
+    preprocessing=PreprocessingConfig(
+        target_spacing_um=0.5,
+        target_tile_size_px=224,
+        tissue_threshold=0.1,
+    ),
     execution=ExecutionOptions(output_dir="outputs/demo"),
 )
 result = pipeline.run(manifest_path="/path/to/slides.csv")
 ```
 
+By default, `ExecutionOptions()` uses all available GPUs. Set `ExecutionOptions(num_gpus=4)` when you want to cap the sharding explicitly.
+
 ### Input Manifest
 
 Manifest-driven runs use the schema below. `mask_path` and `spacing_at_level_0` are optional.
@@ -140,7 +139,7 @@ The package writes explicit artifact directories:
 
 ### Supported Models
 
-`slide2vec` currently ships preset configs for 10 tile-level models and 3 slide-level models.  
+`slide2vec` currently ships preset configs for 20 tile-level models and 3 slide-level models.  
 For the full catalog and preset names, see [`docs/models.md`](docs/models.md).
 
 ## CLI
@@ -174,4 +173,5 @@ docker run --rm -it \
 
 - [`docs/cli.md`](docs/cli.md) for the config-driven CLI guide
 - [`docs/python-api.md`](docs/python-api.md) for the detailed API reference
+- [`tutorials/api_walkthrough.ipynb`](tutorials/api_walkthrough.ipynb) for a notebook walkthrough of the API
 - [`docs/models.md`](docs/models.md) for the full supported-model catalog

{slide2vec-3.1.0 → slide2vec-3.2.1}/README.md

@@ -21,38 +21,37 @@ pip install "slide2vec[models]"
 ## Python API
 
 ```python
-from slide2vec import Model, PreprocessingConfig
+from slide2vec import Model
+from slide2vec.utils.config import hf_login
 
-model = Model.from_pretrained("virchow2", level="tile")
-preprocessing = PreprocessingConfig(
-    target_spacing_um=0.5,
-    target_tile_size_px=224,
-    tissue_threshold=0.1,
-)
-embedded = model.embed_slide(
-    "/path/to/slide.svs",
-    preprocessing=preprocessing,
-)
+hf_login()
+
+model = Model.from_preset("virchow2")
+embedded = model.embed_slide("/path/to/slide.svs")
 
 tile_embeddings = embedded.tile_embeddings
 coordinates = embedded.coordinates
 ```
 
-By default, `ExecutionOptions()` uses all available GPUs. Set `ExecutionOptions(num_gpus=4)` when you want to cap the sharding explicitly.
-
 Use `Pipeline(...)` for manifest-driven batch processing when you want artifacts written to disk instead of only in-memory outputs:
 
 ```python
-from slide2vec import ExecutionOptions, Pipeline
+from slide2vec import ExecutionOptions, Pipeline, PreprocessingConfig
 
 pipeline = Pipeline(
     model=model,
-    preprocessing=preprocessing,
+    preprocessing=PreprocessingConfig(
+        target_spacing_um=0.5,
+        target_tile_size_px=224,
+        tissue_threshold=0.1,
+    ),
     execution=ExecutionOptions(output_dir="outputs/demo"),
 )
 result = pipeline.run(manifest_path="/path/to/slides.csv")
 ```
 
+By default, `ExecutionOptions()` uses all available GPUs. Set `ExecutionOptions(num_gpus=4)` when you want to cap the sharding explicitly.
+
 ### Input Manifest
 
 Manifest-driven runs use the schema below. `mask_path` and `spacing_at_level_0` are optional.
@@ -81,7 +80,7 @@ The package writes explicit artifact directories:
 
 ### Supported Models
 
-`slide2vec` currently ships preset configs for 10 tile-level models and 3 slide-level models.  
+`slide2vec` currently ships preset configs for 20 tile-level models and 3 slide-level models.  
 For the full catalog and preset names, see [`docs/models.md`](docs/models.md).
 
 ## CLI
@@ -115,4 +114,5 @@ docker run --rm -it \
 
 - [`docs/cli.md`](docs/cli.md) for the config-driven CLI guide
 - [`docs/python-api.md`](docs/python-api.md) for the detailed API reference
+- [`tutorials/api_walkthrough.ipynb`](tutorials/api_walkthrough.ipynb) for a notebook walkthrough of the API
 - [`docs/models.md`](docs/models.md) for the full supported-model catalog

{slide2vec-3.1.0 → slide2vec-3.2.1}/pyproject.toml

@@ -23,7 +23,7 @@ warn_unused_configs = true
 no_implicit_reexport = true
 
 [tool.bumpver]
-current_version = "3.1.0"
+current_version = "3.2.1"
 version_pattern = "MAJOR.MINOR.PATCH"
 commit = false       # We do version bumping in CI, not as a commit
 tag = false          # Git tag already exists — we don't auto-tag

{slide2vec-3.1.0 → slide2vec-3.2.1}/setup.cfg

@@ -1,6 +1,6 @@
 [metadata]
 name = slide2vec
-version = 3.1.0
+version = 3.2.1
 description = Embedding of whole slide images with Foundation Models
 author = Clément Grisi
 platforms = unix, linux, osx, cygwin, win32
@@ -16,13 +16,14 @@ classifiers =
 packages = 
 	slide2vec
 install_requires = 
-	hs2p>=2.4.1,<3
+	hs2p>=2.5.1,<3
 	omegaconf
 	h5py
 	matplotlib
 	numpy<2
 	pandas
 	pillow
+	PyTurboJPEG
 	rich
 	tqdm
 	torch
@@ -38,8 +39,7 @@ include_package_data = True
 
 [options.extras_require]
 cucim = 
-	hs2p[cucim]>=2.4.1,<3
-	PyTurboJPEG
+	hs2p[cucim]>=2.5.1,<3
 models = 
 	huggingface-hub
 	sacremoses

{slide2vec-3.1.0 → slide2vec-3.2.1}/slide2vec/__init__.py

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

{slide2vec-3.1.0 → slide2vec-3.2.1}/slide2vec/api.py

@@ -1,4 +1,7 @@
+import logging
+import os
 from dataclasses import dataclass, field, replace
+from contextlib import contextmanager
 from pathlib import Path
 from typing import TYPE_CHECKING, Any, Mapping, Protocol, Sequence, overload
 
@@ -23,6 +26,8 @@ DEFAULT_LEVEL_BY_NAME = {
     "titan": "slide",
 }
 
+logger = logging.getLogger("slide2vec")
+
 PathLike = str | Path
 
 
@@ -137,8 +142,8 @@ class ExecutionOptions:
             output_dir=Path(cfg.output_dir),
             output_format="pt",
             batch_size=int(getattr(cfg.model, "batch_size", 1)),
-            num_workers=int(getattr(cfg.speed, "num_dataloader_workers", getattr(cfg.speed, "num_workers_embedding", cfg.speed.num_workers))),
-            num_preprocessing_workers=int(getattr(cfg.speed, "num_preprocessing_workers", cfg.speed.num_workers)),
+            num_workers=int(getattr(cfg.speed, "num_dataloader_workers", getattr(cfg.speed, "num_workers_embedding", 8))),
+            num_preprocessing_workers=int(getattr(cfg.speed, "num_preprocessing_workers", 8)),
             num_gpus=1 if run_on_cpu else _coerce_num_gpus(configured_num_gpus),
             precision="fp32" if run_on_cpu else requested_precision,
             prefetch_factor=int(getattr(cfg.speed, "prefetch_factor_embedding", 4)),
@@ -156,6 +161,15 @@ 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")
+        slurm_cpu_limit = None
+        for env_name in ("SLURM_CPUS_PER_TASK", "SLURM_CPUS_ON_NODE", "SLURM_JOB_CPUS_PER_NODE"):
+            value = os.environ.get(env_name)
+            if value and value.strip().isdigit() and int(value.strip()) > 0:
+                slurm_cpu_limit = int(value.strip())
+                break
+        if slurm_cpu_limit is not None:
+            object.__setattr__(self, "num_workers", min(self.num_workers, slurm_cpu_limit))
+            object.__setattr__(self, "num_preprocessing_workers", min(self.num_preprocessing_workers, slurm_cpu_limit))
 
     def with_output_dir(self, output_dir: PathLike | None) -> "ExecutionOptions":
         if output_dir is None:
@@ -179,6 +193,9 @@ class EmbeddedSlide:
     tile_size_lv0: int
     image_path: Path
     mask_path: Path | None = None
+    num_tiles: int | None = None
+    mask_preview_path: Path | None = None
+    tiling_preview_path: Path | None = None
     latents: Any | None = None
 
 
@@ -214,7 +231,7 @@ class Model:
         self._backend: LoadedModel | None = None
 
     @classmethod
-    def from_pretrained(
+    def from_preset(
         cls,
         name: str,
         *,
@@ -230,7 +247,7 @@ class Model:
         device: str = "auto",
     ) -> "Model":
         canonical_name = _canonical_model_name(name)
-        resolved_level = level or DEFAULT_LEVEL_BY_NAME.get(canonical_name, "tile")
+        resolved_level = _resolve_model_level(canonical_name, requested_level=level)
         return cls(
             name=canonical_name,
             level=resolved_level,
@@ -267,7 +284,8 @@ class Model:
         _require_output_dir_for_persistence(resolved, method_name="Model.embed_tiles(...)")
         if preprocessing is not None:
             validate_model_runtime_compatibility(self, preprocessing, resolved)
-        return embed_tiles(self, slides, tiling_results, execution=resolved, preprocessing=preprocessing)
+        with _auto_progress_reporting(output_dir=resolved.output_dir):
+            return embed_tiles(self, slides, tiling_results, execution=resolved, preprocessing=preprocessing)
 
     def aggregate_tiles(
         self,
@@ -280,14 +298,15 @@ class Model:
 
         resolved = _coerce_execution_options(execution, model=self)
         _require_output_dir_for_persistence(resolved, method_name="Model.aggregate_tiles(...)")
-        return aggregate_tiles(self, tile_artifacts, execution=resolved, preprocessing=preprocessing)
+        with _auto_progress_reporting(output_dir=resolved.output_dir):
+            return aggregate_tiles(self, tile_artifacts, execution=resolved, preprocessing=preprocessing)
 
     @overload
     def embed_slide(
         self,
         slide: PathLike,
         *,
-        preprocessing: PreprocessingConfig,
+        preprocessing: PreprocessingConfig | None = None,
         execution: ExecutionOptions | None = None,
         sample_id: str | None = None,
         mask_path: PathLike | None = None,
@@ -300,7 +319,7 @@ class Model:
         self,
         slide: Mapping[str, object] | SlideLike | SlideSpec,
         *,
-        preprocessing: PreprocessingConfig,
+        preprocessing: PreprocessingConfig | None = None,
         execution: ExecutionOptions | None = None,
         sample_id: None = None,
         mask_path: None = None,
@@ -312,7 +331,7 @@ class Model:
         self,
         slide: SlideInput,
         *,
-        preprocessing: PreprocessingConfig,
+        preprocessing: PreprocessingConfig | None = None,
         execution: ExecutionOptions | None = None,
         sample_id: str | None = None,
         mask_path: PathLike | None = None,
@@ -339,19 +358,21 @@ class Model:
         self,
         slides: SlideSequence,
         *,
-        preprocessing: PreprocessingConfig,
+        preprocessing: PreprocessingConfig | None = None,
         execution: ExecutionOptions | None = None,
     ) -> list[EmbeddedSlide]:
         from slide2vec.inference import embed_slides
 
         resolved = _coerce_execution_options(execution, model=self)
-        validate_model_runtime_compatibility(self, preprocessing, resolved)
-        return embed_slides(
-            self,
-            slides,
-            preprocessing=preprocessing,
-            execution=resolved,
-        )
+        resolved_preprocessing = _resolve_direct_api_preprocessing(self, preprocessing)
+        with _auto_progress_reporting(output_dir=resolved.output_dir):
+            validate_model_runtime_compatibility(self, resolved_preprocessing, resolved)
+            return embed_slides(
+                self,
+                slides,
+                preprocessing=resolved_preprocessing,
+                execution=resolved,
+            )
 
     def _load_backend(self) -> "LoadedModel":
         if self._backend is None:
@@ -390,22 +411,29 @@ class Pipeline:
     ) -> RunResult:
         from slide2vec.inference import run_pipeline
 
-        if not tiling_only:
-            validate_model_runtime_compatibility(self.model, self.preprocessing, self.execution)
-        return run_pipeline(
-            self.model,
-            slides=slides,
-            manifest_path=manifest_path,
-            preprocessing=self.preprocessing,
-            tiling_only=tiling_only,
-            execution=self.execution,
-        )
+        with _auto_progress_reporting(output_dir=self.execution.output_dir):
+            if not tiling_only:
+                validate_model_runtime_compatibility(self.model, self.preprocessing, self.execution)
+            return run_pipeline(
+                self.model,
+                slides=slides,
+                manifest_path=manifest_path,
+                preprocessing=self.preprocessing,
+                tiling_only=tiling_only,
+                execution=self.execution,
+            )
 
 
 def _canonical_model_name(name: str) -> str:
     return canonicalize_model_name(name)
 
 
+def _resolve_model_level(name: str, *, requested_level: str | None) -> str:
+    if requested_level is not None:
+        return requested_level
+    return DEFAULT_LEVEL_BY_NAME.get(name, "tile")
+
+
 def _coerce_execution_options(
     options: ExecutionOptions | None,
     *,
@@ -444,3 +472,80 @@ def _recommended_execution_precision(model: Model | None) -> str:
     if settings is not None and settings.precision is not None:
         return settings.precision
     return "fp32"
+
+
+def _resolve_direct_api_preprocessing(
+    model: Model,
+    preprocessing: PreprocessingConfig | None,
+) -> PreprocessingConfig:
+    if preprocessing is not None:
+        return preprocessing
+
+    settings = get_recommended_model_settings(getattr(model, "name", None))
+    target_tile_size_px = _default_target_tile_size_px(model, settings)
+    target_spacing_um = _default_target_spacing_um(model, settings)
+    return PreprocessingConfig(
+        backend="auto",
+        target_spacing_um=target_spacing_um,
+        target_tile_size_px=target_tile_size_px,
+    )
+
+
+def _default_target_tile_size_px(model: Model, settings) -> int:
+    explicit_input_size = getattr(model, "_model_kwargs", {}).get("input_size")
+    if explicit_input_size is not None:
+        return int(explicit_input_size)
+    if settings is not None:
+        return int(settings.input_size[0])
+    return int(PreprocessingConfig().target_tile_size_px)
+
+
+def _default_target_spacing_um(model: Model, settings) -> float:
+    if settings is None or not getattr(settings, "spacings_um", ()):
+        default_spacing = float(PreprocessingConfig().target_spacing_um)
+        logger.warning(
+            "No recommended preprocessing spacing is known for model '%s'; defaulting direct API calls to "
+            "target_spacing_um=%g. Pass PreprocessingConfig(...) to override.",
+            getattr(model, "name", None),
+            default_spacing,
+        )
+        return default_spacing
+
+    supported_spacings = tuple(float(value) for value in settings.spacings_um)
+    if len(supported_spacings) == 1:
+        return supported_spacings[0]
+
+    if any(abs(value - 0.5) <= 1e-8 for value in supported_spacings):
+        chosen = 0.5
+    else:
+        chosen = min(supported_spacings)
+    supported_text = ", ".join(f"{spacing:g}" for spacing in supported_spacings)
+    logger.warning(
+        "Model '%s' supports multiple spacings [%s]; defaulting direct API calls to target_spacing_um=%g. "
+        "Pass PreprocessingConfig(target_spacing_um=...) to choose another supported spacing.",
+        getattr(model, "name", None),
+        supported_text,
+        chosen,
+    )
+    return chosen
+
+
+@contextmanager
+def _auto_progress_reporting(*, output_dir: PathLike | None):
+    from slide2vec.progress import (
+        NullProgressReporter,
+        activate_progress_reporter,
+        create_api_progress_reporter,
+        get_progress_reporter,
+    )
+
+    active = get_progress_reporter()
+    if not isinstance(active, NullProgressReporter):
+        yield
+        return
+    reporter = create_api_progress_reporter(output_dir=output_dir)
+    if isinstance(reporter, NullProgressReporter):
+        yield
+        return
+    with activate_progress_reporter(reporter):
+        yield

{slide2vec-3.1.0 → slide2vec-3.2.1}/slide2vec/cli.py

@@ -23,7 +23,7 @@ def get_args_parser(add_help: bool = True):
 def build_model_and_pipeline(args):
     cfg, _cfg_path = _setup_cli_config(args)
     _hf_login()
-    model = Model.from_pretrained(
+    model = Model.from_preset(
         cfg.model.name,
         level=cfg.model.level,
         mode=cfg.model.mode,

{slide2vec-3.1.0 → slide2vec-3.2.1}/slide2vec/configs/preprocessing/default.yaml

@@ -10,7 +10,7 @@ seed: 0 # seed for reproducibility
 
 tiling:
   on_the_fly: true # read tiles directly from WSI during embedding (requires cucim backend)
-  gpu_decode: false # attempt GPU-accelerated JPEG decoding via nvImageCodec (experimental)
+  gpu_decode: false # GPU-accelerated batch decoding via device="cuda" in cucim read_region; set true to opt in when the runtime is configured for it
   adaptive_batching: false # when true, vary batch size to align with super tile boundaries (avoids redundant reads but batch size fluctuates)
   use_supertiles: true # group tiles into 8x8/4x4/2x2 super tile reads to reduce WSI read calls (on-the-fly path only)
   jpeg_backend: "turbojpeg" # JPEG encoder for tar extraction: "turbojpeg" (faster) or "pil" (compatible with older ground truth fixtures)

{slide2vec-3.1.0 → slide2vec-3.2.1}/slide2vec/data/cucim_tile_reader.py

@@ -115,17 +115,16 @@ class CuCIMTileReader:
         tiling_result: TilingResult,
         *,
         num_cucim_workers: int = 4,
-        gpu_decode: bool = False,
+        gpu_decode: bool = True,
         use_supertiles: bool = True,
     ):
-        self._image_path = image_path
+        from hs2p.wsi.cucim_reader import CuImageReader
         self._x = tiling_result.x
         self._y = tiling_result.y
         self._read_level = tiling_result.read_level
         self._tile_size_px = int(tiling_result.read_tile_size_px)
         self._num_cucim_workers = num_cucim_workers
-        self._gpu_decode = gpu_decode
-        self._cu_image = None
+        self._reader = CuImageReader(image_path, gpu_decode=gpu_decode)
 
         self._use_supertiles = use_supertiles
         if use_supertiles:
@@ -141,29 +140,13 @@ class CuCIMTileReader:
             self._tile_to_st = None
             self.ordered_indices = None
 
-    def _ensure_open(self):
-        if self._cu_image is None:
-            try:
-                from cucim import CuImage
-            except ImportError as exc:
-                raise ImportError(
-                    "cucim is required for on-the-fly tile reading. "
-                    "Install it with: pip install cucim-cuXX (where XX matches your CUDA version)"
-                ) from exc
-            self._cu_image = CuImage(str(self._image_path))
-
     def _read_region(self, locations, size):
-        kwargs = {
-            "level": int(self._read_level),
-            "num_workers": max(1, self._num_cucim_workers),
-        }
-        if self._gpu_decode:
-            kwargs["device"] = "cuda"
-        try:
-            return self._cu_image.read_region(locations, size, **kwargs)
-        except TypeError:
-            kwargs.pop("device", None)
-            return self._cu_image.read_region(locations, size, **kwargs)
+        return self._reader.read_region(
+            locations,
+            size,
+            level=int(self._read_level),
+            num_workers=self._num_cucim_workers,
+        )
 
     def read_batch(self, tile_indices: np.ndarray) -> torch.Tensor:
         tensor, _timing = self.read_batch_with_timing(tile_indices)
@@ -174,9 +157,9 @@ class CuCIMTileReader:
             return torch.empty(
                 (0, 3, self._tile_size_px, self._tile_size_px), dtype=torch.uint8
             ), {"reader_open_ms": 0.0, "reader_read_ms": 0.0}
-        was_closed = self._cu_image is None
+        was_closed = self._reader._cu_image is None
         open_start = time.perf_counter()
-        self._ensure_open()
+        self._reader._ensure_open()
         reader_open_ms = (time.perf_counter() - open_start) * 1000.0 if was_closed else 0.0
         read_start = time.perf_counter()
 
@@ -242,7 +225,7 @@ class OnTheFlyBatchTileCollator:
         image_path: Path,
         tiling_result: TilingResult,
         num_cucim_workers: int = 4,
-        gpu_decode: bool = False,
+        gpu_decode: bool = True,
         use_supertiles: bool = True,
     ):
         self.tile_size = int(tiling_result.read_tile_size_px)

{slide2vec-3.1.0 → slide2vec-3.2.1}/slide2vec/data/wsd_tile_reader.py

@@ -58,7 +58,9 @@ class WSDTileReader:
 
     def _ensure_open(self) -> None:
         if self._wsi is None:
-            import wholeslidedata as wsd
+            from slide2vec.utils.log_utils import suppress_c_stderr
+            with suppress_c_stderr():
+                import wholeslidedata as wsd
             from hs2p.wsi.backend import coerce_wsd_path
 
             self._wsi = wsd.WholeSlideImage(

{slide2vec-3.1.0 → slide2vec-3.2.1}/slide2vec/distributed/direct_embed_worker.py

@@ -41,7 +41,7 @@ def main(argv=None) -> int:
         local_rank = distributed.get_local_rank()
 
         model_spec = dict(request["model"])
-        model = Model.from_pretrained(
+        model = Model.from_preset(
             model_spec["name"],
             level=model_spec["level"],
             device=f"cuda:{local_rank}",

{slide2vec-3.1.0 → slide2vec-3.2.1}/slide2vec/distributed/pipeline_worker.py

@@ -37,7 +37,7 @@ def main(argv=None) -> int:
         world_size = distributed.get_global_size()
 
         model_spec = dict(request["model"])
-        model = Model.from_pretrained(
+        model = Model.from_preset(
             model_spec["name"],
             level=model_spec["level"],
             device=f"cuda:{local_rank}",