horde-engine 3.3.1__tar.gz → 3.3.2__tar.gz

{horde_engine-3.3.1 → horde_engine-3.3.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: horde-engine
-Version: 3.3.1
+Version: 3.3.2
 Summary: A wrapper around ComfyUI to allow use by AI Horde.
 Project-URL: Homepage, https://github.com/Haidra-Org/hordelib
 Project-URL: Bug Tracker, https://github.com/Haidra-Org/hordelib/issues

{horde_engine-3.3.1 → horde_engine-3.3.2}/hordelib/_version.py

@@ -18,7 +18,7 @@ version_tuple: tuple[int | str, ...]
 commit_id: str | None
 __commit_id__: str | None
 
-__version__ = version = '3.3.1'
-__version_tuple__ = version_tuple = (3, 3, 1)
+__version__ = version = '3.3.2'
+__version_tuple__ = version_tuple = (3, 3, 2)
 
 __commit_id__ = commit_id = None

{horde_engine-3.3.1 → horde_engine-3.3.2}/hordelib/feature_impact.py

@@ -371,6 +371,7 @@ def estimate_job_burden(
     features: list[FEATURE_KIND] | None = None,
     model_record: ImageGenerationModelRecord | None = None,
     aux_model_weights_mb: dict[FEATURE_KIND, float] | None = None,
+    post_processing_upscale_factor: float = 1.0,
 ) -> BurdenEstimate:
     """Estimate the total resource burden of one job configuration.
 
@@ -385,6 +386,12 @@ def estimate_job_burden(
     ``vram_delta_mb`` term while keeping the activation (per-megapixel) term. Unsupplied features keep the
     conservative seed.
 
+    ``post_processing_upscale_factor`` is the linear scale of the requested upscaler (see
+    :func:`hordelib.pipeline.constants.max_upscale_factor`). The upscale activation peak scales with the
+    *output* megapixels, so the ``post_processing_upscale`` feature's per-megapixel term is applied against
+    ``factor**2`` the generation megapixels: a 4x upscale of a 1 MP image works a 16 MP tensor, the dominant
+    cost of the post-processing phase. The default of 1.0 leaves the activation at generation resolution.
+
     Never raises on unknown baselines: pre-flight callers need an answer for every
     job, so unknown baselines use a heavy fallback seed and are flagged via
     ``baseline_known=False``.
@@ -411,7 +418,12 @@ def estimate_job_burden(
             weight_mb = round(aux_model_weights_mb[kind])
         else:
             weight_mb = impact.vram_delta_mb
-        vram_delta = weight_mb + round(impact.vram_delta_per_megapixel_mb * megapixels)
+        # The upscaler enlarges the image, so its activation peak scales with the *output* megapixels
+        # (factor**2 the generation megapixels); every other feature works at generation resolution.
+        activation_megapixels = megapixels
+        if kind == FEATURE_KIND.post_processing_upscale and post_processing_upscale_factor > 1.0:
+            activation_megapixels = megapixels * (post_processing_upscale_factor**2)
+        vram_delta = weight_mb + round(impact.vram_delta_per_megapixel_mb * activation_megapixels)
         if impact.phase == FEATURE_PHASE.post_processing:
             vram_post_processing_mb += vram_delta
         else:

{horde_engine-3.3.1 → horde_engine-3.3.2}/hordelib/pipeline/constants.py

@@ -93,6 +93,47 @@ def controlnet_annotator_download_bytes(control_types: Iterable[str | None]) ->
     return sum(CONTROLNET_ANNOTATOR_DOWNLOAD_BYTES.get(control_type, 0) for control_type in distinct)
 
 
+# Horde upscaler name (KNOWN_UPSCALERS value) to its linear scale factor. The upscaler enlarges the
+# generated image by this factor on each axis, so the post-processing activation peak scales with the
+# *output* megapixels (factor**2 the generation megapixels), not the generation resolution. A 4x upscale
+# of a 1 MP image produces a 16 MP tensor, which is the dominant VRAM cost of the post-processing phase
+# (the model weights themselves are tens of MB). Used by the feature-impact estimate to size that peak.
+UPSCALER_SCALE_FACTORS = {
+    "BACKEND_DEFAULT": 4,  # the worker's default upscaler is a 4x ESRGAN; assume the larger factor
+    "RealESRGAN_x4plus": 4,
+    "RealESRGAN_x2plus": 2,
+    "RealESRGAN_x4plus_anime_6B": 4,
+    "NMKD_Siax": 4,
+    "4x_AnimeSharp": 4,
+}
+"""Horde upscaler name to its linear (per-axis) scale factor (ROM)."""
+
+_DEFAULT_UPSCALE_FACTOR = 4
+"""Assumed factor for an upscaler absent from the ROM: err high so the activation peak is not under-sized."""
+
+
+def upscaler_scale_factor(name: str | None) -> int:
+    """Return the linear scale factor for upscaler *name*, or the conservative default when unknown.
+
+    ``None`` returns 1 (no upscaler, no enlargement). An unrecognised upscaler returns
+    :data:`_DEFAULT_UPSCALE_FACTOR` rather than 1, so a new upscaler the ROM has not learned yet
+    over-reserves rather than under-reserving the post-processing activation peak.
+    """
+    if name is None:
+        return 1
+    return UPSCALER_SCALE_FACTORS.get(name, _DEFAULT_UPSCALE_FACTOR)
+
+
+def max_upscale_factor(names: Iterable[str | None]) -> int:
+    """Return the largest linear scale factor among *names*, or 1 when none enlarge the image.
+
+    A job may request several upscalers; the output size (and thus the activation peak) is driven by the
+    largest factor. ``None`` entries and an empty iterable contribute the no-op factor of 1.
+    """
+    factors = [upscaler_scale_factor(name) for name in names if name is not None]
+    return max(factors) if factors else 1
+
+
 SOURCE_IMAGE_PROCESSING_OPTIONS = ["img2img", "inpainting", "outpainting", "remix"]
 
 SCHEDULERS = ["normal", "karras", "simple", "ddim_uniform", "sgm_uniform", "exponential"]