per‑step CFG scheduling

Introduces per‑step CFG schedules (cosine, warmup, U‑shape) driven by log‑sigma progress; schedules stack with existing cfg_curve.
Presset finetune.

mod/easy/mg_cade25_easy.py

@@ -1378,6 +1378,73 @@ def _wrap_model_with_guidance(model, guidance_mode: str, rescale_multiplier: flo
             except Exception:
                 return None
 
+        # Compute effective cond scale before any branch, so schedules apply in all modes
+        cond_scale_eff = cond_scale
+        curve_gain = 1.0
+        if cfg_curve > 0.0 and (sigma is not None):
+            s = sigma
+            if s.ndim > 1:
+                s = s.flatten()
+            s_max = float(torch.max(s).item())
+            s_min = float(torch.min(s).item())
+            if sigma_seen["max"] is None:
+                sigma_seen["max"] = s_max
+                sigma_seen["min"] = s_min
+            else:
+                sigma_seen["max"] = max(sigma_seen["max"], s_max)
+                sigma_seen["min"] = min(sigma_seen["min"], s_min)
+            lo = max(1e-6, sigma_seen["min"])
+            hi = max(lo * (1.0 + 1e-6), sigma_seen["max"])
+            t = (torch.log(s + 1e-6) - torch.log(torch.tensor(lo, device=sigma.device))) / (torch.log(torch.tensor(hi, device=sigma.device)) - torch.log(torch.tensor(lo, device=sigma.device)) + 1e-6)
+            t = t.clamp(0.0, 1.0)
+            k = 6.0 * float(cfg_curve)
+            s_curve = torch.tanh((t - 0.5) * k)
+            g = 1.0 + 0.15 * float(cfg_curve) * s_curve
+            if g.ndim > 0:
+                g = g.mean().item()
+            curve_gain = float(g)
+            cond_scale_eff = cond_scale * curve_gain
+
+        if isinstance(cfg_sched_type, str) and cfg_sched_type.lower() != "off" and (sigma is not None):
+            try:
+                s = sigma
+                if s.ndim > 1:
+                    s = s.flatten()
+                s_max = float(torch.max(s).item())
+                s_min = float(torch.min(s).item())
+                if sigma_seen["max"] is None:
+                    sigma_seen["max"] = s_max
+                    sigma_seen["min"] = s_min
+                else:
+                    sigma_seen["max"] = max(sigma_seen["max"], s_max)
+                    sigma_seen["min"] = min(sigma_seen["min"], s_min)
+                lo = max(1e-6, sigma_seen["min"])
+                hi = max(lo * (1.0 + 1e-6), sigma_seen["max"])
+                t = (torch.log(s + 1e-6) - torch.log(torch.tensor(lo, device=sigma.device))) / (torch.log(torch.tensor(hi, device=sigma.device)) - torch.log(torch.tensor(lo, device=sigma.device)) + 1e-6)
+                t = t.clamp(0.0, 1.0)
+                if t.ndim > 0:
+                    t_val = float(t.mean().item())
+                else:
+                    t_val = float(t.item())
+                cmin = float(max(0.0, cfg_sched_min))
+                cmax = float(max(cmin, cfg_sched_max))
+                tp = cfg_sched_type.lower()
+                if tp == "cosine":
+                    import math
+                    cfg_val = cmax - (cmax - cmin) * 0.5 * (1.0 + math.cos(math.pi * t_val))
+                elif tp in ("warmup", "warm-up", "linear"):
+                    g = float(max(0.0, min(1.0, t_val))) ** float(max(0.1, cfg_sched_gamma))
+                    cfg_val = cmin + (cmax - cmin) * g
+                elif tp in ("u", "u-shape", "ushape"):
+                    e = 4.0 * (t_val - 0.5) * (t_val - 0.5)
+                    e = float(min(1.0, max(0.0, e)))
+                    e = e ** float(max(0.1, cfg_sched_u_pow))
+                    cfg_val = cmin + (cmax - cmin) * e
+                else:
+                    cfg_val = cond_scale_eff
+                cond_scale_eff = float(cfg_val) * float(curve_gain)
+            except Exception:
+                pass
         # Allow hybrid switch per-step
         mode = guidance_mode
         if guidance_mode == "ZeResFDG":
@@ -1448,7 +1515,7 @@ def _wrap_model_with_guidance(model, guidance_mode: str, rescale_multiplier: flo
             lg = _local_gain_for((cond.shape[-2], cond.shape[-1]))
             if lg is not None:
                 resid = resid * lg.expand(-1, resid.shape[1], -1, -1)
-            noise_pred = uncond * alpha + cond_scale * resid
+            noise_pred = uncond * alpha + cond_scale_eff * resid
             return noise_pred
 
         # RescaleCFG/FDG path (with optional momentum/perp damping and S-curve shaping)
@@ -1496,76 +1563,7 @@ def _wrap_model_with_guidance(model, guidance_mode: str, rescale_multiplier: flo
                 delta = delta * lg.expand(-1, delta.shape[1], -1, -1)
             cond = uncond + delta
 
-        cond_scale_eff = cond_scale
-        curve_gain = 1.0
-        if cfg_curve > 0.0 and (sigma is not None):
-            s = sigma
-            if s.ndim > 1:
-                s = s.flatten()
-            s_max = float(torch.max(s).item())
-            s_min = float(torch.min(s).item())
-            if sigma_seen["max"] is None:
-                sigma_seen["max"] = s_max
-                sigma_seen["min"] = s_min
-            else:
-                sigma_seen["max"] = max(sigma_seen["max"], s_max)
-                sigma_seen["min"] = min(sigma_seen["min"], s_min)
-            lo = max(1e-6, sigma_seen["min"])
-            hi = max(lo * (1.0 + 1e-6), sigma_seen["max"])
-            t = (torch.log(s + 1e-6) - torch.log(torch.tensor(lo, device=sigma.device))) / (torch.log(torch.tensor(hi, device=sigma.device)) - torch.log(torch.tensor(lo, device=sigma.device)) + 1e-6)
-            t = t.clamp(0.0, 1.0)
-            k = 6.0 * float(cfg_curve)
-            s_curve = torch.tanh((t - 0.5) * k)
-            g = 1.0 + 0.15 * float(cfg_curve) * s_curve
-            if g.ndim > 0:
-                g = g.mean().item()
-            curve_gain = float(g)
-            cond_scale_eff = cond_scale * curve_gain
-
-        # Per-step CFG schedule (cosine/warmup/U) using normalized sigma progress
-        if isinstance(cfg_sched_type, str) and cfg_sched_type.lower() != "off" and (sigma is not None):
-            try:
-                s = sigma
-                if s.ndim > 1:
-                    s = s.flatten()
-                s_max = float(torch.max(s).item())
-                s_min = float(torch.min(s).item())
-                if sigma_seen["max"] is None:
-                    sigma_seen["max"] = s_max
-                    sigma_seen["min"] = s_min
-                else:
-                    sigma_seen["max"] = max(sigma_seen["max"], s_max)
-                    sigma_seen["min"] = min(sigma_seen["min"], s_min)
-                lo = max(1e-6, sigma_seen["min"])
-                hi = max(lo * (1.0 + 1e-6), sigma_seen["max"])
-                t = (torch.log(s + 1e-6) - torch.log(torch.tensor(lo, device=sigma.device))) / (torch.log(torch.tensor(hi, device=sigma.device)) - torch.log(torch.tensor(lo, device=sigma.device)) + 1e-6)
-                t = t.clamp(0.0, 1.0)
-                if t.ndim > 0:
-                    t_val = float(t.mean().item())
-                else:
-                    t_val = float(t.item())
-                cmin = float(max(0.0, cfg_sched_min))
-                cmax = float(max(cmin, cfg_sched_max))
-                tp = cfg_sched_type.lower()
-                if tp == "cosine":
-                    import math
-                    cfg_val = cmax - (cmax - cmin) * 0.5 * (1.0 + math.cos(math.pi * t_val))
-                elif tp in ("warmup", "warm-up", "linear"):
-                    g = float(max(0.0, min(1.0, t_val))) ** float(max(0.1, cfg_sched_gamma))
-                    cfg_val = cmin + (cmax - cmin) * g
-                elif tp in ("u", "u-shape", "ushape"):
-                    # edges high, middle low; power to control concavity
-                    e = 4.0 * (t_val - 0.5) * (t_val - 0.5)
-                    e = float(min(1.0, max(0.0, e)))
-                    e = e ** float(max(0.1, cfg_sched_u_pow))
-                    cfg_val = cmin + (cmax - cmin) * e
-                else:
-                    cfg_val = cond_scale_eff
-                # Keep curve shaping as a multiplier on top of scheduled absolute value
-                shape = (cond_scale_eff / float(cond_scale)) if float(cond_scale) != 0.0 else 1.0
-                cond_scale_eff = float(cfg_val) * float(shape)
-            except Exception:
-                pass
+        
 
         # Epsilon scaling (exposure bias correction): early steps get multiplier closer to (1 + eps_scale)
         eps_mult = 1.0
@@ -2324,6 +2322,15 @@ class ComfyAdaptiveDetailEnhancer25:
                 __cade_noop = 0  # ensure non-empty with-block
                 # Latent buffer runtime state
                 lb_state = {"z_ema": None, "anchor": None, "drift_last": None, "ref_dist_last": None}
+                # Pre-initialize EMA from the incoming latent so that a 2-iteration node already benefits on iter=1
+                try:
+                    if bool(latent_buffer) and (iterations > 1):
+                        z0 = current_latent.get("samples", None)
+                        if isinstance(z0, torch.Tensor):
+                            lb_state["z_ema"] = z0.clone().detach()
+                            lb_state["anchor"] = z0.clone().detach()
+                except Exception:
+                    pass
 
                 # Preflight: reset sticky state and build external masks once (CPU-pinned)
                 try:

pressets/mg_cade25.cfg

@@ -6,7 +6,7 @@ seed: 0
 control_after_generate: randomize
 steps: 10
 cfg: 8.0
-denoise: 1.0
+denoise: 1.00
 sampler_name: ddim
 scheduler: MGHybrid
 iterations: 2
@@ -22,7 +22,7 @@ clip_clean: true
 latent_compare: true
 
 # latent buffer (internal)
-latent_buffer: true
+latent_buffer: false
 lb_inject: 0.25
 lb_ema: 0.75
 lb_every: 1
@@ -52,10 +52,10 @@ ref_cooldown: 2
 # cfg schedule (internal)
 #cfg_sched: off | cosine | warmup | u
 cfg_sched: warmup
-#cfg_sched_min: 4.0
-#cfg_sched_max: 8.0
+cfg_sched_min: 6.0
+cfg_sched_max: 8.8
 cfg_sched_gamma: 1.5
-#cfg_sched_u_pow: 1.0
+cfg_sched_u_pow: 1.0
 
 
 # guidance
@@ -138,9 +138,9 @@ aq_attn: true
 # core
 seed: 0
 control_after_generate: randomize
-steps: 8
+steps: 10
 cfg: 6.5
-denoise: 0.55
+denoise: 0.56
 sampler_name: ddim
 scheduler: MGHybrid
 iterations: 2
@@ -184,11 +184,11 @@ ref_cooldown: 2
 
 # cfg schedule (internal)
 #cfg_sched: off | cosine | warmup | u
-cfg_sched: cosine
-#cfg_sched_min: 3.0
-#cfg_sched_max: 6.5
-#cfg_sched_gamma: 1.5
-#cfg_sched_u_pow: 1.0
+cfg_sched: warmup
+cfg_sched_min: 4.0
+cfg_sched_max: 6.5
+cfg_sched_gamma: 1.5
+cfg_sched_u_pow: 1.0
 
 
 # guidance
@@ -271,13 +271,13 @@ aq_attn: true
 # core
 seed: 0
 control_after_generate: randomize
-steps: 10
-cfg: 5.0
-denoise: 0.40
+steps: 16
+cfg: 7.0
+denoise: 0.55
 sampler_name: ddim
 scheduler: MGHybrid
 iterations: 2
-steps_delta: 2.00
+steps_delta: 4.00
 cfg_delta: 0.03
 denoise_delta: 0.0500
 
@@ -296,7 +296,7 @@ latent_buffer: true
 lb_inject: 0.25
 lb_ema: 0.75
 lb_every: 1
-lb_anchor_every: 6
+lb_anchor_every: 4
 lb_masked: true
 lb_rebase_thresh: 0.10
 lb_rebase_rate: 0.25
@@ -322,8 +322,8 @@ ref_cooldown: 2
 # cfg schedule (internal)
 #cfg_sched: off | cosine | warmup | u
 cfg_sched: warmup
-cfg_sched_min: 4.5
-cfg_sched_max: 5.0
+cfg_sched_min: 5.8
+cfg_sched_max: 7.8
 cfg_sched_gamma: 1.5
 cfg_sched_u_pow: 1.2
 
@@ -346,10 +346,10 @@ use_zero_init: false
 zero_init_steps: 0
 
 # FDG / ZE thresholds
-fdg_low: 0.35
-fdg_high: 0.7
+fdg_low: 0.15
+fdg_high: 1.15
 fdg_sigma: 1.10
-ze_res_zero_steps: 12
+ze_res_zero_steps: 6
 ze_adaptive: true
 ze_r_switch_hi: 0.85
 ze_r_switch_lo: 0.25
@@ -397,7 +397,7 @@ midfreq_sigma_hi: 2.10
 # QSilk-AQClip-Lite (adaptive latent clipping)
 aqclip_enable: true
 aq_tile: 64
-aq_stride: 8
+aq_stride: 18
 aq_alpha: 2.0
 
 aq_attn: true
@@ -406,16 +406,16 @@ aq_attn: true
 # core
 seed: 0
 control_after_generate: randomize
-steps: 16
-cfg: 5.1
+steps: 20
+cfg: 7
 #0.75
-denoise: 0.49
+denoise: 0.50
 sampler_name: ddim
 scheduler: MGHybrid
 iterations: 2
 steps_delta: 2.00
 cfg_delta: 1.00
-denoise_delta: 0.10
+denoise_delta: 0.05
 
 # Smart seed toggle (disable for this step)
 smart_seed_enable: false
@@ -429,7 +429,7 @@ latent_compare: true
 
 # latent buffer (internal)
 latent_buffer: true
-lb_inject: 0.25
+lb_inject: 0.30
 lb_ema: 0.75
 lb_every: 1
 lb_anchor_every: 6
@@ -440,7 +440,8 @@ lb_rebase_rate: 0.25
 # detail controls
 ids_strength: 0.35
 upscale_method: lanczos
-scale_by: 1.5
+# 1.55
+scale_by: 1.50
 scale_delta: 0.1
 noise_offset: 0.0035
 threshold: 1.000
@@ -455,11 +456,11 @@ ref_cooldown: 2
 
 # cfg schedule (internal)
 #cfg_sched: off | cosine | warmup | u
-cfg_sched: cosine
-cfg_sched_min: 3.2
-cfg_sched_max: 5.6
+cfg_sched: warmup
+cfg_sched_min: 5.9
+cfg_sched_max: 7.0
 cfg_sched_gamma: 1.5
-cfg_sched_u_pow: 1.0
+cfg_sched_u_pow: 1.2
 
 
 # guidance
@@ -481,7 +482,7 @@ zero_init_steps: 0
 
 # FDG / ZE thresholds
 fdg_low: 0.35
-fdg_high: 1.15
+fdg_high: 0.90
 fdg_sigma: 1.20
 ze_res_zero_steps: 10
 ze_adaptive: true
@@ -512,7 +513,7 @@ clipseg_gain: 0.35
 clipseg_blend: fuse
 clipseg_ref_gate: true
 clipseg_ref_threshold: 0.005
-#seg_use_cf_edges: false
+seg_use_cf_edges: true
 
 # polish
 polish_enable: false