InvokeAI 6.11.0rc1__py3-none-any.whl → 6.11.1__py3-none-any.whl

invokeai/app/invocations/flux2_denoise.py

@@ -329,15 +329,13 @@ class Flux2DenoiseInvocation(BaseInvocation):
         noise_packed = pack_flux2(noise)
         x = pack_flux2(x)
 
-        # Apply BN normalization BEFORE denoising (as per diffusers Flux2KleinPipeline)
-        # BN normalization: y = (x - mean) / std
-        # This transforms latents to normalized space for the transformer
-        # IMPORTANT: Also normalize init_latents and noise for inpainting to maintain consistency
-        if bn_mean is not None and bn_std is not None:
-            x = self._bn_normalize(x, bn_mean, bn_std)
-            if init_latents_packed is not None:
-                init_latents_packed = self._bn_normalize(init_latents_packed, bn_mean, bn_std)
-            noise_packed = self._bn_normalize(noise_packed, bn_mean, bn_std)
+        # BN normalization for txt2img:
+        # - DO NOT normalize random noise (it's already N(0,1) distributed)
+        # - Diffusers only normalizes image latents from VAE (for img2img/kontext)
+        # - Output MUST be denormalized after denoising before VAE decode
+        #
+        # For img2img with init_latents, we should normalize init_latents on unpacked
+        # shape (B, 128, H/16, W/16) - this is handled by _bn_normalize_unpacked below
 
         # Verify packed dimensions
         assert packed_h * packed_w == x.shape[1]
@@ -366,16 +364,24 @@ class Flux2DenoiseInvocation(BaseInvocation):
         if self.scheduler in FLUX_SCHEDULER_MAP and not is_inpainting:
             # Only use scheduler for txt2img - use manual Euler for inpainting to preserve exact timesteps
             scheduler_class = FLUX_SCHEDULER_MAP[self.scheduler]
-            scheduler = scheduler_class(
-                num_train_timesteps=1000,
-                shift=3.0,
-                use_dynamic_shifting=True,
-                base_shift=0.5,
-                max_shift=1.15,
-                base_image_seq_len=256,
-                max_image_seq_len=4096,
-                time_shift_type="exponential",
-            )
+            # FlowMatchHeunDiscreteScheduler only supports num_train_timesteps and shift parameters
+            # FlowMatchEulerDiscreteScheduler and FlowMatchLCMScheduler support dynamic shifting
+            if self.scheduler == "heun":
+                scheduler = scheduler_class(
+                    num_train_timesteps=1000,
+                    shift=3.0,
+                )
+            else:
+                scheduler = scheduler_class(
+                    num_train_timesteps=1000,
+                    shift=3.0,
+                    use_dynamic_shifting=True,
+                    base_shift=0.5,
+                    max_shift=1.15,
+                    base_image_seq_len=256,
+                    max_image_seq_len=4096,
+                    time_shift_type="exponential",
+                )
 
         # Prepare reference image extension for FLUX.2 Klein built-in editing
         ref_image_extension = None

invokeai/app/invocations/flux2_vae_decode.py

@@ -57,20 +57,6 @@ class Flux2VaeDecodeInvocation(BaseInvocation, WithMetadata, WithBoard):
             # Decode using diffusers API
             decoded = vae.decode(latents, return_dict=False)[0]
 
-        # Debug: Log decoded output statistics
-        print(
-            f"[FLUX.2 VAE] Decoded output: shape={decoded.shape}, "
-            f"min={decoded.min().item():.4f}, max={decoded.max().item():.4f}, "
-            f"mean={decoded.mean().item():.4f}"
-        )
-        # Check per-channel statistics to diagnose color issues
-        for c in range(min(3, decoded.shape[1])):
-            ch = decoded[0, c]
-            print(
-                f"[FLUX.2 VAE] Channel {c}: min={ch.min().item():.4f}, "
-                f"max={ch.max().item():.4f}, mean={ch.mean().item():.4f}"
-            )
-
         # Convert from [-1, 1] to [0, 1] then to [0, 255] PIL image
         img = (decoded / 2 + 0.5).clamp(0, 1)
         img = rearrange(img[0], "c h w -> h w c")

invokeai/app/invocations/flux_denoise.py

@@ -32,7 +32,12 @@ from invokeai.app.services.shared.invocation_context import InvocationContext
 from invokeai.backend.flux.controlnet.instantx_controlnet_flux import InstantXControlNetFlux
 from invokeai.backend.flux.controlnet.xlabs_controlnet_flux import XLabsControlNetFlux
 from invokeai.backend.flux.denoise import denoise
-from invokeai.backend.flux.dype.presets import DyPEPreset, get_dype_config_from_preset
+from invokeai.backend.flux.dype.presets import (
+    DYPE_PRESET_LABELS,
+    DYPE_PRESET_OFF,
+    DyPEPreset,
+    get_dype_config_from_preset,
+)
 from invokeai.backend.flux.extensions.dype_extension import DyPEExtension
 from invokeai.backend.flux.extensions.instantx_controlnet_extension import InstantXControlNetExtension
 from invokeai.backend.flux.extensions.kontext_extension import KontextExtension
@@ -66,7 +71,7 @@ from invokeai.backend.util.devices import TorchDevice
     title="FLUX Denoise",
     tags=["image", "flux"],
     category="image",
-    version="4.3.0",
+    version="4.5.1",
 )
 class FluxDenoiseInvocation(BaseInvocation):
     """Run denoising process with a FLUX transformer model."""
@@ -170,20 +175,27 @@ class FluxDenoiseInvocation(BaseInvocation):
 
     # DyPE (Dynamic Position Extrapolation) for high-resolution generation
     dype_preset: DyPEPreset = InputField(
-        default=DyPEPreset.OFF,
-        description="DyPE preset for high-resolution generation. 'auto' enables automatically for resolutions > 1536px. '4k' uses optimized settings for 4K output.",
+        default=DYPE_PRESET_OFF,
+        description=(
+            "DyPE preset for high-resolution generation. 'auto' enables automatically for resolutions > 1536px. "
+            "'area' enables automatically based on image area. '4k' uses optimized settings for 4K output."
+        ),
+        ui_order=100,
+        ui_choice_labels=DYPE_PRESET_LABELS,
     )
     dype_scale: Optional[float] = InputField(
         default=None,
         ge=0.0,
         le=8.0,
         description="DyPE magnitude (λs). Higher values = stronger extrapolation. Only used when dype_preset is not 'off'.",
+        ui_order=101,
     )
     dype_exponent: Optional[float] = InputField(
         default=None,
         ge=0.0,
         le=1000.0,
         description="DyPE decay speed (λt). Controls transition from low to high frequency detail. Only used when dype_preset is not 'off'.",
+        ui_order=102,
     )
 
     @torch.no_grad()
@@ -464,9 +476,13 @@ class FluxDenoiseInvocation(BaseInvocation):
                     target_width=self.width,
                 )
                 context.logger.info(
-                    f"DyPE enabled: {self.width}x{self.height}, preset={self.dype_preset.value}, "
-                    f"scale={dype_config.dype_scale:.2f}, method={dype_config.method}"
+                    f"DyPE enabled: resolution={self.width}x{self.height}, preset={self.dype_preset}, "
+                    f"method={dype_config.method}, scale={dype_config.dype_scale:.2f}, "
+                    f"exponent={dype_config.dype_exponent:.2f}, start_sigma={dype_config.dype_start_sigma:.2f}, "
+                    f"base_resolution={dype_config.base_resolution}"
                 )
+            else:
+                context.logger.debug(f"DyPE disabled: resolution={self.width}x{self.height}, preset={self.dype_preset}")
 
             x = denoise(
                 model=transformer,

invokeai/app/invocations/flux_model_loader.py

@@ -6,7 +6,7 @@ from invokeai.app.invocations.baseinvocation import (
     invocation,
     invocation_output,
 )
-from invokeai.app.invocations.fields import FieldDescriptions, Input, InputField, OutputField
+from invokeai.app.invocations.fields import FieldDescriptions, InputField, OutputField
 from invokeai.app.invocations.model import CLIPField, ModelIdentifierField, T5EncoderField, TransformerField, VAEField
 from invokeai.app.services.shared.invocation_context import InvocationContext
 from invokeai.app.util.t5_model_identifier import (
@@ -37,28 +37,25 @@ class FluxModelLoaderOutput(BaseInvocationOutput):
     title="Main Model - FLUX",
     tags=["model", "flux"],
     category="model",
-    version="1.0.6",
+    version="1.0.7",
 )
 class FluxModelLoaderInvocation(BaseInvocation):
     """Loads a flux base model, outputting its submodels."""
 
     model: ModelIdentifierField = InputField(
         description=FieldDescriptions.flux_model,
-        input=Input.Direct,
         ui_model_base=BaseModelType.Flux,
         ui_model_type=ModelType.Main,
     )
 
     t5_encoder_model: ModelIdentifierField = InputField(
         description=FieldDescriptions.t5_encoder,
-        input=Input.Direct,
         title="T5 Encoder",
         ui_model_type=ModelType.T5Encoder,
     )
 
     clip_embed_model: ModelIdentifierField = InputField(
         description=FieldDescriptions.clip_embed_model,
-        input=Input.Direct,
         title="CLIP Embed",
         ui_model_type=ModelType.CLIPEmbed,
     )

invokeai/app/util/step_callback.py

@@ -93,54 +93,60 @@ COGVIEW4_LATENT_RGB_FACTORS = [
     [-0.00955853, -0.00980067, -0.00977842],
 ]
 
-# FLUX.2 uses 32 latent channels. Since we don't have proper factors yet,
-# we extend FLUX factors with zeros for preview approximation.
+# FLUX.2 uses 32 latent channels.
+# Factors from ComfyUI: https://github.com/Comfy-Org/ComfyUI/blob/main/comfy/latent_formats.py
 FLUX2_LATENT_RGB_FACTORS = [
     #   R        G        B
-    # First 16 channels (from FLUX)
-    [0.0118, 0.0024, 0.0017],
-    [-0.0074, -0.0108, -0.0003],
-    [0.0056, 0.0291, 0.0768],
-    [0.0342, -0.0681, -0.0427],
-    [-0.0258, 0.0092, 0.0463],
-    [0.0863, 0.0784, 0.0547],
-    [-0.0017, 0.0402, 0.0158],
-    [0.0501, 0.1058, 0.1152],
-    [-0.0209, -0.0218, -0.0329],
-    [-0.0314, 0.0083, 0.0896],
-    [0.0851, 0.0665, -0.0472],
-    [-0.0534, 0.0238, -0.0024],
-    [0.0452, -0.0026, 0.0048],
-    [0.0892, 0.0831, 0.0881],
-    [-0.1117, -0.0304, -0.0789],
-    [0.0027, -0.0479, -0.0043],
-    # Additional 16 channels (zeros as placeholder)
-    [0.0, 0.0, 0.0],
-    [0.0, 0.0, 0.0],
-    [0.0, 0.0, 0.0],
-    [0.0, 0.0, 0.0],
-    [0.0, 0.0, 0.0],
-    [0.0, 0.0, 0.0],
-    [0.0, 0.0, 0.0],
-    [0.0, 0.0, 0.0],
-    [0.0, 0.0, 0.0],
-    [0.0, 0.0, 0.0],
-    [0.0, 0.0, 0.0],
-    [0.0, 0.0, 0.0],
-    [0.0, 0.0, 0.0],
-    [0.0, 0.0, 0.0],
-    [0.0, 0.0, 0.0],
-    [0.0, 0.0, 0.0],
+    [0.0058, 0.0113, 0.0073],
+    [0.0495, 0.0443, 0.0836],
+    [-0.0099, 0.0096, 0.0644],
+    [0.2144, 0.3009, 0.3652],
+    [0.0166, -0.0039, -0.0054],
+    [0.0157, 0.0103, -0.0160],
+    [-0.0398, 0.0902, -0.0235],
+    [-0.0052, 0.0095, 0.0109],
+    [-0.3527, -0.2712, -0.1666],
+    [-0.0301, -0.0356, -0.0180],
+    [-0.0107, 0.0078, 0.0013],
+    [0.0746, 0.0090, -0.0941],
+    [0.0156, 0.0169, 0.0070],
+    [-0.0034, -0.0040, -0.0114],
+    [0.0032, 0.0181, 0.0080],
+    [-0.0939, -0.0008, 0.0186],
+    [0.0018, 0.0043, 0.0104],
+    [0.0284, 0.0056, -0.0127],
+    [-0.0024, -0.0022, -0.0030],
+    [0.1207, -0.0026, 0.0065],
+    [0.0128, 0.0101, 0.0142],
+    [0.0137, -0.0072, -0.0007],
+    [0.0095, 0.0092, -0.0059],
+    [0.0000, -0.0077, -0.0049],
+    [-0.0465, -0.0204, -0.0312],
+    [0.0095, 0.0012, -0.0066],
+    [0.0290, -0.0034, 0.0025],
+    [0.0220, 0.0169, -0.0048],
+    [-0.0332, -0.0457, -0.0468],
+    [-0.0085, 0.0389, 0.0609],
+    [-0.0076, 0.0003, -0.0043],
+    [-0.0111, -0.0460, -0.0614],
 ]
 
+FLUX2_LATENT_RGB_BIAS = [-0.0329, -0.0718, -0.0851]
+
 
 def sample_to_lowres_estimated_image(
-    samples: torch.Tensor, latent_rgb_factors: torch.Tensor, smooth_matrix: Optional[torch.Tensor] = None
+    samples: torch.Tensor,
+    latent_rgb_factors: torch.Tensor,
+    smooth_matrix: Optional[torch.Tensor] = None,
+    latent_rgb_bias: Optional[torch.Tensor] = None,
 ):
     if samples.dim() == 4:
         samples = samples[0]
     latent_image = samples.permute(1, 2, 0) @ latent_rgb_factors
 
+    if latent_rgb_bias is not None:
+        latent_image = latent_image + latent_rgb_bias
+
     if smooth_matrix is not None:
         latent_image = latent_image.unsqueeze(0).permute(3, 0, 1, 2)
         latent_image = torch.nn.functional.conv2d(latent_image, smooth_matrix.reshape((1, 1, 3, 3)), padding=1)
@@ -193,6 +199,7 @@ def diffusion_step_callback(
         sample = intermediate_state.latents
 
     smooth_matrix: list[list[float]] | None = None
+    latent_rgb_bias: list[float] | None = None
     if base_model in [BaseModelType.StableDiffusion1, BaseModelType.StableDiffusion2]:
         latent_rgb_factors = SD1_5_LATENT_RGB_FACTORS
     elif base_model in [BaseModelType.StableDiffusionXL, BaseModelType.StableDiffusionXLRefiner]:
@@ -206,6 +213,7 @@ def diffusion_step_callback(
         latent_rgb_factors = FLUX_LATENT_RGB_FACTORS
     elif base_model == BaseModelType.Flux2:
         latent_rgb_factors = FLUX2_LATENT_RGB_FACTORS
+        latent_rgb_bias = FLUX2_LATENT_RGB_BIAS
     elif base_model == BaseModelType.ZImage:
         # Z-Image uses FLUX-compatible VAE with 16 latent channels
         latent_rgb_factors = FLUX_LATENT_RGB_FACTORS
@@ -216,8 +224,14 @@ def diffusion_step_callback(
     smooth_matrix_torch = (
         torch.tensor(smooth_matrix, dtype=sample.dtype, device=sample.device) if smooth_matrix else None
     )
+    latent_rgb_bias_torch = (
+        torch.tensor(latent_rgb_bias, dtype=sample.dtype, device=sample.device) if latent_rgb_bias else None
+    )
     image = sample_to_lowres_estimated_image(
-        samples=sample, latent_rgb_factors=latent_rgb_factors_torch, smooth_matrix=smooth_matrix_torch
+        samples=sample,
+        latent_rgb_factors=latent_rgb_factors_torch,
+        smooth_matrix=smooth_matrix_torch,
+        latent_rgb_bias=latent_rgb_bias_torch,
     )
 
     width = image.width * 8

invokeai/backend/flux/dype/__init__.py

@@ -8,11 +8,28 @@ Based on: https://github.com/wildminder/ComfyUI-DyPE
 
 from invokeai.backend.flux.dype.base import DyPEConfig
 from invokeai.backend.flux.dype.embed import DyPEEmbedND
-from invokeai.backend.flux.dype.presets import DyPEPreset, get_dype_config_for_resolution
+from invokeai.backend.flux.dype.presets import (
+    DYPE_PRESET_4K,
+    DYPE_PRESET_AREA,
+    DYPE_PRESET_AUTO,
+    DYPE_PRESET_LABELS,
+    DYPE_PRESET_MANUAL,
+    DYPE_PRESET_OFF,
+    DyPEPreset,
+    get_dype_config_for_area,
+    get_dype_config_for_resolution,
+)
 
 __all__ = [
     "DyPEConfig",
     "DyPEEmbedND",
     "DyPEPreset",
+    "DYPE_PRESET_OFF",
+    "DYPE_PRESET_MANUAL",
+    "DYPE_PRESET_AUTO",
+    "DYPE_PRESET_AREA",
+    "DYPE_PRESET_4K",
+    "DYPE_PRESET_LABELS",
+    "get_dype_config_for_area",
     "get_dype_config_for_resolution",
 ]

invokeai/backend/flux/dype/base.py

@@ -99,13 +99,17 @@ def compute_vision_yarn_freqs(
     The NTK-aware approach smoothly interpolates frequencies to cover larger
     position ranges without breaking the attention patterns.
 
+    DyPE (Dynamic Position Extrapolation) modulates the NTK scaling based on
+    the current timestep - stronger extrapolation in early steps (global structure),
+    weaker in late steps (fine details).
+
     Args:
         pos: Position tensor
         dim: Embedding dimension
         theta: RoPE base frequency
         scale_h: Height scaling factor
         scale_w: Width scaling factor
-        current_sigma: Current noise level (reserved for future timestep-aware scaling)
+        current_sigma: Current noise level (1.0 = full noise, 0.0 = clean)
         dype_config: DyPE configuration
 
     Returns:
@@ -124,7 +128,24 @@ def compute_vision_yarn_freqs(
     # This increases the wavelength of position encodings proportionally
     if scale > 1.0:
         ntk_alpha = scale ** (dim / (dim - 2))
-        scaled_theta = theta * ntk_alpha
+
+        # Apply timestep-dependent DyPE modulation
+        # mscale controls how strongly we apply the NTK extrapolation
+        # Early steps (high sigma): stronger extrapolation for global structure
+        # Late steps (low sigma): weaker extrapolation for fine details
+        mscale = get_timestep_mscale(
+            scale=scale,
+            current_sigma=current_sigma,
+            dype_scale=dype_config.dype_scale,
+            dype_exponent=dype_config.dype_exponent,
+            dype_start_sigma=dype_config.dype_start_sigma,
+        )
+
+        # Modulate NTK alpha by mscale
+        # When mscale > 1: interpolate towards stronger extrapolation
+        # When mscale = 1: use base NTK alpha
+        modulated_alpha = 1.0 + (ntk_alpha - 1.0) * mscale
+        scaled_theta = theta * modulated_alpha
     else:
         scaled_theta = theta
 
@@ -151,14 +172,15 @@ def compute_yarn_freqs(
 ) -> tuple[Tensor, Tensor]:
     """Compute RoPE frequencies using YARN/NTK method.
 
-    Uses NTK-aware theta scaling for high-resolution support.
+    Uses NTK-aware theta scaling for high-resolution support with
+    timestep-dependent DyPE modulation.
 
     Args:
         pos: Position tensor
         dim: Embedding dimension
         theta: RoPE base frequency
         scale: Uniform scaling factor
-        current_sigma: Current noise level (reserved for future use)
+        current_sigma: Current noise level (1.0 = full noise, 0.0 = clean)
         dype_config: DyPE configuration
 
     Returns:
@@ -169,10 +191,22 @@ def compute_yarn_freqs(
     device = pos.device
     dtype = torch.float64 if device.type != "mps" else torch.float32
 
-    # NTK-aware theta scaling
+    # NTK-aware theta scaling with DyPE modulation
     if scale > 1.0:
         ntk_alpha = scale ** (dim / (dim - 2))
-        scaled_theta = theta * ntk_alpha
+
+        # Apply timestep-dependent DyPE modulation
+        mscale = get_timestep_mscale(
+            scale=scale,
+            current_sigma=current_sigma,
+            dype_scale=dype_config.dype_scale,
+            dype_exponent=dype_config.dype_exponent,
+            dype_start_sigma=dype_config.dype_start_sigma,
+        )
+
+        # Modulate NTK alpha by mscale
+        modulated_alpha = 1.0 + (ntk_alpha - 1.0) * mscale
+        scaled_theta = theta * modulated_alpha
     else:
         scaled_theta = theta
 

invokeai/backend/flux/dype/presets.py

@@ -1,17 +1,29 @@
 """DyPE presets and automatic configuration."""
 
+import math
 from dataclasses import dataclass
-from enum import Enum
+from typing import Literal
 
 from invokeai.backend.flux.dype.base import DyPEConfig
 
-
-class DyPEPreset(str, Enum):
-    """Predefined DyPE configurations."""
-
-    OFF = "off"  # DyPE disabled
-    AUTO = "auto"  # Automatically enable based on resolution
-    PRESET_4K = "4k"  # Optimized for 3840x2160 / 4096x2160
+# DyPE preset type - using Literal for proper frontend dropdown support
+DyPEPreset = Literal["off", "manual", "auto", "area", "4k"]
+
+# Constants for preset values
+DYPE_PRESET_OFF: DyPEPreset = "off"
+DYPE_PRESET_MANUAL: DyPEPreset = "manual"
+DYPE_PRESET_AUTO: DyPEPreset = "auto"
+DYPE_PRESET_AREA: DyPEPreset = "area"
+DYPE_PRESET_4K: DyPEPreset = "4k"
+
+# Human-readable labels for the UI
+DYPE_PRESET_LABELS: dict[str, str] = {
+    "off": "Off",
+    "manual": "Manual",
+    "auto": "Auto (>1536px)",
+    "area": "Area (auto)",
+    "4k": "4K Optimized",
+}
 
 
 @dataclass
@@ -27,7 +39,7 @@ class DyPEPresetConfig:
 
 # Predefined preset configurations
 DYPE_PRESETS: dict[DyPEPreset, DyPEPresetConfig] = {
-    DyPEPreset.PRESET_4K: DyPEPresetConfig(
+    DYPE_PRESET_4K: DyPEPresetConfig(
         base_resolution=1024,
         method="vision_yarn",
         dype_scale=2.0,
@@ -79,6 +91,50 @@ def get_dype_config_for_resolution(
     )
 
 
+def get_dype_config_for_area(
+    width: int,
+    height: int,
+    base_resolution: int = 1024,
+) -> DyPEConfig | None:
+    """Automatically determine DyPE config based on target area.
+
+    Uses sqrt(area/base_area) as an effective side-length ratio.
+    DyPE is enabled only when target area exceeds base area.
+
+    Returns:
+        DyPEConfig if DyPE should be enabled, None otherwise
+    """
+    area = width * height
+    base_area = base_resolution**2
+
+    if area <= base_area:
+        return None
+
+    area_ratio = area / base_area
+    effective_side_ratio = math.sqrt(area_ratio)  # 1.0 at base, 2.0 at 2K (if base is 1K)
+
+    # Strength: 0 at base area, 8 at sat_area, clamped thereafter.
+    sat_area = 2027520  # Determined by experimentation where a vertical line appears
+    sat_side_ratio = math.sqrt(sat_area / base_area)
+    dynamic_dype_scale = 8.0 * (effective_side_ratio - 1.0) / (sat_side_ratio - 1.0)
+    dynamic_dype_scale = max(0.0, min(dynamic_dype_scale, 8.0))
+
+    # Continuous exponent schedule:
+    # r=1 -> 0.5, r=2 -> 1.0, r=4 -> 2.0 (exact), smoothly varying in between.
+    x = math.log2(effective_side_ratio)
+    dype_exponent = 0.25 * (x**2) + 0.25 * x + 0.5
+    dype_exponent = max(0.5, min(dype_exponent, 2.0))
+
+    return DyPEConfig(
+        enable_dype=True,
+        base_resolution=base_resolution,
+        method="vision_yarn",
+        dype_scale=dynamic_dype_scale,
+        dype_exponent=dype_exponent,
+        dype_start_sigma=1.0,
+    )
+
+
 def get_dype_config_from_preset(
     preset: DyPEPreset,
     width: int,
@@ -92,41 +148,47 @@ def get_dype_config_from_preset(
         preset: The DyPE preset to use
         width: Target image width
         height: Target image height
-        custom_scale: Optional custom dype_scale (overrides preset)
-        custom_exponent: Optional custom dype_exponent (overrides preset)
+        custom_scale: Optional custom dype_scale (only used with 'manual' preset)
+        custom_exponent: Optional custom dype_exponent (only used with 'manual' preset)
 
     Returns:
         DyPEConfig if DyPE should be enabled, None otherwise
     """
-    if preset == DyPEPreset.OFF:
-        # Check if custom values are provided even with preset=OFF
-        if custom_scale is not None:
-            return DyPEConfig(
-                enable_dype=True,
-                base_resolution=1024,
-                method="vision_yarn",
-                dype_scale=custom_scale,
-                dype_exponent=custom_exponent if custom_exponent is not None else 2.0,
-                dype_start_sigma=1.0,
-            )
+    if preset == DYPE_PRESET_OFF:
         return None
 
-    if preset == DyPEPreset.AUTO:
-        config = get_dype_config_for_resolution(
+    if preset == DYPE_PRESET_MANUAL:
+        # Manual mode - custom values can override defaults
+        max_dim = max(width, height)
+        scale = max_dim / 1024
+        dynamic_dype_scale = min(2.0 * scale, 8.0)
+        return DyPEConfig(
+            enable_dype=True,
+            base_resolution=1024,
+            method="vision_yarn",
+            dype_scale=custom_scale if custom_scale is not None else dynamic_dype_scale,
+            dype_exponent=custom_exponent if custom_exponent is not None else 2.0,
+            dype_start_sigma=1.0,
+        )
+
+    if preset == DYPE_PRESET_AUTO:
+        # Auto preset - custom values are ignored
+        return get_dype_config_for_resolution(
             width=width,
             height=height,
             base_resolution=1024,
             activation_threshold=1536,
         )
-        # Apply custom overrides if provided
-        if config is not None:
-            if custom_scale is not None:
-                config.dype_scale = custom_scale
-            if custom_exponent is not None:
-                config.dype_exponent = custom_exponent
-        return config
-
-    # Use preset configuration
+
+    if preset == DYPE_PRESET_AREA:
+        # Area-based preset - custom values are ignored
+        return get_dype_config_for_area(
+            width=width,
+            height=height,
+            base_resolution=1024,
+        )
+
+    # Use preset configuration (4K etc.) - custom values are ignored
     preset_config = DYPE_PRESETS.get(preset)
     if preset_config is None:
         return None
@@ -135,7 +197,7 @@ def get_dype_config_from_preset(
         enable_dype=True,
         base_resolution=preset_config.base_resolution,
         method=preset_config.method,
-        dype_scale=custom_scale if custom_scale is not None else preset_config.dype_scale,
-        dype_exponent=custom_exponent if custom_exponent is not None else preset_config.dype_exponent,
+        dype_scale=preset_config.dype_scale,
+        dype_exponent=preset_config.dype_exponent,
         dype_start_sigma=preset_config.dype_start_sigma,
     )