Upload sd_simple_kes_v2 using SD-Hub

sd_simple_kes_v2/get_sigmas.py

@@ -0,0 +1,32 @@
+import math
+import torch
+from torch import linspace, tensor
+
+#source files are from the diffusers library. Modified file to remove error messages on console:
+'''
+UserWarning: To copy construct from a tensor, it is recommended to use sourceTensor.clone().detach() or sourceTensor.clone().detach().requires_grad_(True), rather than torch.tensor(sourceTensor).
+  min_inv_rho = tensor(sigma_min, device=device) ** (1 / rho)
+
+'''
+def append_zero(x):
+    return torch.cat([x, x.new_zeros([1])])
+
+def get_sigmas_karras(n, sigma_min, sigma_max, rho=7., device='cpu'):
+    """Constructs the noise schedule of Karras et al. (2022)."""
+    ramp = linspace(0, 1, n, device=device)
+    #min_inv_rho = tensor(sigma_min, device=device) ** (1 / rho)
+    #max_inv_rho = tensor(sigma_max, device=device) ** (1 / rho)
+    def _to_tensor(val, device):
+        return val.to(device) if isinstance(val, torch.Tensor) else torch.tensor(val, device=device)
+
+    min_inv_rho = _to_tensor(sigma_min, device) ** (1 / rho)
+    max_inv_rho = _to_tensor(sigma_max, device) ** (1 / rho)
+    sigmas = (max_inv_rho + ramp * (min_inv_rho - max_inv_rho)) ** rho
+    return append_zero(sigmas).to(device)
+
+
+
+def get_sigmas_exponential(n, sigma_min, sigma_max, device='cpu'):
+    """Constructs an exponential noise schedule."""
+    sigmas = torch.linspace(math.log(sigma_max), math.log(sigma_min), n, device=device).exp()
+    return append_zero(sigmas)

sd_simple_kes_v2/image_generation_data/generation_log_20250706_075947.txt

@@ -0,0 +1,332 @@
+[Config Validation] Config validated and missing values filled successfully.
+Final sigmas: sigma_min=0.13757067353874633, sigma_max=47.95768510805332
+[Auto Sigma Min] sigma_min set to 0.05328631678672591 using scale factor 900
+Generated sigma sequences. Karras: tensor([47.9577, 40.8963, 34.7614, 29.4468, 24.8569, 20.9051, 17.5141, 14.6142,
+        12.1431, 10.0455,  8.2718,  6.7783,  5.5261,  4.4811,  3.6131,  2.8959,
+         2.3064,  1.8247,  1.4333,  1.1174,  0.8642,  0.6626,  0.5034,  0.3788,
+         0.2820,  0.2075,  0.1509,  0.1083,  0.0766,  0.0533,  0.0000],
+       device='cuda:0'), Exponential: tensor([47.9577, 37.9304, 29.9997, 23.7272, 18.7662, 14.8425, 11.7391,  9.2846,
+         7.3434,  5.8080,  4.5936,  3.6332,  2.8735,  2.2727,  1.7975,  1.4217,
+         1.1244,  0.8893,  0.7034,  0.5563,  0.4400,  0.3480,  0.2752,  0.2177,
+         0.1722,  0.1362,  0.1077,  0.0852,  0.0674,  0.0533,  0.0000],
+       device='cuda:0')
+
+--- Starting Pre-Pass Blending ---
+
+[Prepass First Step - Step 0/30] Blended Sigma: 47.957703, Final Sigma: 53.952412
+Prepass First Step Delta Converged: True delta_change: 0.000000, Target Default Settings:0.6
+
+--- Early Stopping Evaluation at Step 12 ---
+Current Blended Sigma: 6.541308
+Sigma Variance: 205.154327
+Relative Sigma Progress: 0.991854
+Max Recent Sigma Change: 3.083299
+Mean Recent Sigma Change: 2.090022
+
+--- Early Stopping Evaluation at Step 13 ---
+Current Blended Sigma: 5.300452
+Sigma Variance: 205.005798
+Relative Sigma Progress: 0.989947
+Max Recent Sigma Change: 2.492145
+Mean Recent Sigma Change: 1.673866
+
+--- Early Stopping Evaluation at Step 14 ---
+Current Blended Sigma: 4.269258
+Sigma Variance: 204.924225
+Relative Sigma Progress: 0.987519
+Max Recent Sigma Change: 2.003127
+Mean Recent Sigma Change: 1.332481
+
+--- Early Stopping Evaluation at Step 15 ---
+Current Blended Sigma: 3.417069
+Sigma Variance: 204.903030
+Relative Sigma Progress: 0.984406
+Max Recent Sigma Change: 1.600587
+Mean Recent Sigma Change: 1.053938
+
+--- Early Stopping Evaluation at Step 16 ---
+Current Blended Sigma: 2.716985
+Sigma Variance: 204.930466
+Relative Sigma Progress: 0.980388
+Max Recent Sigma Change: 1.270950
+Mean Recent Sigma Change: 0.827970
+
+--- Early Stopping Evaluation at Step 17 ---
+Current Blended Sigma: 2.145483
+Sigma Variance: 204.993378
+Relative Sigma Progress: 0.975163
+Max Recent Sigma Change: 1.002521
+Mean Recent Sigma Change: 0.645771
+
+--- Early Stopping Evaluation at Step 18 ---
+Current Blended Sigma: 1.682080
+Sigma Variance: 205.079575
+Relative Sigma Progress: 0.968321
+Max Recent Sigma Change: 0.785219
+Mean Recent Sigma Change: 0.499817
+
+--- Early Stopping Evaluation at Step 19 ---
+Current Blended Sigma: 1.309016
+Sigma Variance: 205.178589
+Relative Sigma Progress: 0.959293
+Max Recent Sigma Change: 0.610414
+Mean Recent Sigma Change: 0.383711
+
+--- Early Stopping Evaluation at Step 20 ---
+Current Blended Sigma: 1.010955
+Sigma Variance: 205.282227
+Relative Sigma Progress: 0.947291
+Max Recent Sigma Change: 0.470745
+Mean Recent Sigma Change: 0.292036
+
+--- Early Stopping Evaluation at Step 21 ---
+Current Blended Sigma: 0.774734
+Sigma Variance: 205.384445
+Relative Sigma Progress: 0.931220
+Max Recent Sigma Change: 0.359954
+Mean Recent Sigma Change: 0.220228
+
+--- Early Stopping Evaluation at Step 22 ---
+Current Blended Sigma: 0.589107
+Sigma Variance: 205.481079
+Relative Sigma Progress: 0.909547
+Max Recent Sigma Change: 0.272753
+Mean Recent Sigma Change: 0.164463
+
+--- Early Stopping Evaluation at Step 23 ---
+Current Blended Sigma: 0.444537
+Sigma Variance: 205.569595
+Relative Sigma Progress: 0.880131
+Max Recent Sigma Change: 0.204688
+Mean Recent Sigma Change: 0.121554
+
+--- Early Stopping Evaluation at Step 24 ---
+Current Blended Sigma: 0.332985
+Sigma Variance: 205.648605
+Relative Sigma Progress: 0.839974
+Max Recent Sigma Change: 0.152039
+Mean Recent Sigma Change: 0.088862
+
+--- Early Stopping Evaluation at Step 25 ---
+Current Blended Sigma: 0.247734
+Sigma Variance: 205.717728
+Relative Sigma Progress: 0.784905
+Max Recent Sigma Change: 0.111705
+Mean Recent Sigma Change: 0.064218
+
+--- Early Stopping Evaluation at Step 26 ---
+Current Blended Sigma: 0.183217
+Sigma Variance: 205.777161
+Relative Sigma Progress: 0.709164
+Max Recent Sigma Change: 0.081129
+Mean Recent Sigma Change: 0.045850
+
+--- Early Stopping Evaluation at Step 27 ---
+Current Blended Sigma: 0.134866
+Sigma Variance: 205.827545
+Relative Sigma Progress: 0.604895
+Max Recent Sigma Change: 0.058207
+Mean Recent Sigma Change: 0.032324
+Early stopping triggered by mean at step 26. Mean change: 0.058207. Steps used: 27/31, steps skipped: 4
+
+--- Early Stopping Evaluation at Step 28 ---
+Current Blended Sigma: 0.098973
+Sigma Variance: 205.869736
+Relative Sigma Progress: 0.461609
+Max Recent Sigma Change: 0.041230
+Mean Recent Sigma Change: 0.022493
+Early stopping triggered by mean at step 27. Mean change: 0.041230. Steps used: 28/31, steps skipped: 3
+
+--- Early Stopping Evaluation at Step 29 ---
+Current Blended Sigma: 0.072565
+Sigma Variance: 205.904678
+Relative Sigma Progress: 0.265671
+Max Recent Sigma Change: 0.028817
+Mean Recent Sigma Change: 0.015444
+Early stopping triggered by mean at step 28. Mean change: 0.028817. Steps used: 29/31, steps skipped: 2
+
+--- Early Stopping Evaluation at Step 30 ---
+Current Blended Sigma: 0.053286
+Sigma Variance: 205.933395
+Relative Sigma Progress: 0.875376
+Max Recent Sigma Change: 0.019865
+Mean Recent Sigma Change: 0.010461
+Early stopping triggered by mean at step 29. Mean change: 0.019865. Steps used: 30/31, steps skipped: 1
+[Randomization] sigma_min: No randomization applied. Using default value: 0.13757067353874633
+[Randomization] sigma_max: No randomization applied. Using default value: 47.95768510805332
+[Randomization] start_blend: No randomization applied. Using default value: 0.08
+[Randomization] end_blend: No randomization applied. Using default value: 0.5
+[Randomization] sharpness: No randomization applied. Using default value: 0.85
+[Randomization] early_stopping_threshold: No randomization applied. Using default value: 0.06
+[Randomization] initial_step_size: No randomization applied. Using default value: 0.9
+[Randomization] final_step_size: No randomization applied. Using default value: 0.2
+[Randomization] initial_noise_scale: No randomization applied. Using default value: 1.25
+[Randomization] final_noise_scale: No randomization applied. Using default value: 0.8
+[Randomization] smooth_blend_factor: No randomization applied. Using default value: 9.426004103284665
+[Randomization] step_size_factor: No randomization applied. Using default value: 0.80814932869181
+[Randomization] noise_scale_factor: No randomization applied. Using default value: 0.8113992828873163
+[Randomization] rho: No randomization applied. Using default value: 7.959565031107985
+Using device: cuda
+Final sigmas: sigma_min=0.13757067353874633, sigma_max=47.95768510805332
+[Auto Sigma Min] sigma_min set to 0.05328631678672591 using scale factor 900
+Generated sigma sequences. Karras: tensor([47.9577, 40.8963, 34.7614, 29.4468, 24.8569, 20.9051, 17.5141, 14.6142,
+        12.1431, 10.0455,  8.2718,  6.7783,  5.5261,  4.4811,  3.6131,  2.8959,
+         2.3064,  1.8247,  1.4333,  1.1174,  0.8642,  0.6626,  0.5034,  0.3788,
+         0.2820,  0.2075,  0.1509,  0.1083,  0.0766,  0.0533,  0.0000],
+       device='cuda:0'), Exponential: tensor([47.9577, 37.9304, 29.9997, 23.7272, 18.7662, 14.8425, 11.7391,  9.2846,
+         7.3434,  5.8080,  4.5936,  3.6332,  2.8735,  2.2727,  1.7975,  1.4217,
+         1.1244,  0.8893,  0.7034,  0.5563,  0.4400,  0.3480,  0.2752,  0.2177,
+         0.1722,  0.1362,  0.1077,  0.0852,  0.0674,  0.0533,  0.0000],
+       device='cuda:0')
+
+--- Starting Final Pass Blending ---
+
+
+==========
+[Start of Sigma Sequence Logging]
+==========
+[First Step - Step 1/31]
+Step Size: 0.186242
+Dynamic Blend Factor: 0.080000
+Noise Scale: 1.250000
+Smooth Blend: 0.018726
+Blended Sigma: 47.957703
+Final Sigma: 11.164686
+
+==========
+[End of Sigma Sequence Logging]
+==========
+
+==========
+[Start of Sigma Sequence Logging]
+==========
+[First Step - Step 0/30]
+Step Size: 0.186242
+Blended Sigma: 47.957703
+Final Sigma: 11.164686
+
+==========
+[End of Sigma Sequence Logging]
+==========
+
+--- Starting Final Pass Blending ---
+
+
+--- Starting Final Pass Blending ---
+
+
+--- Starting Final Pass Blending ---
+
+
+--- Starting Final Pass Blending ---
+
+
+--- Starting Final Pass Blending ---
+
+
+--- Starting Final Pass Blending ---
+
+
+--- Starting Final Pass Blending ---
+
+
+--- Starting Final Pass Blending ---
+
+
+--- Starting Final Pass Blending ---
+
+
+--- Starting Final Pass Blending ---
+
+
+--- Starting Final Pass Blending ---
+
+Sigma Variance: 8.835401
+
+--- Starting Final Pass Blending ---
+
+Sigma Variance: 8.867280
+
+--- Starting Final Pass Blending ---
+
+Sigma Variance: 8.940592
+
+--- Starting Final Pass Blending ---
+
+Sigma Variance: 9.023338
+
+--- Starting Final Pass Blending ---
+
+
+==========
+[Start of Sigma Sequence Logging]
+==========
+[Middle Step - Step 16/31]
+Step Size: 0.186242
+Dynamic Blend Factor: 0.290000
+Noise Scale: 0.949560
+Smooth Blend: 0.121376
+Blended Sigma: 2.716985
+Final Sigma: 0.480494
+
+==========
+[End of Sigma Sequence Logging]
+==========
+Sigma Variance: 9.099936
+
+--- Starting Final Pass Blending ---
+
+Sigma Variance: 9.164114
+
+--- Starting Final Pass Blending ---
+
+Sigma Variance: 9.214593
+
+--- Starting Final Pass Blending ---
+
+Sigma Variance: 9.252495
+
+--- Starting Final Pass Blending ---
+
+Sigma Variance: 9.279906
+
+--- Starting Final Pass Blending ---
+
+Sigma Variance: 9.299084
+
+--- Starting Final Pass Blending ---
+
+Sigma Variance: 9.312086
+
+--- Starting Final Pass Blending ---
+
+Sigma Variance: 9.320630
+
+--- Starting Final Pass Blending ---
+
+Sigma Variance: 9.326054
+
+--- Starting Final Pass Blending ---
+
+Sigma Variance: 9.329365
+
+--- Starting Final Pass Blending ---
+
+Sigma Variance: 9.331285
+
+--- Starting Final Pass Blending ---
+
+Sigma Variance: 9.332323
+
+--- Starting Final Pass Blending ---
+
+Sigma Variance: 9.332817
+
+--- Starting Final Pass Blending ---
+
+Sigma Variance: 9.332994
+
+--- Starting Final Pass Blending ---
+
+Sigma Variance: 9.332994
+[Sharpen Mask] Full sharpening applied at steps: [22, 23, 24, 25, 26, 27, 28, 29]

sd_simple_kes_v2/kes_config/default_config.yaml

@@ -0,0 +1,137 @@
+log_save_directory: "modules/sd_simple_kes/image_generation_data"
+graph_save_directory: "modules/sd_simple_kes/image_generation_data"
+graph_save_enable: false
+
+skip_prepass: false # has no change to image quality - not currently functioning as intended for early stop purposes
+device: "cuda" #cpu or cuda
+debug: true
+global_randomize: false
+#
+sigma_scale_factor: 900
+sigma_auto_enabled: true
+sigma_auto_mode: sigma_min # Options: sigma_min, sigma_max
+#
+rho_rand: false
+rho_rand_min: 3.00 # tested recommended settings threshold
+rho_rand_max: 8.00 # tested recommended settings threshold
+#rho: 7.571656624637901
+rho: 7.959565031107985
+rho_enable_randomization_type: false
+rho_randomization_type: "log"
+rho_randomization_percent: 0.1
+#
+sigma_min_rand: false
+sigma_min_rand_min: 0.001 # tested recommended settings 
+sigma_min_rand_max: 0.02 # tested recommended settings threshold
+sigma_min: 0.13757067353874633
+sigma_min_enable_randomization_type: false
+sigma_min_randomization_type:  "asymmetric"
+sigma_min_randomization_percent: 0.2
+#
+sigma_max_rand: false
+sigma_max_rand_min: 25 
+sigma_max_rand_max: 60
+sigma_max: 47.95768510805332
+sigma_max_enable_randomization_type: false
+sigma_max_randomization_type: "log"
+sigma_max_randomization_percent: 0.25
+#
+start_blend_rand: false
+start_blend_rand_min: 0.04 # tested recommended settings threshold
+start_blend_rand_max: 0.11 # tested recommended settings threshold
+start_blend: 0.08
+start_blend_enable_randomization_type: false
+start_blend_randomization_type:  "asymmetric"
+start_blend_randomization_percent: 0.1
+#
+end_blend_rand: false
+end_blend_rand_min: 0.4 # tested recommended settings threshold
+end_blend_rand_max: 0.6 # tested recommended settings threshold
+end_blend: 0.5
+end_blend_enable_randomization_type: false
+end_blend_randomization_type:  "asymmetric"
+end_blend_randomization_percent: 0.2
+#
+sharpness_rand: false
+sharpness_rand_min: 0.75 # tested recommended settings threshold
+sharpness_rand_max: 0.95 # tested recommended settings threshold
+sharpness: 0.85 # Note: Visible changes in image between 2-15. Above 15 - notable differences. At 50+ - poor image quality. sharpness not applied above 0.95
+sharpen_variance_threshold: 0.01
+sharpen_last_n_steps: 10
+sharpen_mode: "full" # Options: last_n, full, both
+sharpness_enable_randomization_type: false
+sharpness_randomization_type:  "asymmetric"
+sharpness_randomization_percent: 0.2
+#
+step_progress_mode: "linear" # Options supported (default = "linear"), "exponential", "logarithmic", or "sigmoid". If exponential, uses "exp_power"
+exp_power: 2
+#
+initial_step_size_rand: false
+initial_step_size_rand_min: 0.7 
+initial_step_size_rand_max: 1.0 
+initial_step_size: 0.9
+initial_step_size_enable_randomization_type: false
+initial_step_size_randomization_type: "asymmetric"
+initial_step_size_randomization_percent: 0.2
+#
+final_step_size_rand: false
+final_step_size_rand_min: 0.1
+final_step_size_rand_max: 0.3
+final_step_size: 0.20
+final_step_size_enable_randomization_type: false
+final_step_size_randomization_type:  "asymmetric"
+final_step_size_randomization_percent: 0.2
+#
+step_size_factor_rand: false
+step_size_factor_rand_min: 0.65
+step_size_factor_rand_max: 0.85
+step_size_factor: 0.80814932869181
+step_size_factor_enable_randomization_type: false
+step_size_factor_randomization_type:  "asymmetric"
+step_size_factor_randomization_percent: 0.2
+#
+initial_noise_scale_rand: false
+initial_noise_scale_rand_min: 1.0
+initial_noise_scale_rand_max: 1.5
+initial_noise_scale: 1.25
+initial_noise_scale_enable_randomization_type: false
+initial_noise_scale_randomization_type:  "asymmetric"
+initial_noise_scale_randomization_percent: 0.2
+#
+final_noise_scale_rand: false
+final_noise_scale_rand_min: 0.6
+final_noise_scale_rand_max: 1.0
+final_noise_scale: 0.80
+final_noise_scale_enable_randomization_type: false
+final_noise_scale_randomization_type:  "asymmetric"
+final_noise_scale_randomization_percent: 0.2
+#
+smooth_blend_factor_rand: false
+smooth_blend_factor_rand_min: 6
+smooth_blend_factor_rand_max: 11
+smooth_blend_factor: 9.426004103284665
+smooth_blend_factor_enable_randomization_type: false
+smooth_blend_factor_randomization_type:  "asymmetric"
+smooth_blend_factor_randomization_percent: 0.2
+#
+noise_scale_factor_rand: false
+noise_scale_factor_rand_min: 0.75
+noise_scale_factor_rand_max: 0.95
+noise_scale_factor: 0.8113992828873163
+noise_scale_factor_enable_randomization_type: false
+noise_scale_factor_randomization_type:  "asymmetric"
+noise_scale_factor_randomization_percent: 0.2
+
+# Experimental settings
+early_stopping_threshold_rand: false
+early_stopping_threshold_rand_min: 0.001
+early_stopping_threshold_rand_max: 0.02
+early_stopping_threshold: 0.06
+early_stopping_method: max  # Options: mean, max, sum
+sigma_variance_scale: 0.1   # *100 = % of current sigma, increase to reduce false early stopping, try 0.07 or 0.10
+safety_minimum_stop_step: 10 # means won't consider until past this step, consider increasing this to increase minimum steps to process the image
+recent_change_convergence_delta: 0.6 # this is the change between mean/max variable changes between sigmas. Keep this relatively low. This contributes directly to when we stop.
+#min_visual_sigma: 50            # Increase from 10 to push later into the denoising sequence
+early_stopping_threshold_enable_randomization_type: false
+early_stopping_threshold_randomization_type: "asymmetric"
+early_stopping_threshold_randomization_percent: 0.2

sd_simple_kes_v2/plot_sigma_sequence.py

@@ -0,0 +1,42 @@
+import matplotlib.pyplot as plt
+import numpy as np
+import os
+
+def plot_sigma_sequence(sigs, stopping_index, log_filename, save_directory="modules/sd_simple_kes_v2/image_generation_data", show_plot=False):
+        """
+        Plot the sigma sequence and mark the early stopping point.
+
+        Parameters:
+        - sigs: The sigma tensor or numpy array (can be truncated if stopping early).
+        - stopping_index: The step index where early stopping was triggered.
+        - log_filename: The filename of the generation log (used to match the graph name).
+        - save_directory: The folder where the plot should be saved.
+        - show_plot: Set to True to display the plot interactively.
+        """
+
+        # Extract base name to match log filename
+        base_filename = os.path.splitext(os.path.basename(log_filename))[0]
+        graph_filename = f"{base_filename}_sigma_plot.png"
+        graph_path = os.path.join(save_directory, graph_filename)
+
+        # Prepare sigma sequence for plotting
+        sigs_np = sigs.cpu().numpy() if hasattr(sigs, 'cpu') else np.array(sigs)
+        x = np.arange(len(sigs_np))
+
+        # Plotting
+        plt.figure(figsize=(10, 6))
+        plt.plot(x, sigs_np, label='Sigma Sequence', marker='o')
+        plt.axvline(x=stopping_index, color='red', linestyle='--', label=f'Stopping Point: {stopping_index}')
+        plt.xlabel('Step Index')
+        plt.ylabel('Sigma Value')
+        plt.title('Sigma Sequence with Early Stopping Point')
+        plt.legend()
+        plt.grid(True)
+        plt.tight_layout()
+        plt.savefig(graph_path)
+
+        if show_plot:
+            plt.show()
+
+        plt.close()
+        return graph_path

sd_simple_kes_v2/setup.txt

@@ -0,0 +1,3 @@
+remove the appended name "_v2" from all files/folders and place into the modules folder of A1111/Forge.
+
+This version is experimental.

sd_simple_kes_v2/simple_kes_v2.py

@@ -0,0 +1,785 @@
+import torch
+import logging
+from modules.sd_simple_kes_v2.get_sigmas import get_sigmas_karras, get_sigmas_exponential 
+from modules.sd_simple_kes_v2.validate_config import validate_config
+from modules.sd_simple_kes_v2.plot_sigma_sequence import plot_sigma_sequence
+import os
+import yaml
+import random
+from datetime import datetime
+import warnings
+import math
+from typing import Optional
+import json
+import numpy as np
+
+
+
+def simple_kes_scheduler_v22(n: int, sigma_min: float, sigma_max: float, device: torch.device) -> torch.Tensor:
+    scheduler = SimpleKEScheduler(n=n, sigma_min=sigma_min, sigma_max=sigma_max, device=device)
+    return scheduler()
+
+
+    
+class SharedLogger:
+    def __init__(self, debug=False):
+        self.debug = debug
+        self.log_buffer = []
+
+    def log(self, message):
+        if self.debug:
+            self.log_buffer.append(message)
+
+    def dump(self):
+        return "\n".join(self.log_buffer)
+
+    
+class SimpleKEScheduler:
+    """
+    SimpleKEScheduler
+    ------------------
+    A hybrid scheduler that combines Karras-style sigma sampling
+    with exponential decay and blending controls. Supports parameterized
+    customization for use in advanced diffusion pipelines.
+
+    Parameters:
+    - steps (int): Number of inference steps.
+    - device (torch.device): Target device (e.g. 'cuda').
+    - config (dict): Scheduler-specific configuration options.
+
+    Usage:
+        scheduler = SimpleKEScheduler(steps=30, device='cuda', config=config_dict)
+        sigmas = scheduler.get_sigmas()
+    """
+    
+    
+    def __init__(self, n: int, sigma_min: Optional[float] = None, sigma_max: Optional[float] = None, device: torch.device = "cpu", logger=None, **kwargs)->torch.Tensor:         
+        self.steps = n if n is not None else 10 
+        self.original_steps = n
+        self.device = torch.device(device if isinstance(device, str) else device)        
+        self.sigma_min = sigma_min
+        self.sigma_max = sigma_max
+        
+        self.RANDOMIZATION_TYPE_ALIASES = {
+            'symmetric': 'symmetric', 'sym': 'symmetric', 's': 'symmetric',
+            'asymmetric': 'asymmetric', 'assym': 'asymmetric', 'a': 'asymmetric',
+            'logarithmic': 'logarithmic', 'log': 'logarithmic', 'l': 'logarithmic',
+            'exponential': 'exponential', 'exp': 'exponential', 'e': 'exponential'
+        }
+
+        
+        # Temporarily hold overrides from kwargs
+        self._overrides = kwargs.copy()        
+        self.config_path = os.path.abspath(os.path.normpath(os.path.join("modules", "sd_simple_kes", "kes_config", "default_config.yaml")))
+        self.config_data = self.load_config()        
+        self.config = self.config_data.copy()
+        self.settings = self.config.copy() 
+                
+        # Apply overrides from kwargs if present
+        for k, v in self._overrides.items():
+            if k in self.settings:
+                self.settings[k] = v
+                setattr(self, k, v)        
+        
+        self.debug = self.settings.get("debug", False)
+        logger = SharedLogger(debug=self.debug)
+        self.logger=logger
+        self.log = self.logger.log
+        validate_config(self.config, logger=self.logger)
+   
+        for key, value in self.settings.items():            
+            setattr(self, key, value)
+            
+        if self.settings.get("global_randomize", False):
+            self.apply_global_randomization()
+        self.settings = self.settings.copy()        
+        
+        self.re_randomizable_keys = [
+            "sigma_min", "sigma_max", "start_blend", "end_blend", "sharpness",
+            "early_stopping_threshold",
+            "initial_step_size", "final_step_size",
+            "initial_noise_scale", "final_noise_scale",
+            "smooth_blend_factor", "step_size_factor", "noise_scale_factor", "rho"
+        ]
+       
+        for key in self.re_randomizable_keys:
+            value = self.settings.get(key)
+            if value is None:
+                raise KeyError(f"[KEScheduler] Missing required setting: {key}")
+            setattr(self, key, value)   
+        
+        self.sigma_variance_threshold = self.settings.get('sharpen_variance_threshold', 0.01)         
+        self.N = self.settings.get('sharpen_last_n_steps', 10)
+        
+        self.initialize_generation_filename()
+        self.relative_converged = False
+        self.max_converged = False
+        self.delta_converged = False
+        self.early_stop_triggered = False
+        
+    def __call__(self):
+        # First pass: Run prepass to determine predicted_stop_step
+        if not self.settings.get('skip_prepass', False):
+            self.prepass_compute_sigmas()  
+            
+        else:
+            # Build sigma sequence directly (without prepass)
+            self.config_values()            
+            self.generate_sigmas_schedule()  
+            self.blend_sigma_sequence(
+                sigs=self.sigs,
+                sigmas_karras=self.sigmas_karras,
+                sigmas_exponential=self.sigmas_exponential,
+                pre_pass = False                
+            )
+        sigmas = self.compute_sigmas()
+        # Safety checks
+        if torch.isnan(sigmas).any():
+            raise ValueError("[SimpleKEScheduler] NaN detected in sigmas")
+        if torch.isinf(sigmas).any():
+            raise ValueError("[SimpleKEScheduler] Inf detected in sigmas")
+        if (sigmas <= 0).all():
+            raise ValueError("[SimpleKEScheduler] All sigma values are <= 0")
+        if (sigmas > 1000).all():
+            raise ValueError("[SimpleKEScheduler] Sigma values are extremely large — might explode the model")
+        # Save logs to file
+        if self.debug:
+            self.save_generation_settings()
+        # Return final sigmas to the scheduler caller
+        return sigmas
+
+    def initialize_generation_filename(self, folder=None, base_name="generation_log", ext="txt"):
+        """
+        Initialize the log filename early so it can be used throughout the process.
+        """
+        if folder is None:
+            folder = self.settings.get('log_save_directory', 'modules/sd_simple_kes/image_generation_data')
+            folder = os.path.abspath(os.path.normpath(folder))
+
+        os.makedirs(folder, exist_ok=True)
+        timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+
+        self.log_filename = os.path.join(folder, f"{base_name}_{timestamp}.{ext}")
+      
+    def save_generation_settings(self):
+        """
+        Save the generation log with configurable directory, base name, and extension.
+
+        Parameters:
+        - folder (str): Optional custom directory to save the log file.
+        - base_name (str): The base name for the file (default is 'generation_log').
+        - ext (str): The file extension to use (default is 'txt').
+        """         
+        with open(self.log_filename, "w", encoding = 'utf-8') as f:
+            for line in self.logger.log_buffer:
+                f.write(f"{line}\n")
+        self.log(f"[SimpleKEScheduler] Generation settings saved to {self.log_filename}")
+            
+        self.logger.log_buffer.clear() 
+    
+    def save_image_plot(self):
+        if self.settings.get('graph_save_enable', False):                        
+            graph_plot = plot_sigma_sequence(
+                sigs[:i + 1],
+                i,
+                self.log_filename,
+                self.settings.get('graph_save_directory', 'modules/sd_simple_kes/image_generation_data'),
+                self.settings.get('graph_save_enable', False)
+            )
+            self.log(f"Sigma sequence plot saved to {graph_plot}")
+    
+    def load_config(self):
+        try:
+            with open(self.config_path, 'r', encoding = 'utf-8') as f:
+                user_config = yaml.safe_load(f)
+                return user_config
+        except FileNotFoundError:
+            self.log(f"Config file not found: {self.config_path}. Using empty config.")
+            return {}
+        except yaml.YAMLError as e:
+            self.log(f"Error loading config file: {e}")
+            return {}
+    
+    def apply_global_randomization(self):
+        """Force randomization for all eligible settings by enabling _rand flags and re-randomizing values."""
+        # First pass: turn on all _rand flags if corresponding _rand_min/_rand_max exists
+        for key in list(self.settings.keys()):
+            if key.endswith("_rand_min") or key.endswith("_rand_max"):
+                base_key = key.rsplit("_rand_", 1)[0]
+                rand_flag_key = f"{base_key}_rand"
+                self.settings[rand_flag_key] = True
+        # Step 2: If global_randomize is active, re-randomize all eligible keys
+        if self.settings.get("global_randomize", False):           
+            if key not in self.settings:
+                raise KeyError(f"[apply_global_randomization] Missing required key: {key}")
+
+            default_val = self.settings[key]
+            randomized_val = self.get_random_or_default(key, default_val)
+            self.settings[key] = randomized_val
+            setattr(self, key, randomized_val)  
+   
+    def get_randomization_type(self, key_prefix):
+        """
+        Retrieves the randomization type for a given key, with fallback to 'asymmetric' if missing.
+        """
+        randomization_type_raw = self.settings.get(f'{key_prefix}_randomization_type', 'asymmetric')
+        randomization_type = self.RANDOMIZATION_TYPE_ALIASES.get(randomization_type_raw.lower(), 'asymmetric')
+        return randomization_type
+
+    def get_randomization_percent(self, key_prefix):
+        """
+        Retrieves the randomization percent for a given key, with fallback to 0.2 if missing.
+        """
+        return self.settings.get(f'{key_prefix}_randomization_percent', 0.2)
+
+   
+    def get_random_between_min_max(self, key_prefix, default_value):
+        """
+        Picks a random value between _rand_min and _rand_max if _rand is True.
+        Otherwise, returns the base value.
+        """
+        randomize_flag = self.settings.get(f'{key_prefix}_rand', False)
+
+        if randomize_flag:
+            rand_min = self.settings.get(f'{key_prefix}_rand_min', default_value)
+            rand_max = self.settings.get(f'{key_prefix}_rand_max', default_value)
+
+            if rand_min == rand_max:
+                self.log(f"[Random Range] {key_prefix}: min and max are equal ({rand_min}). Using single value.")
+                return rand_min
+
+            value = random.uniform(rand_min, rand_max)
+            self.log(f"[Random Range] {key_prefix}: Picked random value {value} between {rand_min} and {rand_max}")
+            return value
+        else:
+            self.log(f"[Random Range] {key_prefix}: Randomization is OFF. Using base value {default_value}")
+            return default_value
+
+    def get_random_by_type(self, key_prefix, default_value):
+        randomization_enabled = self.settings.get(f'{key_prefix}_enable_randomization_type', False)
+
+        if not randomization_enabled:
+            self.log(f"[Randomization Type] {key_prefix}: Randomization type is OFF. Using base value {default_value}")
+            return default_value
+
+        randomization_type = self.get_randomization_type(key_prefix)
+        randomization_percent = self.get_randomization_percent(key_prefix)
+
+        if randomization_type == 'symmetric':
+            rand_min = default_value * (1 - randomization_percent)
+            rand_max = default_value * (1 + randomization_percent)
+            self.log(f"[Symmetric Randomization] {key_prefix}: Range {rand_min} to {rand_max}")            
+
+        elif randomization_type == 'asymmetric':
+            rand_min = default_value * (1 - randomization_percent)
+            rand_max = default_value * (1 + (randomization_percent * 2))
+            self.log(f"[Asymmetric Randomization] {key_prefix}: Range {rand_min} to {rand_max}")
+
+        elif randomization_type == 'logarithmic':
+            rand_min = math.log(default_value * (1 - randomization_percent))
+            rand_max = math.log(default_value * (1 + randomization_percent))
+            value = math.exp(random.uniform(rand_min, rand_max))
+            self.log(f"[Logarithmic Randomization] {key_prefix}: Log-space randomization resulted in {value}")
+            return value
+
+        elif randomization_type == 'exponential':
+            rand_min = default_value * (1 - randomization_percent)
+            rand_max = default_value * (1 + randomization_percent)
+            base_value = random.uniform(rand_min, rand_max)
+            value = math.exp(base_value)
+            self.log(f"[Exponential Randomization] {key_prefix}: Randomized exponential value {value}")
+            return value
+
+        else:
+            self.log(f"[Randomization Type] {key_prefix}: Invalid randomization type {randomization_type}. Using base value.")
+            return default_value
+
+        value = random.uniform(rand_min, rand_max)
+        
+        self.log(f"[Randomization Type] {key_prefix}: Randomized value {value}")
+        return value
+
+    def get_random_or_default(self, key_prefix, default_value):
+        """
+        Selects randomization method based on active flags:
+            - If both enabled → prioritize randomization type (or min/max if you prefer).
+            - If only one enabled → apply that one.
+            - If neither → return default value.
+        """
+        rand_type_enabled = self.settings.get(f'{key_prefix}_enable_randomization_type', False)
+        min_max_enabled = self.settings.get(f'{key_prefix}_rand', False)
+
+        if rand_type_enabled and min_max_enabled:
+            self.log(f"[Randomization Policy] Both min/max and randomization type enabled for {key_prefix}. System will prioritize randomization type.")
+            result_value = self.get_random_by_type(key_prefix, default_value)
+
+        elif rand_type_enabled:
+            result_value = self.get_random_by_type(key_prefix, default_value)
+            self.log(f"[Randomization] {key_prefix}: Applied randomization type. Final value: {result_value}")
+
+        elif min_max_enabled:
+            result_value = self.get_random_between_min_max(key_prefix, default_value)
+            self.log(f"[Randomization] {key_prefix}: Applied min/max randomization. Final value: {result_value}")
+
+        else:
+            result_value = default_value
+            self.log(f"[Randomization] {key_prefix}: No randomization applied. Using default value: {result_value}")
+
+        return result_value
+
+    def blend_sigma_sequence(self, sigs, sigmas_karras, sigmas_exponential, pre_pass=False):
+        self.progress = torch.linspace(0, 1, len(sigmas_karras)).to(self.device)
+        self.blended_sigmas = []
+        self.change_log = []
+        self.relative_converged = False
+        self.max_converged = False
+        self.delta_converged = False
+        self.early_stop_triggered = False
+        
+        """
+        Computes the blended sigma sequence using adaptive step sizes, dynamic blend factors, 
+        and noise scaling across the progress of the diffusion process.
+
+        This method blends sigma values from the Karras and Exponential schedules using 
+        a smooth, progress-dependent interpolation. It applies adaptive scaling based on 
+        step size and noise scale factors to each sigma in the sequence.
+
+        Parameters:
+        -----------
+        sigs : torch.Tensor
+            A pre-allocated tensor where the computed sigma sequence will be stored. 
+            This tensor must match the shape of the sigma schedules.
+        
+        sigmas_karras : torch.Tensor
+            The sigma sequence generated using the Karras schedule.
+        
+        sigmas_exponential : torch.Tensor
+            The sigma sequence generated using the Exponential schedule.
+
+        Returns:
+        --------
+        sigs : torch.Tensor
+            The final blended and scaled sigma sequence.
+
+        Notes:
+        ------
+        - This method is used in both the prepass and final pass of the scheduler.
+        - The progress tensor is computed linearly from 0 to 1 over the length of the sequence.
+        - The method uses class attributes for step size factors, blend factors, and noise scaling.
+        - This method modifies `sigs` in place.
+        """                        
+        for i in range(len(sigs)):
+            if self.step_progress_mode == "linear":
+                progress_value = self.progress[i]
+            elif self.step_progress_mode == "exponential":
+                progress_value = self.progress[i] ** self.settings.get("exp_power", 2)
+            elif self.step_progress_mode == "logarithmic":
+                progress_value = torch.log1p(self.progress[i] * (torch.exp(torch.tensor(1.0)) - 1))
+            elif self.step_progress_mode == "sigmoid":
+                progress_value = 1 / (1 + torch.exp(-12 * (self.progress[i] - 0.5)))
+            else:
+                progress_value = self.progress[i]  # Fallback to linear (previous version used)  
+            dynamic_blend_factor = self.start_blend * (1 - self.progress[i]) + self.end_blend * self.progress[i]
+            smooth_blend = torch.sigmoid((dynamic_blend_factor - 0.5) * self.smooth_blend_factor)
+            noise_scale = self.initial_noise_scale * (1 - self.progress[i]) + self.final_noise_scale * self.progress[i] * self.noise_scale_factor                
+            self.blended_sigma = sigmas_karras[i] * (1 - smooth_blend) + sigmas_exponential[i] * smooth_blend
+            
+                           
+            self.step_size = self.initial_step_size * (1 - progress_value) + self.final_step_size * progress_value * self.step_size_factor  
+            sigs[i] = self.blended_sigma * self.step_size * noise_scale
+           
+            self.change = torch.abs(sigs[i] - sigs[i - 1])
+            self.change_log.append(self.change.item())
+            relative_sigma_progress = (self.blended_sigma - sigs[-1].item()) / self.blended_sigma                                
+            recent_changes = torch.abs(torch.tensor(self.change_log[-5:]))
+            max_change = torch.max(recent_changes).item()                        
+            mean_change = torch.mean(recent_changes).item()
+            #percent_of_threshold = (max_change / self.early_stopping_threshold) * 100                                        
+            self.delta_change = abs(max_change - mean_change)
+            self.blended_sigmas.append(self.blended_sigma.item()) 
+            
+            # Check 1: Relative sigma progress
+            self.relative_converged = relative_sigma_progress < 0.05
+            # Check 2: Max recent sigma change
+            self.max_converged = max_change < self.early_stopping_threshold
+            # Check 3: Max-mean difference converged
+            self.delta_converged = self.delta_change < self.settings.get('recent_change_convergence_delta', 0.02)            
+            
+            if pre_pass:
+                if i >= 2:
+                    sigma_rate = abs(self.blended_sigmas[i] - self.blended_sigmas[i - 1])
+                    previous_sigma_rate = abs(self.blended_sigmas[i - 1] - self.blended_sigmas[i - 2])
+                    if sigma_rate > previous_sigma_rate:
+                        self.log(f"Sigma decline is slowing down → possible plateau at step {i+1}.")
+
+                if i == 0:
+                    self.log("\n--- Starting Pre-Pass Blending ---\n")  
+                    step_label = "Prepass First Step"
+                elif i == len(sigmas_karras) - 1:
+                    step_label = "Prepass Last Step"
+                else:
+                    step_label = None
+
+                if step_label:
+                    self.log(f"[{step_label} - Step {i}/{len(sigs)}] Blended Sigma: {self.blended_sigma:.6f}, Final Sigma: {sigs[i]:.6f}")    
+                    self.log(f"{step_label} Delta Converged: {self.delta_converged} delta_change: {self.delta_change:.6f}, Target Default Settings:{self.recent_change_convergence_delta}")
+                 
+                # Start checking for early stopping after minimum steps
+                if i > self.safety_minimum_stop_step and len(self.change_log) > 10:                  
+                    # Calculate variance and dynamic threshold
+                    self.blended_tensor = torch.tensor(self.blended_sigmas) 
+                    if self.device == 'cpu':
+                        self.sigma_variance = np.var(self.blended_sigmas)
+                    else: 
+                        self.sigma_variance = torch.var(sigs).item()
+
+                    self.min_sigma_threshold = self.sigma_variance * self.settings.get('sigma_variance_scale', 0.05)  # scale factor can be tuned
+                    self.log(f"\n--- Early Stopping Evaluation at Step {i+1} ---")
+                    self.log(f"Current Blended Sigma: {self.blended_sigma:.6f}")
+                    self.log(f"Sigma Variance: {self.sigma_variance:.6f}")
+                    self.log(f"Relative Sigma Progress: {relative_sigma_progress:.6f}")
+                    self.log(f"Max Recent Sigma Change: {max_change:.6f}")
+                    self.log(f"Mean Recent Sigma Change: {mean_change:.6f}")
+                    
+
+                    # Reason for continuing (sigma still too high)
+                    if self.blended_sigma > self.min_sigma_threshold:
+                        self.log(f"Blended Sigma {self.blended_sigma:.6f} exceeds min sigma threshold {self.min_sigma_threshold:.6f} → Continuing.\n")
+                                            
+                    # Start Early Stopping Checks                    
+                    if self.early_stopping_method == "mean":
+                        mean_change = sum(self.change_log) / len(self.change_log)
+                        if mean_change < self.early_stopping_threshold:
+                            skipped_steps = len(sigmas_karras) - (i)
+                            self.log(f"Early stopping triggered by mean at step {i}. Mean change: {mean_change:.6f}. Steps used: {i}/{len(sigmas_karras)}, steps skipped: {skipped_steps}")
+                        self.save_image_plot()                        
+
+                    elif self.early_stopping_method == "max":
+                        #max_change = max(self.change_log)
+                        if max_change < self.early_stopping_threshold:
+                            skipped_steps = len(sigmas_karras) - (i)
+                            self.log(f"Early stopping triggered by mean at step {i}. Mean change: {max_change:.6f}. Steps used: {i}/{len(sigmas_karras)}, steps skipped: {skipped_steps}") 
+                        self.save_image_plot()
+                                                    
+                    elif self.early_stopping_method == "sum":
+                        stable_steps = sum(
+                            1 for j in range(1, len(self.change_log))
+                            if abs(self.change_log[j]) < self.early_stopping_threshold * abs(sigs[j])
+                        )
+                        if stable_steps >= 0.8 * len(self.change_log):
+                            skipped_steps = len(sigmas_karras) - (i)
+                            self.log(f"Early stopping triggered by sum at step {i}. Stable steps: {stable_steps}/{len(self.change_log)}. Steps used: {i}/{len(sigmas_karras)}, steps skipped: {skipped_steps}")
+                        self.save_image_plot()                        
+                            
+                if self.relative_converged and self.max_converged and self.delta_converged: 
+                    self.early_stop_triggered = True                    
+                    self.log(f"\n--- Early Stopping Evaluation at Step {i+1} ---")
+                    self.log(f"Relative Sigma Progress: {relative_sigma_progress:.6f}")
+                    self.log(f"Max Recent Sigma Change: {max_change:.6f}")
+                    self.log(f"Mean Recent Sigma Change: {mean_change:.6f}")
+                    self.log(f"Delta Change: {delta_change:.6f} (Target: {self.settings.get('recent_change_convergence_delta', 0.02)})")                        
+                    self.log(f"Early stopping criteria met at step {i+1} based on all convergence checks.")
+                    self.predicted_stop_step = i
+                    #self.steps = self.predicted_stop_step
+                    break        
+            
+        # === Final Pass ===
+        
+        #for i in range(len(sigmas_karras)):
+        for i in range(len(sigs)):
+            if not pre_pass:
+                self.log("\n--- Starting Final Pass Blending ---\n")
+                
+                if i == 0:
+                    step_label = "First Step"
+                elif i == len(sigmas_karras) // 2:
+                    step_label = "Middle Step"
+                elif i == len(sigmas_karras) - 1:
+                    step_label = "Last Step"
+                else:
+                    step_label = None
+                
+                dynamic_blend_factor = self.start_blend * (1 - self.progress[i]) + self.end_blend * self.progress[i]
+                smooth_blend = torch.sigmoid((dynamic_blend_factor - 0.5) * self.smooth_blend_factor)            
+                noise_scale = self.initial_noise_scale * (1 - self.progress[i]) + self.final_noise_scale * self.progress[i] * self.noise_scale_factor                        
+                blended_sigma = sigmas_karras[i] * (1 - smooth_blend) + sigmas_exponential[i] * smooth_blend
+                
+
+                sigs[i] = blended_sigma * self.step_size * noise_scale
+                self.blended_sigmas.append(blended_sigma.item())
+                
+                if step_label:
+                    if not pre_pass:  # Only log detailed steps in the final pass
+                        self.log("\n" + "=" * 10 + "\n[Start of Sigma Sequence Logging]\n" + "=" * 10)
+                        self.log(f"[{step_label} - Step {i}/{len(sigmas_karras)}]"
+                                 f"\nStep Size: {self.step_size:.6f}"
+                                 f"\nDynamic Blend Factor: {dynamic_blend_factor:.6f}"
+                                 f"\nNoise Scale: {noise_scale:.6f}"
+                                 f"\nSmooth Blend: {smooth_blend:.6f}"
+                                 f"\nBlended Sigma: {blended_sigma:.6f}"
+                                 f"\nFinal Sigma: {sigs[i]:.6f}")
+                        self.log("\n" + "=" * 10 + "\n[End of Sigma Sequence Logging]\n" + "=" * 10)
+
+                    elif pre_pass:  # Optional: Log a simple summary in the prepass
+                        self.log(f"[Prepass {step_label} - Step {i}/{len(sigmas_karras)}] "
+                                 f"Blended Sigma: {blended_sigma:.6f}, Final Sigma: {sigs[i]:.6f}")
+                
+                if i == 0:
+                    step_label = "First Step"
+                elif i == len(sigmas_karras) - 1:
+                    step_label = "Last Step"
+                else:
+                    step_label = None
+
+                if step_label:
+                    self.log("\n" + "=" * 10 + "\n[Start of Sigma Sequence Logging]\n" + "=" * 10)
+                    self.log(f"[{step_label} - Step {i}/{len(sigs)}]"
+                             f"\nStep Size: {self.step_size:.6f}"
+                             f"\nBlended Sigma: {blended_sigma:.6f}"
+                             f"\nFinal Sigma: {sigs[i]:.6f}")
+                    self.log("\n" + "=" * 10 + "\n[End of Sigma Sequence Logging]\n" + "=" * 10)
+
+                if i > 0:
+                    self.change = torch.abs(sigs[i] - sigs[i - 1])
+                    self.change_log.append(self.change.item())
+
+                # Early Stopping Evaluation
+                if i > self.safety_minimum_stop_step and len(self.change_log) > 5:
+                    #relative_sigma_progress = (blended_sigma - self.sigs[-1].item()) / blended_sigma                
+                    final_target_sigma = sigmas_karras[-1].item()  # or use min(self.sigmas) if preferred
+                    #relative_sigma_progress = (blended_sigma - final_target_sigma) / blended_sigma  
+                    if blended_sigma != 0:
+                        relative_sigma_progress = (blended_sigma - final_target_sigma) / blended_sigma
+                    else:
+                        relative_sigma_progress = 0  # Assume fully converged if blended_sigma is 0                                    
+                    # Optional: Show variance but no need to stop on it
+                    self.sigma_variance = torch.var(sigs).item() if self.device != 'cpu' else np.var(self.blended_sigmas)
+                    self.log(f"Sigma Variance: {self.sigma_variance:.6f}")
+        
+        if pre_pass and self.early_stop_triggered:
+            return sigs[:self.predicted_stop_step]  # Return only the usable sequence        
+        else:
+            return sigs
+   
+    def generate_sigmas_schedule(self):
+        """
+        Generates the sigma schedules required for the hybrid blending process.
+
+        The Karras and Exponential sigma sequences are created to provide two distinct 
+        noise scaling strategies:
+        - The Karras sequence offers a more aggressive noise decay, commonly used in 
+          modern schedulers for improved image quality and denoising stability.
+        - The Exponential sequence provides a traditional log-space noise schedule.
+
+        These two sequences are dynamically blended in later steps using progress-dependent 
+        weights to produce a custom sigma path that combines the advantages of both approaches.
+
+        This blending process is critical to the scheduler's ability to:
+        - Adapt noise scaling across steps.
+        - Control the sharpness and smoothness of transitions.
+        - Support early stopping based on sigma convergence patterns.
+
+        These sigma sequences must be regenerated in both the prepass (for early stopping detection) 
+        and the final pass (for polished sigma application), ensuring both passes are synchronized 
+        with the current step count and randomization settings.
+        """
+
+        
+        self.sigmas_karras = get_sigmas_karras(n=self.steps, sigma_min=self.sigma_min, sigma_max=self.sigma_max, rho=self.rho, device=self.device)
+        self.sigmas_exponential = get_sigmas_exponential(n=self.steps, sigma_min=self.sigma_min, sigma_max=self.sigma_max, device=self.device)
+        target_length = min(len(self.sigmas_karras), len(self.sigmas_exponential))  
+        self.sigmas_karras = self.sigmas_karras[:target_length]
+        self.sigmas_exponential = self.sigmas_exponential[:target_length]
+                  
+        self.log(f"Generated sigma sequences. Karras: {self.sigmas_karras}, Exponential: {self.sigmas_exponential}")
+        
+        if self.sigmas_karras is None:
+            raise ValueError(f"Sigmas Karras:{self.sigmas_karras} Failed to generate or assign sigmas correctly.")
+        if self.sigmas_exponential is None:    
+            raise ValueError(f"Sigmas Exponential: {self.sigmas_exponential} Failed to generate or assign sigmas correctly.")
+            self.sigmas_karras = torch.zeros(self.steps).to(self.device)
+            self.sigmas_exponential = torch.zeros(self.steps).to(self.device)   
+        try:
+            pass
+        except Exception as e:
+            self.log(f"Error generating sigmas: {e}") 
+        
+        if len(self.sigmas_karras) < len(self.sigmas_exponential):
+            # Pad `sigmas_karras` with the last value
+            padding_karras = torch.full((len(self.sigmas_exponential) - len(self.sigmas_karras),), self.sigmas_karras[-1]).to(self.sigmas_karras.self.device)
+            self.sigmas_karras = torch.cat([self.sigmas_karras, padding_karras])
+        elif len(self.sigmas_karras) > len(self.sigmas_exponential):
+            # Pad `sigmas_exponential` with the last value
+            padding_exponential = torch.full((len(self.sigmas_karras) - len(self.sigmas_exponential),), self.sigmas_exponential[-1]).to(self.sigmas_exponential.device)
+            self.sigmas_exponential = torch.cat([self.sigmas_exponential, padding_exponential])
+       
+        # Now it's safe to compute sigs
+        start = math.log(self.sigma_max)
+        end = math.log(self.sigma_min)
+        self.sigs = torch.linspace(start, end, self.steps, device=self.device).exp()       
+
+        # Ensure sigs contain valid values before using them
+        if torch.any(self.sigs > 0):  
+            self.sigma_min, self.sigma_max = self.sigs[self.sigs > 0].min(), self.sigs.max()            
+        else:
+            # If sigs are all invalid, set a safe fallback
+            self.sigma_min, self.sigma_max = self.min_threshold, self.min_threshold              
+            self.log(f"Debugging Warning: No positive sigma values found! Setting fallback sigma_min={self.sigma_min}, sigma_max={self.sigma_max}")
+        
+        return self.sigmas_karras, self.sigmas_exponential, self.sigs
+    
+    def config_values(self):        
+        
+        
+        #Ensures sigma_min is always less than sigma_max for edge cases       
+        if self.sigma_min >= self.sigma_max:
+            correction_factor = random.uniform(0.01, 0.99)
+            old_sigma_min = self.sigma_min
+            self.sigma_min = self.sigma_max * correction_factor
+            self.log(f"[Correction] sigma_min ({old_sigma_min}) was >= sigma_max ({self.sigma_max}). Adjusted sigma_min to {self.sigma_min} using correction factor {correction_factor}.")
+
+        self.log(f"Final sigmas: sigma_min={self.sigma_min}, sigma_max={self.sigma_max}")
+        
+        # Other configs
+        self.sharpen_mode = self.settings.get('sharpen_mode', 'full')
+        
+        if self.sigma_auto_enabled:
+            if self.sigma_auto_mode not in ["sigma_min", "sigma_max"]:
+                raise ValueError(f"[Config Error] Invalid sigma_auto_mode: {self.sigma_auto_mode}. Must be 'sigma_min' or 'sigma_max'.")
+
+            if self.sigma_auto_mode == "sigma_min":
+                self.sigma_min = self.sigma_max / self.sigma_scale_factor
+                self.log(f"[Auto Sigma Min] sigma_min set to {self.sigma_min} using scale factor {self.sigma_scale_factor}")
+
+            elif self.sigma_auto_mode == "sigma_max":
+                self.sigma_max = self.sigma_min * self.sigma_scale_factor
+                self.log(f"[Auto Sigma Max] sigma_max set to {self.sigma_max} using scale factor {self.sigma_scale_factor} and using a multiplier of {sigma_max_multipier} to account for smoother transitions")
+
+        # Always apply min_threshold AFTER auto scaling
+        self.min_threshold = random.uniform(1e-5, 5e-5)
+
+        if self.sigma_min < self.min_threshold:
+            self.log(f"[Threshold Enforcement] sigma_min was too low: {self.sigma_min} < min_threshold {self.min_threshold}")
+            self.sigma_min = self.min_threshold
+
+        if self.sigma_max < self.min_threshold:
+            self.log(f"[Threshold Enforcement] sigma_max was too low: {self.sigma_max} < min_threshold {self.min_threshold}")
+            self.sigma_max = self.min_threshold
+        
+        self.early_stopping_method = self.settings.get("early_stopping_method", "mean")
+        valid_methods = ['mean', 'max', 'sum']
+        if self.early_stopping_method not in valid_methods:
+            self.log(f"[Config Correction] Invalid early_stopping_method: {self.early_stopping_method}. Defaulting to 'mean'.")
+            self.early_stopping_method = 'mean'
+       
+    def prepass_compute_sigmas(self, skip_prepass = False)->torch.Tensor:   
+        if self.steps is None:
+            raise ValueError("Number of steps must be provided.")
+        if isinstance(self.device, str):
+            self.device = torch.device(self.device)
+        self.config_values()        
+        self.generate_sigmas_schedule()
+         
+        self.predicted_stop_step = self.steps if None else self.original_steps
+        if self.N > len(self.sigs):
+            self.N = len(self.sigs)
+            self.log(f"[Sharpening Notice] Requested last {self.N} steps exceeds sequence length. Using entire sequence instead.")
+        self.min_visual_sigma = self.settings.get('min_visual_sigma', 10)
+        self.visual_sigma = max(0.8, self.sigma_min * self.min_visual_sigma)
+        self.safety_minimum_stop_step = self.settings.get('safety_minimum_stop_step', 10)
+        self.blend_sigma_sequence(sigs = self.sigs, sigmas_karras=self.sigmas_karras, sigmas_exponential=self.sigmas_exponential, pre_pass = True)        
+        if torch.isnan(self.sigs).any() or torch.isinf(self.sigs).any():
+            raise ValueError("Invalid sigma values detected (NaN or Inf).")
+        final_steps = self.sigs[:self.predicted_stop_step].to(self.device) 
+        # Store the results for later use in compute_sigmas
+        self.final_steps = final_steps
+        self.final_sigmas_karras = self.sigmas_karras
+        self.final_sigmas_exponential = self.sigmas_exponential        
+        self.log(f" Final Steps = {self.final_steps}. Predicted_stop_step = {self.predicted_stop_step}. Original requested steps = {self.steps}")
+        self.log(f"final sigmas karras: {self.final_sigmas_karras}")           
+            
+    
+    def compute_sigmas(self)->torch.Tensor:  
+        """
+        Scheduler function that blends sigma sequences using Karras and Exponential methods with adaptive parameters.
+
+        Parameters:
+            n (int): Number of steps.
+            sigma_min (float): Minimum sigma value.
+            sigma_max (float): Maximum sigma value.
+            device (torch.device): The device on which to perform computations (e.g., 'cuda' or 'cpu').
+            start_blend (float): Initial blend factor for dynamic blending.
+            end_bend (float): Final blend factor for dynamic blending.
+            sharpen_factor (float): Sharpening factor to be applied adaptively.
+            early_stopping_threshold (float): Threshold to trigger early stopping.            
+            initial_step_size (float): Initial step size for adaptive step size calculation.
+            final_step_size (float): Final step size for adaptive step size calculation.
+            initial_noise_scale (float): Initial noise scale factor.
+            final_noise_scale (float): Final noise scale factor.
+            step_size_factor: Adjust to compensate for oversmoothing
+            noise_scale_factor: Adjust to provide more variation
+            
+        Returns:
+            torch.Tensor: A tensor of blended sigma values.
+        """  
+        acceptable_keys = [
+            "sigma_min", "sigma_max", "start_blend", "end_blend", "sharpness",
+            "early_stopping_threshold", "initial_step_size",
+            "final_step_size", "initial_noise_scale", "final_noise_scale",
+            "smooth_blend_factor", "step_size_factor", "noise_scale_factor", "rho"
+        ]
+        
+        for key in acceptable_keys:
+            default_val = self.settings[key]
+            value = self.get_random_or_default(key, default_val)
+            setattr(self, key, value)     
+            
+        self.log(f"Using device: {self.device}")        
+        self.config_values() 
+        self.generate_sigmas_schedule() 
+        if hasattr(self, 'final_sigmas_karras'):
+            self.sigs = torch.zeros_like(self.final_sigmas_karras).to(self.device)        
+        else:
+            self.sigs = torch.zeros_like(self.sigmas_karras).to(self.device)
+         
+         
+        #self.blend_sigma_sequence(sigs=self.sigs, sigmas_karras=self.sigmas_karras, sigmas_exponential=self.sigmas_exponential, pre_pass = False)
+        self.blend_sigma_sequence(
+            sigs=self.sigs,
+            sigmas_karras=self.final_sigmas_karras if hasattr(self, 'final_sigmas_karras') else self.sigmas_karras,
+            sigmas_exponential=self.final_sigmas_exponential if hasattr(self, 'final_sigmas_exponential') else self.sigmas_exponential,
+            pre_pass=False
+        )
+        self.sigma_variance = torch.var(self.sigs).item()          
+        if self.sharpen_mode in ['last_n', 'both']:
+            if self.sigma_variance < self.sigma_variance_threshold:
+                # Apply full sharpening
+                self.sharpen_mask = torch.where(self.sigs < self.sigma_min * 1.5, self.sharpness, 1.0).to(self.device)
+                sharpen_indices = torch.where(self.sharpen_mask < 1.0)[0].tolist()
+                self.sigs = self.sigs * self.sharpen_mask
+                self.log(f"[Sharpen Mask] Full sharpening applied (low variance). Steps: {sharpen_indices}")
+            else:
+                # Apply sharpening only to the last N steps
+                recent_sigs = self.sigs[-self.N:]
+                sharpen_mask = torch.where(recent_sigs < self.sigma_min * 1.5, self.sharpness, 1.0).to(self.device)
+                sharpen_indices = torch.where(sharpen_mask < 1.0)[0].tolist()
+                self.sigs[-self.N:] = recent_sigs * sharpen_mask
+
+                # Now loop per step if desired (safely inside this block)
+                for j in range(len(self.sigs) - self.N, len(self.sigs)):
+                    if self.sigs[j] < self.sigma_min * 1.5:
+                        old_value = self.sigs[j].item()
+                        self.sigs[j] = self.sigs[j] * self.sharpness
+                        self.log(f"[Sharpening] Step {j+1}: Applied sharpening. Sigma changed from {old_value:.6f} to {self.sigs[j].item():.6f}")
+                    else:
+                        self.log(f"[Sharpening] Step {j+1}: No sharpening applied. Sigma: {self.sigs[j].item():.6f}")
+
+        if self.sharpen_mode in ['full', 'both']:
+            # Optional: Additional full sharpening (if needed)
+            self.sharpen_mask = torch.where(self.sigs < self.sigma_min * 1.5, self.sharpness, 1.0).to(self.device)
+            sharpen_indices = torch.where(self.sharpen_mask < 1.0)[0].tolist()
+            self.sigs = self.sigs * self.sharpen_mask
+            self.log(f"[Sharpen Mask] Full sharpening applied at steps: {sharpen_indices}")
+
+        #self.log(f"[DEBUG]Final Output: Skip Prepass: {self.skip_prepass}. Original requested steps: {self.original_steps}. Self.steps = {self.steps} for tensor sigs: {self.sigs})")
+        return self.sigs.to(self.device)

sd_simple_kes_v2/validate_config.py

@@ -0,0 +1,88 @@
+from typing import Optional, Dict, Any
+
+RANDOMIZATION_TYPE_ALIASES = {
+    # Asymmetric
+    'asymmetric': 'asymmetric', 'assym': 'asymmetric', 'a': 'asymmetric', 'asym': 'asymmetric', 'A': 'asymmetric',
+    # Symmetric
+    'symmetric': 'symmetric', 'sym': 'symmetric', 's': 'symmetric', 'S': 'symmetric',
+    # Logarithmic
+    'logarithmic': 'logarithmic', 'log': 'logarithmic', 'l': 'logarithmic', 'L': 'logarithmic',
+    # Exponential
+    'exponential': 'exponential', 'exp': 'exponential', 'e': 'exponential', 'E': 'exponential',
+}
+
+DEFAULT_RANDOMIZATION_TYPE = 'asymmetric'
+DEFAULT_RANDOMIZATION_PERCENT = 0.2
+
+# Base default values
+BASE_DEFAULTS = {
+    'sigma_min': 0.05,
+    'sigma_max': 27.5,
+    'start_blend': 0.1,
+    'end_blend': 0.5,
+    'sharpness': 1.0,
+    'early_stopping_threshold': 0.01,
+    'initial_step_size': 0.9,
+    'final_step_size': 0.2,
+    'initial_noise_scale': 1.25,
+    'final_noise_scale': 0.8,
+    'smooth_blend_factor': 9.0,
+    'step_size_factor': 0.8,
+    'noise_scale_factor': 0.8,
+    'rho': 8.0
+}
+
+def validate_config(config: Dict[str, Any], logger: Optional[Any] = None) -> Dict[str, Any]:
+    updated_config = config.copy()
+
+    def log(message):
+        if logger:
+            logger.log(message)
+        else:
+            print(message)
+
+    # Step 1: Set all base defaults if missing
+    for key, base_value in BASE_DEFAULTS.items():
+        if key not in updated_config:
+            updated_config[key] = base_value
+            log(f"[Config Correction] {key} missing. Set to base default: {base_value}")
+
+        # Ensure _rand flag exists and is a boolean
+        rand_flag = f"{key}_rand"
+        if rand_flag not in updated_config or not isinstance(updated_config.get(rand_flag), bool):
+            updated_config[rand_flag] = False
+            log(f"[Config Correction] {rand_flag} missing or invalid. Set to False.")
+
+        # Ensure _enable_randomization_type flag exists and is a boolean
+        randomization_flag = f"{key}_enable_randomization_type"
+        if randomization_flag not in updated_config or not isinstance(updated_config.get(randomization_flag), bool):
+            updated_config[randomization_flag] = False
+            log(f"[Config Correction] {randomization_flag} missing or invalid. Set to False.")
+
+        # Ensure randomization_type exists
+        randomization_type_key = f"{key}_randomization_type"
+        if randomization_type_key not in updated_config:
+            updated_config[randomization_type_key] = DEFAULT_RANDOMIZATION_TYPE
+            log(f"[Config Correction] {randomization_type_key} missing. Set to '{DEFAULT_RANDOMIZATION_TYPE}'.")
+
+        # Ensure randomization_percent exists
+        randomization_percent_key = f"{key}_randomization_percent"
+        if randomization_percent_key not in updated_config:
+            updated_config[randomization_percent_key] = DEFAULT_RANDOMIZATION_PERCENT
+            log(f"[Config Correction] {randomization_percent_key} missing. Set to {DEFAULT_RANDOMIZATION_PERCENT}.")
+
+        # Ensure _rand_min and _rand_max exist
+        min_key = f"{key}_rand_min"
+        max_key = f"{key}_rand_max"
+        percent = updated_config[randomization_percent_key]
+
+        if min_key not in updated_config:
+            updated_config[min_key] = updated_config[key] * (1 - percent)
+            log(f"[Config Correction] {min_key} missing. Auto-calculated from base.")
+
+        if max_key not in updated_config:
+            updated_config[max_key] = updated_config[key] * (1 + percent)
+            log(f"[Config Correction] {max_key} missing. Auto-calculated from base.")
+
+    log("[Config Validation] Config validated and missing values filled successfully.")
+    return updated_config