Upload sd_simple_kes_v1 using SD-Hub

sd_simple_kes_v1/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_v1/image_generation_data/generation_log_20250706_075558.txt

@@ -0,0 +1,32 @@
+[Config Validation] Config validated and missing values filled successfully.
+[Randomization] sigma_min: No randomization applied. Using default value: 0.13757067353874633
+[Random Range] sigma_max: Picked random value 40.47247420824197 between 10 and 50
+[Randomization] sigma_max: Applied min/max randomization. Final value: 40.47247420824197
+[Randomization] start_blend: No randomization applied. Using default value: 0.10237033381422371
+[Randomization] end_blend: No randomization applied. Using default value: 0.5627048166151302
+[Randomization] sharpness: No randomization applied. Using default value: 0.9070742264431869
+[Randomization] early_stopping_threshold: No randomization applied. Using default value: 0.01
+[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
+[Random Range] rho: Picked random value 5.3338640899006275 between 5.0 and 10.0
+[Randomization] rho: Applied min/max randomization. Final value: 5.3338640899006275
+[Auto Sigma Min] sigma_min set to 0.20236237104120985 using scale factor 200
+Using device: cuda
+Final sigmas: sigma_min=0.20236237347126007, sigma_max=40.47247314453125
+Generated sigma sequences. Karras: tensor([40.4725, 36.0006, 31.9388, 28.2574, 24.9286, 21.9256, 19.2235, 16.7984,
+        14.6280, 12.6912, 10.9681,  9.4401,  8.0898,  6.9009,  5.8579,  4.9469,
+         4.1545,  3.4684,  2.8774,  2.3710,  1.9395,  1.5741,  1.2668,  1.0101,
+         0.7973,  0.6225,  0.4802,  0.3656,  0.2742,  0.2024,  0.0000],
+       device='cuda:0'), Exponential: tensor([40.4725, 33.7143, 28.0846, 23.3949, 19.4884, 16.2342, 13.5234, 11.2652,
+         9.3841,  7.8171,  6.5118,  5.4244,  4.5187,  3.7641,  3.1356,  2.6120,
+         2.1758,  1.8125,  1.5099,  1.2577,  1.0477,  0.8728,  0.7270,  0.6056,
+         0.5045,  0.4203,  0.3501,  0.2916,  0.2429,  0.2024,  0.0000],
+       device='cuda:0')
+[Progress Initialized] Created progress tensor with 30 steps (excluding terminal step) on device: cuda
+[Initialization] Pre-allocated empty sigma sequence with shape: torch.Size([30]) on device: cuda
+[Sharpen Mask] Sharpening applied at steps: [23, 24, 25, 26, 27, 28, 29, 30]

sd_simple_kes_v1/image_generation_data/generation_log_20250706_084556.txt

@@ -0,0 +1,24 @@
+[Config Validation] Config validated and missing values filled successfully.
+[Randomization] sigma_min: No randomization applied. Using default value: 0.13757067353874633
+[Random Range] sigma_max: Picked random value 20.31486888381647 between 10 and 50
+[Randomization] sigma_max: Applied min/max randomization. Final value: 20.31486888381647
+[Randomization] start_blend: No randomization applied. Using default value: 0.10237033381422371
+[Randomization] end_blend: No randomization applied. Using default value: 0.5627048166151302
+[Randomization] sharpness: No randomization applied. Using default value: 0.9070742264431869
+[Randomization] early_stopping_threshold: No randomization applied. Using default value: 0.01
+[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
+[Random Range] rho: Picked random value 6.341474071879316 between 5.0 and 10.0
+[Randomization] rho: Applied min/max randomization. Final value: 6.341474071879316
+[Auto Sigma Min] sigma_min set to 0.10157434441908235 using scale factor 200
+Using device: cuda
+Final sigmas: sigma_min=0.1015743613243103, sigma_max=20.31486701965332
+Generated sigma sequences. Karras: tensor([20.3149, 14.9509, 10.8332,  7.7153,  5.3903,  3.6859,  2.4600,  1.5972,  1.0048,  0.6094,  0.3541,  0.1956,  0.1016,  0.0000], device='cuda:0'), Exponential: tensor([20.3149, 13.0636,  8.4006,  5.4020,  3.4738,  2.2338,  1.4365,  0.9237,  0.5940,  0.3820,  0.2456,  0.1580,  0.1016,  0.0000], device='cuda:0')
+[Progress Initialized] Created progress tensor with 13 steps (excluding terminal step) on device: cuda
+[Initialization] Pre-allocated empty sigma sequence with shape: torch.Size([13]) on device: cuda
+[Sharpen Mask] Sharpening applied at steps: [10, 11, 12, 13]

sd_simple_kes_v1/image_generation_data/generation_log_20250706_084826.txt

@@ -0,0 +1,24 @@
+[Config Validation] Config validated and missing values filled successfully.
+[Randomization] sigma_min: No randomization applied. Using default value: 0.13757067353874633
+[Random Range] sigma_max: Picked random value 47.511735883659846 between 10 and 50
+[Randomization] sigma_max: Applied min/max randomization. Final value: 47.511735883659846
+[Randomization] start_blend: No randomization applied. Using default value: 0.10237033381422371
+[Randomization] end_blend: No randomization applied. Using default value: 0.5627048166151302
+[Randomization] sharpness: No randomization applied. Using default value: 0.9070742264431869
+[Randomization] early_stopping_threshold: No randomization applied. Using default value: 0.01
+[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
+[Random Range] rho: Picked random value 5.411802739400299 between 5.0 and 10.0
+[Randomization] rho: Applied min/max randomization. Final value: 5.411802739400299
+[Auto Sigma Min] sigma_min set to 0.23755867941829922 using scale factor 200
+Using device: cuda
+Final sigmas: sigma_min=0.23755867779254913, sigma_max=47.51173400878906
+Generated sigma sequences. Karras: tensor([47.5117, 35.5816, 26.2156, 18.9651, 13.4400,  9.3042,  6.2706,  4.0968,  2.5811,  1.5574,  0.8921,  0.4793,  0.2376,  0.0000], device='cuda:0'), Exponential: tensor([47.5117, 30.5526, 19.6470, 12.6341,  8.1244,  5.2244,  3.3596,  2.1604,  1.3893,  0.8934,  0.5745,  0.3694,  0.2376,  0.0000], device='cuda:0')
+[Progress Initialized] Created progress tensor with 13 steps (excluding terminal step) on device: cuda
+[Initialization] Pre-allocated empty sigma sequence with shape: torch.Size([13]) on device: cuda
+[Sharpen Mask] Sharpening applied at steps: [10, 11, 12, 13]

sd_simple_kes_v1/image_generation_data/generation_log_20250706_094358.txt

@@ -0,0 +1,24 @@
+[Config Validation] Config validated and missing values filled successfully.
+[Randomization] sigma_min: No randomization applied. Using default value: 0.13757067353874633
+[Random Range] sigma_max: Picked random value 22.70747556206838 between 10 and 50
+[Randomization] sigma_max: Applied min/max randomization. Final value: 22.70747556206838
+[Randomization] start_blend: No randomization applied. Using default value: 0.10237033381422371
+[Randomization] end_blend: No randomization applied. Using default value: 0.5627048166151302
+[Randomization] sharpness: No randomization applied. Using default value: 0.9070742264431869
+[Randomization] early_stopping_threshold: No randomization applied. Using default value: 0.01
+[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
+[Random Range] rho: Picked random value 7.114235966440336 between 5.0 and 10.0
+[Randomization] rho: Applied min/max randomization. Final value: 7.114235966440336
+[Auto Sigma Min] sigma_min set to 0.11353737781034191 using scale factor 200
+Using device: cuda
+Final sigmas: sigma_min=0.11353737860918045, sigma_max=22.707477569580078
+Generated sigma sequences. Karras: tensor([22.7075, 16.5162, 11.8351,  8.3430,  5.7759,  3.9193,  2.6007,  1.6829,  1.0586,  0.6447,  0.3783,  0.2126,  0.1135,  0.0000], device='cuda:0'), Exponential: tensor([22.7075, 14.6021,  9.3900,  6.0383,  3.8829,  2.4969,  1.6057,  1.0325,  0.6640,  0.4270,  0.2746,  0.1766,  0.1135,  0.0000], device='cuda:0')
+[Progress Initialized] Created progress tensor with 13 steps (excluding terminal step) on device: cuda
+[Initialization] Pre-allocated empty sigma sequence with shape: torch.Size([13]) on device: cuda
+[Sharpen Mask] Sharpening applied at steps: [10, 11, 12, 13]

sd_simple_kes_v1/image_generation_data/generation_log_20250706_094514.txt

@@ -0,0 +1,24 @@
+[Config Validation] Config validated and missing values filled successfully.
+[Randomization] sigma_min: No randomization applied. Using default value: 0.13757067353874633
+[Random Range] sigma_max: Picked random value 30.093752214132895 between 10 and 50
+[Randomization] sigma_max: Applied min/max randomization. Final value: 30.093752214132895
+[Randomization] start_blend: No randomization applied. Using default value: 0.10237033381422371
+[Randomization] end_blend: No randomization applied. Using default value: 0.5627048166151302
+[Randomization] sharpness: No randomization applied. Using default value: 0.9070742264431869
+[Randomization] early_stopping_threshold: No randomization applied. Using default value: 0.01
+[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
+[Random Range] rho: Picked random value 5.278771579706032 between 5.0 and 10.0
+[Randomization] rho: Applied min/max randomization. Final value: 5.278771579706032
+[Auto Sigma Min] sigma_min set to 0.15046876107066448 using scale factor 200
+Using device: cuda
+Final sigmas: sigma_min=0.15046875178813934, sigma_max=30.093753814697266
+Generated sigma sequences. Karras: tensor([30.0938, 22.6017, 16.6984, 12.1118,  8.6041,  5.9691,  4.0299,  2.6360,  1.6614,  1.0018,  0.5725,  0.3061,  0.1505,  0.0000], device='cuda:0'), Exponential: tensor([30.0938, 19.3519, 12.4443,  8.0024,  5.1460,  3.3091,  2.1279,  1.3684,  0.8799,  0.5659,  0.3639,  0.2340,  0.1505,  0.0000], device='cuda:0')
+[Progress Initialized] Created progress tensor with 13 steps (excluding terminal step) on device: cuda
+[Initialization] Pre-allocated empty sigma sequence with shape: torch.Size([13]) on device: cuda
+[Sharpen Mask] Sharpening applied at steps: [10, 11, 12, 13]

sd_simple_kes_v1/image_generation_data/generation_log_20250706_094707.txt

@@ -0,0 +1,24 @@
+[Config Validation] Config validated and missing values filled successfully.
+[Randomization] sigma_min: No randomization applied. Using default value: 0.13757067353874633
+[Random Range] sigma_max: Picked random value 15.16043243738741 between 10 and 50
+[Randomization] sigma_max: Applied min/max randomization. Final value: 15.16043243738741
+[Randomization] start_blend: No randomization applied. Using default value: 0.10237033381422371
+[Randomization] end_blend: No randomization applied. Using default value: 0.5627048166151302
+[Randomization] sharpness: No randomization applied. Using default value: 0.9070742264431869
+[Randomization] early_stopping_threshold: No randomization applied. Using default value: 0.01
+[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
+[Random Range] rho: Picked random value 7.529236701684537 between 5.0 and 10.0
+[Randomization] rho: Applied min/max randomization. Final value: 7.529236701684537
+[Auto Sigma Min] sigma_min set to 0.07580216218693706 using scale factor 200
+Using device: cuda
+Final sigmas: sigma_min=0.07580216228961945, sigma_max=15.160433769226074
+Generated sigma sequences. Karras: tensor([15.1604, 10.9661,  7.8176,  5.4849,  3.7815,  2.5572,  1.6926,  1.0938,  0.6881,  0.4199,  0.2475,  0.1402,  0.0758,  0.0000], device='cuda:0'), Exponential: tensor([15.1604,  9.7490,  6.2691,  4.0314,  2.5924,  1.6671,  1.0720,  0.6894,  0.4433,  0.2851,  0.1833,  0.1179,  0.0758,  0.0000], device='cuda:0')
+[Progress Initialized] Created progress tensor with 13 steps (excluding terminal step) on device: cuda
+[Initialization] Pre-allocated empty sigma sequence with shape: torch.Size([13]) on device: cuda
+[Sharpen Mask] Sharpening applied at steps: [10, 11, 12, 13]

sd_simple_kes_v1/image_generation_data/generation_log_20250706_095038.txt

@@ -0,0 +1,24 @@
+[Config Validation] Config validated and missing values filled successfully.
+[Randomization] sigma_min: No randomization applied. Using default value: 0.13757067353874633
+[Random Range] sigma_max: Picked random value 32.577242192334715 between 10 and 50
+[Randomization] sigma_max: Applied min/max randomization. Final value: 32.577242192334715
+[Randomization] start_blend: No randomization applied. Using default value: 0.10237033381422371
+[Randomization] end_blend: No randomization applied. Using default value: 0.5627048166151302
+[Randomization] sharpness: No randomization applied. Using default value: 0.9070742264431869
+[Randomization] early_stopping_threshold: No randomization applied. Using default value: 0.01
+[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
+[Random Range] rho: Picked random value 8.06934320596871 between 5.0 and 10.0
+[Randomization] rho: Applied min/max randomization. Final value: 8.06934320596871
+[Auto Sigma Min] sigma_min set to 0.16288621096167358 using scale factor 200
+Using device: cuda
+Final sigmas: sigma_min=0.16288620233535767, sigma_max=32.577239990234375
+Generated sigma sequences. Karras: tensor([32.5772, 23.4117, 16.5892, 11.5756,  7.9427,  5.3503,  3.5315,  2.2790,  1.4342,  0.8774,  0.5200,  0.2972,  0.1629,  0.0000], device='cuda:0'), Exponential: tensor([32.5772, 20.9489, 13.4713,  8.6628,  5.5706,  3.5822,  2.3036,  1.4813,  0.9526,  0.6126,  0.3939,  0.2533,  0.1629,  0.0000], device='cuda:0')
+[Progress Initialized] Created progress tensor with 13 steps (excluding terminal step) on device: cuda
+[Initialization] Pre-allocated empty sigma sequence with shape: torch.Size([13]) on device: cuda
+[Sharpen Mask] Sharpening applied at steps: [10, 11, 12, 13]

sd_simple_kes_v1/image_generation_data/generation_log_20250706_095104.txt

@@ -0,0 +1,24 @@
+[Config Validation] Config validated and missing values filled successfully.
+[Randomization] sigma_min: No randomization applied. Using default value: 0.13757067353874633
+[Random Range] sigma_max: Picked random value 48.89761928677526 between 10 and 50
+[Randomization] sigma_max: Applied min/max randomization. Final value: 48.89761928677526
+[Randomization] start_blend: No randomization applied. Using default value: 0.10237033381422371
+[Randomization] end_blend: No randomization applied. Using default value: 0.5627048166151302
+[Randomization] sharpness: No randomization applied. Using default value: 0.9070742264431869
+[Randomization] early_stopping_threshold: No randomization applied. Using default value: 0.01
+[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
+[Random Range] rho: Picked random value 6.552977828605041 between 5.0 and 10.0
+[Randomization] rho: Applied min/max randomization. Final value: 6.552977828605041
+[Auto Sigma Min] sigma_min set to 0.2444880964338763 using scale factor 200
+Using device: cuda
+Final sigmas: sigma_min=0.24448810517787933, sigma_max=48.89762496948242
+Generated sigma sequences. Karras: tensor([48.8976, 35.8633, 25.9015, 18.3913, 12.8144,  8.7423,  5.8245,  3.7778,  2.3763,  1.4429,  0.8408,  0.4668,  0.2445,  0.0000], device='cuda:0'), Exponential: tensor([48.8976, 31.4438, 20.2201, 13.0026,  8.3614,  5.3768,  3.4576,  2.2234,  1.4298,  0.9194,  0.5912,  0.3802,  0.2445,  0.0000], device='cuda:0')
+[Progress Initialized] Created progress tensor with 13 steps (excluding terminal step) on device: cuda
+[Initialization] Pre-allocated empty sigma sequence with shape: torch.Size([13]) on device: cuda
+[Sharpen Mask] Sharpening applied at steps: [10, 11, 12, 13]

sd_simple_kes_v1/image_generation_data/generation_log_20250712_061628.txt

@@ -0,0 +1,24 @@
+[Config Validation] Config validated and missing values filled successfully.
+[Randomization] sigma_min: No randomization applied. Using default value: 0.13757067353874633
+[Random Range] sigma_max: Picked random value 30.331830824484825 between 10 and 50
+[Randomization] sigma_max: Applied min/max randomization. Final value: 30.331830824484825
+[Randomization] start_blend: No randomization applied. Using default value: 0.10237033381422371
+[Randomization] end_blend: No randomization applied. Using default value: 0.5627048166151302
+[Randomization] sharpness: No randomization applied. Using default value: 0.9070742264431869
+[Randomization] early_stopping_threshold: No randomization applied. Using default value: 0.01
+[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
+[Random Range] rho: Picked random value 7.2990362567959135 between 5.0 and 10.0
+[Randomization] rho: Applied min/max randomization. Final value: 7.2990362567959135
+[Auto Sigma Min] sigma_min set to 0.15165915412242412 using scale factor 200
+Using device: cuda
+Final sigmas: sigma_min=0.15165916085243225, sigma_max=30.33182716369629
+Generated sigma sequences. Karras: tensor([30.3318, 26.3462, 22.8210, 19.7105, 16.9729, 14.5700, 12.4665, 10.6304,  9.0326,  7.6465,  6.4479,  5.4151,  4.5283,  3.7698,  3.1235,  2.5752,  2.1120,  1.7226,  1.3968,  1.1256,  0.9011,  0.7163,  0.5653,  0.4425,  0.3435,  0.2642,  0.2012,  0.1517,  0.0000], device='cuda:0'), Exponential: tensor([30.3318, 24.9273, 20.4858, 16.8356, 13.8358, 11.3706,  9.3446,  7.6795,  6.3112,  5.1867,  4.2625,  3.5030,  2.8788,  2.3659,  1.9443,  1.5979,  1.3132,  1.0792,  0.8869,  0.7289,  0.5990,  0.4923,  0.4046,  0.3325,  0.2732,  0.2246,  0.1845,  0.1517,  0.0000], device='cuda:0')
+[Progress Initialized] Created progress tensor with 28 steps (excluding terminal step) on device: cuda
+[Initialization] Pre-allocated empty sigma sequence with shape: torch.Size([28]) on device: cuda
+[Sharpen Mask] Sharpening applied at steps: [21, 22, 23, 24, 25, 26, 27, 28]

sd_simple_kes_v1/image_generation_data/generation_log_20250712_061655.txt

@@ -0,0 +1,24 @@
+[Config Validation] Config validated and missing values filled successfully.
+[Randomization] sigma_min: No randomization applied. Using default value: 0.13757067353874633
+[Random Range] sigma_max: Picked random value 43.23162254607824 between 10 and 50
+[Randomization] sigma_max: Applied min/max randomization. Final value: 43.23162254607824
+[Randomization] start_blend: No randomization applied. Using default value: 0.10237033381422371
+[Randomization] end_blend: No randomization applied. Using default value: 0.5627048166151302
+[Randomization] sharpness: No randomization applied. Using default value: 0.9070742264431869
+[Randomization] early_stopping_threshold: No randomization applied. Using default value: 0.01
+[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
+[Random Range] rho: Picked random value 6.000206094407517 between 5.0 and 10.0
+[Randomization] rho: Applied min/max randomization. Final value: 6.000206094407517
+[Auto Sigma Min] sigma_min set to 0.2161581127303912 using scale factor 200
+Using device: cuda
+Final sigmas: sigma_min=0.21615813672542572, sigma_max=43.231624603271484
+Generated sigma sequences. Karras: tensor([43.2316, 37.8945, 33.1181, 28.8543, 25.0581, 21.6876, 18.7037, 16.0700, 13.7529, 11.7212,  9.9460,  8.4008,  7.0610,  5.9042,  4.9099,  4.0592,  3.3350,  2.7219,  2.2057,  1.7738,  1.4148,  1.1186,  0.8759,  0.6788,  0.5201,  0.3936,  0.2939,  0.2162,  0.0000], device='cuda:0'), Exponential: tensor([43.2316, 35.5286, 29.1981, 23.9956, 19.7201, 16.2063, 13.3187, 10.9456,  8.9953,  7.3925,  6.0753,  4.9928,  4.1032,  3.3721,  2.7712,  2.2775,  1.8717,  1.5382,  1.2641,  1.0389,  0.8538,  0.7016,  0.5766,  0.4739,  0.3894,  0.3201,  0.2630,  0.2162,  0.0000], device='cuda:0')
+[Progress Initialized] Created progress tensor with 28 steps (excluding terminal step) on device: cuda
+[Initialization] Pre-allocated empty sigma sequence with shape: torch.Size([28]) on device: cuda
+[Sharpen Mask] Sharpening applied at steps: [21, 22, 23, 24, 25, 26, 27, 28]

sd_simple_kes_v1/image_generation_data/generation_log_20250712_061722.txt

@@ -0,0 +1,24 @@
+[Config Validation] Config validated and missing values filled successfully.
+[Randomization] sigma_min: No randomization applied. Using default value: 0.13757067353874633
+[Random Range] sigma_max: Picked random value 45.36714554920688 between 10 and 50
+[Randomization] sigma_max: Applied min/max randomization. Final value: 45.36714554920688
+[Randomization] start_blend: No randomization applied. Using default value: 0.10237033381422371
+[Randomization] end_blend: No randomization applied. Using default value: 0.5627048166151302
+[Randomization] sharpness: No randomization applied. Using default value: 0.9070742264431869
+[Randomization] early_stopping_threshold: No randomization applied. Using default value: 0.01
+[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
+[Random Range] rho: Picked random value 7.617959675984846 between 5.0 and 10.0
+[Randomization] rho: Applied min/max randomization. Final value: 7.617959675984846
+[Auto Sigma Min] sigma_min set to 0.22683572774603442 using scale factor 200
+Using device: cuda
+Final sigmas: sigma_min=0.2268357276916504, sigma_max=45.36714172363281
+Generated sigma sequences. Karras: tensor([45.3671, 39.3326, 34.0079, 29.3210, 25.2056, 21.6016, 18.4540, 15.7127, 13.3322, 11.2716,  9.4934,  7.9642,  6.6536,  5.5346,  4.5829,  3.7766,  3.0966,  2.5255,  2.0483,  1.6514,  1.3231,  1.0531,  0.8322,  0.6528,  0.5080,  0.3919,  0.2996,  0.2268,  0.0000], device='cuda:0'), Exponential: tensor([45.3671, 37.2836, 30.6404, 25.1809, 20.6942, 17.0069, 13.9766, 11.4862,  9.4396,  7.7577,  6.3754,  5.2394,  4.3059,  3.5387,  2.9081,  2.3900,  1.9641,  1.6142,  1.3265,  1.0902,  0.8959,  0.7363,  0.6051,  0.4973,  0.4087,  0.3359,  0.2760,  0.2268,  0.0000], device='cuda:0')
+[Progress Initialized] Created progress tensor with 28 steps (excluding terminal step) on device: cuda
+[Initialization] Pre-allocated empty sigma sequence with shape: torch.Size([28]) on device: cuda
+[Sharpen Mask] Sharpening applied at steps: [21, 22, 23, 24, 25, 26, 27, 28]

sd_simple_kes_v1/image_generation_data/generation_log_20250712_061750.txt

@@ -0,0 +1,24 @@
+[Config Validation] Config validated and missing values filled successfully.
+[Randomization] sigma_min: No randomization applied. Using default value: 0.13757067353874633
+[Random Range] sigma_max: Picked random value 11.087427883010665 between 10 and 50
+[Randomization] sigma_max: Applied min/max randomization. Final value: 11.087427883010665
+[Randomization] start_blend: No randomization applied. Using default value: 0.10237033381422371
+[Randomization] end_blend: No randomization applied. Using default value: 0.5627048166151302
+[Randomization] sharpness: No randomization applied. Using default value: 0.9070742264431869
+[Randomization] early_stopping_threshold: No randomization applied. Using default value: 0.01
+[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
+[Random Range] rho: Picked random value 6.447578289721838 between 5.0 and 10.0
+[Randomization] rho: Applied min/max randomization. Final value: 6.447578289721838
+[Auto Sigma Min] sigma_min set to 0.05543713941505333 using scale factor 200
+Using device: cuda
+Final sigmas: sigma_min=0.05543714761734009, sigma_max=11.087427139282227
+Generated sigma sequences. Karras: tensor([11.0874,  9.6852,  8.4358,  7.3254,  6.3411,  5.4709,  4.7039,  4.0298,  3.4392,  2.9234,  2.4746,  2.0854,  1.7493,  1.4601,  1.2124,  1.0012,  0.8219,  0.6706,  0.5435,  0.4374,  0.3493,  0.2767,  0.2173,  0.1691,  0.1302,  0.0992,  0.0746,  0.0554,  0.0000], device='cuda:0'), Exponential: tensor([11.0874,  9.1119,  7.4883,  6.1540,  5.0575,  4.1564,  3.4158,  2.8072,  2.3070,  1.8959,  1.5581,  1.2805,  1.0523,  0.8648,  0.7107,  0.5841,  0.4800,  0.3945,  0.3242,  0.2664,  0.2190,  0.1799,  0.1479,  0.1215,  0.0999,  0.0821,  0.0675,  0.0554,  0.0000], device='cuda:0')
+[Progress Initialized] Created progress tensor with 28 steps (excluding terminal step) on device: cuda
+[Initialization] Pre-allocated empty sigma sequence with shape: torch.Size([28]) on device: cuda
+[Sharpen Mask] Sharpening applied at steps: [21, 22, 23, 24, 25, 26, 27, 28]

sd_simple_kes_v1/image_generation_data/generation_log_20250712_061817.txt

@@ -0,0 +1,24 @@
+[Config Validation] Config validated and missing values filled successfully.
+[Randomization] sigma_min: No randomization applied. Using default value: 0.13757067353874633
+[Random Range] sigma_max: Picked random value 44.86829543350951 between 10 and 50
+[Randomization] sigma_max: Applied min/max randomization. Final value: 44.86829543350951
+[Randomization] start_blend: No randomization applied. Using default value: 0.10237033381422371
+[Randomization] end_blend: No randomization applied. Using default value: 0.5627048166151302
+[Randomization] sharpness: No randomization applied. Using default value: 0.9070742264431869
+[Randomization] early_stopping_threshold: No randomization applied. Using default value: 0.01
+[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
+[Random Range] rho: Picked random value 6.254884080290302 between 5.0 and 10.0
+[Randomization] rho: Applied min/max randomization. Final value: 6.254884080290302
+[Auto Sigma Min] sigma_min set to 0.22434147716754754 using scale factor 200
+Using device: cuda
+Final sigmas: sigma_min=0.224341481924057, sigma_max=44.86829376220703
+Generated sigma sequences. Karras: tensor([44.8683, 39.2502, 34.2352, 29.7700, 25.8046, 22.2927, 19.1914, 16.4610, 14.0646, 11.9684, 10.1412,  8.5543,  7.1814,  5.9986,  4.9840,  4.1176,  3.3814,  2.7592,  2.2361,  1.7989,  1.4360,  1.1366,  0.8915,  0.6925,  0.5322,  0.4043,  0.3032,  0.2243,  0.0000], device='cuda:0'), Exponential: tensor([44.8683, 36.8737, 30.3035, 24.9040, 20.4666, 16.8199, 13.8229, 11.3599,  9.3358,  7.6724,  6.3053,  5.1818,  4.2585,  3.4997,  2.8762,  2.3637,  1.9425,  1.5964,  1.3120,  1.0782,  0.8861,  0.7282,  0.5984,  0.4918,  0.4042,  0.3322,  0.2730,  0.2243,  0.0000], device='cuda:0')
+[Progress Initialized] Created progress tensor with 28 steps (excluding terminal step) on device: cuda
+[Initialization] Pre-allocated empty sigma sequence with shape: torch.Size([28]) on device: cuda
+[Sharpen Mask] Sharpening applied at steps: [21, 22, 23, 24, 25, 26, 27, 28]

sd_simple_kes_v1/image_generation_data/generation_log_20250712_061845.txt

@@ -0,0 +1,24 @@
+[Config Validation] Config validated and missing values filled successfully.
+[Randomization] sigma_min: No randomization applied. Using default value: 0.13757067353874633
+[Random Range] sigma_max: Picked random value 32.700045187476825 between 10 and 50
+[Randomization] sigma_max: Applied min/max randomization. Final value: 32.700045187476825
+[Randomization] start_blend: No randomization applied. Using default value: 0.10237033381422371
+[Randomization] end_blend: No randomization applied. Using default value: 0.5627048166151302
+[Randomization] sharpness: No randomization applied. Using default value: 0.9070742264431869
+[Randomization] early_stopping_threshold: No randomization applied. Using default value: 0.01
+[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
+[Random Range] rho: Picked random value 7.762954933618958 between 5.0 and 10.0
+[Randomization] rho: Applied min/max randomization. Final value: 7.762954933618958
+[Auto Sigma Min] sigma_min set to 0.1635002259373841 using scale factor 200
+Using device: cuda
+Final sigmas: sigma_min=0.16350023448467255, sigma_max=32.70004653930664
+Generated sigma sequences. Karras: tensor([32.7000, 28.3276, 24.4735, 21.0845, 18.1119, 15.5112, 13.2421, 11.2678,  9.5550,  8.0736,  6.7965,  5.6991,  4.7593,  3.9576,  3.2762,  2.6993,  2.2130,  1.8049,  1.4640,  1.1806,  0.9462,  0.7535,  0.5959,  0.4678,  0.3644,  0.2815,  0.2156,  0.1635,  0.0000], device='cuda:0'), Exponential: tensor([32.7000, 26.8735, 22.0852, 18.1501, 14.9161, 12.2583, 10.0741,  8.2791,  6.8040,  5.5916,  4.5953,  3.7765,  3.1036,  2.5506,  2.0961,  1.7227,  1.4157,  1.1635,  0.9562,  0.7858,  0.6458,  0.5307,  0.4361,  0.3584,  0.2946,  0.2421,  0.1989,  0.1635,  0.0000], device='cuda:0')
+[Progress Initialized] Created progress tensor with 28 steps (excluding terminal step) on device: cuda
+[Initialization] Pre-allocated empty sigma sequence with shape: torch.Size([28]) on device: cuda
+[Sharpen Mask] Sharpening applied at steps: [21, 22, 23, 24, 25, 26, 27, 28]

sd_simple_kes_v1/image_generation_data/generation_log_20250726_133513.txt

@@ -0,0 +1,24 @@
+[Config Validation] Config validated and missing values filled successfully.
+[Randomization] sigma_min: No randomization applied. Using default value: 0.13757067353874633
+[Random Range] sigma_max: Picked random value 37.06797949691645 between 10 and 50
+[Randomization] sigma_max: Applied min/max randomization. Final value: 37.06797949691645
+[Randomization] start_blend: No randomization applied. Using default value: 0.10237033381422371
+[Randomization] end_blend: No randomization applied. Using default value: 0.5627048166151302
+[Randomization] sharpness: No randomization applied. Using default value: 0.9070742264431869
+[Randomization] early_stopping_threshold: No randomization applied. Using default value: 0.01
+[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
+[Random Range] rho: Picked random value 9.460897838524227 between 5.0 and 10.0
+[Randomization] rho: Applied min/max randomization. Final value: 9.460897838524227
+[Auto Sigma Min] sigma_min set to 0.18533989748458224 using scale factor 200
+Using device: cuda
+Final sigmas: sigma_min=0.18533989787101746, sigma_max=37.06798553466797
+Generated sigma sequences. Karras: tensor([37.0680, 30.1958, 24.4862, 19.7622, 15.8705, 12.6790, 10.0742,  7.9588,  6.2498,  4.8768,  3.7801,  2.9094,  2.2227,  1.6847,  1.2663,  0.9434,  0.6962,  0.5086,  0.3676,  0.2626,  0.1853,  0.0000], device='cuda:0'), Exponential: tensor([37.0680, 28.4412, 21.8221, 16.7434, 12.8467,  9.8569,  7.5629,  5.8028,  4.4523,  3.4161,  2.6211,  2.0111,  1.5431,  1.1839,  0.9084,  0.6970,  0.5348,  0.4103,  0.3148,  0.2416,  0.1853,  0.0000], device='cuda:0')
+[Progress Initialized] Created progress tensor with 21 steps (excluding terminal step) on device: cuda
+[Initialization] Pre-allocated empty sigma sequence with shape: torch.Size([21]) on device: cuda
+[Sharpen Mask] Sharpening applied at steps: [15, 16, 17, 18, 19, 20, 21]

sd_simple_kes_v1/image_generation_data/generation_log_20250813_084451.txt

@@ -0,0 +1,24 @@
+[Config Validation] Config validated and missing values filled successfully.
+[Randomization] sigma_min: No randomization applied. Using default value: 0.13757067353874633
+[Random Range] sigma_max: Picked random value 10.856943669535708 between 10 and 50
+[Randomization] sigma_max: Applied min/max randomization. Final value: 10.856943669535708
+[Randomization] start_blend: No randomization applied. Using default value: 0.10237033381422371
+[Randomization] end_blend: No randomization applied. Using default value: 0.5627048166151302
+[Randomization] sharpness: No randomization applied. Using default value: 0.9070742264431869
+[Randomization] early_stopping_threshold: No randomization applied. Using default value: 0.01
+[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
+[Random Range] rho: Picked random value 8.08819414456137 between 5.0 and 10.0
+[Randomization] rho: Applied min/max randomization. Final value: 8.08819414456137
+[Auto Sigma Min] sigma_min set to 0.05428471834767854 using scale factor 200
+Using device: cuda
+Final sigmas: sigma_min=0.0542847216129303, sigma_max=10.856942176818848
+Generated sigma sequences. Karras: tensor([10.8569,  7.8007,  5.5264,  3.8555,  2.6451,  1.7815,  1.1758,  0.7587,  0.4775,  0.2922,  0.1732,  0.0990,  0.0543,  0.0000], device='cuda:0'), Exponential: tensor([10.8569,  6.9816,  4.4895,  2.8870,  1.8565,  1.1938,  0.7677,  0.4937,  0.3175,  0.2041,  0.1313,  0.0844,  0.0543,  0.0000], device='cuda:0')
+[Progress Initialized] Created progress tensor with 13 steps (excluding terminal step) on device: cuda
+[Initialization] Pre-allocated empty sigma sequence with shape: torch.Size([13]) on device: cuda
+[Sharpen Mask] Sharpening applied at steps: [10, 11, 12, 13]

sd_simple_kes_v1/image_generation_data/generation_log_20250813_084601.txt

@@ -0,0 +1,24 @@
+[Config Validation] Config validated and missing values filled successfully.
+[Randomization] sigma_min: No randomization applied. Using default value: 0.13757067353874633
+[Random Range] sigma_max: Picked random value 41.49888344830137 between 10 and 50
+[Randomization] sigma_max: Applied min/max randomization. Final value: 41.49888344830137
+[Randomization] start_blend: No randomization applied. Using default value: 0.10237033381422371
+[Randomization] end_blend: No randomization applied. Using default value: 0.5627048166151302
+[Randomization] sharpness: No randomization applied. Using default value: 0.9070742264431869
+[Randomization] early_stopping_threshold: No randomization applied. Using default value: 0.01
+[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
+[Random Range] rho: Picked random value 8.988685067558771 between 5.0 and 10.0
+[Randomization] rho: Applied min/max randomization. Final value: 8.988685067558771
+[Auto Sigma Min] sigma_min set to 0.20749441724150686 using scale factor 200
+Using device: cuda
+Final sigmas: sigma_min=0.20749442279338837, sigma_max=41.49888229370117
+Generated sigma sequences. Karras: tensor([41.4989, 29.5391, 20.7470, 14.3626,  9.7881,  6.5575,  4.3118,  2.7777,  1.7493,  1.0744,  0.6417,  0.3714,  0.2075,  0.0000], device='cuda:0'), Exponential: tensor([41.4989, 26.6860, 17.1606, 11.0352,  7.0962,  4.5632,  2.9344,  1.8870,  1.2134,  0.7803,  0.5018,  0.3227,  0.2075,  0.0000], device='cuda:0')
+[Progress Initialized] Created progress tensor with 13 steps (excluding terminal step) on device: cuda
+[Initialization] Pre-allocated empty sigma sequence with shape: torch.Size([13]) on device: cuda
+[Sharpen Mask] Sharpening applied at steps: [10, 11, 12, 13]

sd_simple_kes_v1/image_generation_data/generation_log_20250813_084703.txt

@@ -0,0 +1,24 @@
+[Config Validation] Config validated and missing values filled successfully.
+[Randomization] sigma_min: No randomization applied. Using default value: 0.13757067353874633
+[Random Range] sigma_max: Picked random value 41.76420171760242 between 10 and 50
+[Randomization] sigma_max: Applied min/max randomization. Final value: 41.76420171760242
+[Randomization] start_blend: No randomization applied. Using default value: 0.10237033381422371
+[Randomization] end_blend: No randomization applied. Using default value: 0.5627048166151302
+[Randomization] sharpness: No randomization applied. Using default value: 0.9070742264431869
+[Randomization] early_stopping_threshold: No randomization applied. Using default value: 0.01
+[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
+[Random Range] rho: Picked random value 7.061781584185445 between 5.0 and 10.0
+[Randomization] rho: Applied min/max randomization. Final value: 7.061781584185445
+[Auto Sigma Min] sigma_min set to 0.20882100858801209 using scale factor 200
+Using device: cuda
+Final sigmas: sigma_min=0.20882099866867065, sigma_max=41.764198303222656
+Generated sigma sequences. Karras: tensor([41.7642, 30.3994, 21.7985, 15.3763, 10.6510,  7.2307,  4.7997,  3.1065,  1.9540,  1.1897,  0.6976,  0.3916,  0.2088,  0.0000], device='cuda:0'), Exponential: tensor([41.7642, 26.8566, 17.2703, 11.1057,  7.1416,  4.5924,  2.9532,  1.8991,  1.2212,  0.7853,  0.5050,  0.3247,  0.2088,  0.0000], device='cuda:0')
+[Progress Initialized] Created progress tensor with 13 steps (excluding terminal step) on device: cuda
+[Initialization] Pre-allocated empty sigma sequence with shape: torch.Size([13]) on device: cuda
+[Sharpen Mask] Sharpening applied at steps: [10, 11, 12, 13]

sd_simple_kes_v1/image_generation_data/generation_log_20250813_084836.txt

@@ -0,0 +1,24 @@
+[Config Validation] Config validated and missing values filled successfully.
+[Randomization] sigma_min: No randomization applied. Using default value: 0.13757067353874633
+[Random Range] sigma_max: Picked random value 24.8344928619694 between 10 and 50
+[Randomization] sigma_max: Applied min/max randomization. Final value: 24.8344928619694
+[Randomization] start_blend: No randomization applied. Using default value: 0.10237033381422371
+[Randomization] end_blend: No randomization applied. Using default value: 0.5627048166151302
+[Randomization] sharpness: No randomization applied. Using default value: 0.9070742264431869
+[Randomization] early_stopping_threshold: No randomization applied. Using default value: 0.01
+[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
+[Random Range] rho: Picked random value 6.906271264950195 between 5.0 and 10.0
+[Randomization] rho: Applied min/max randomization. Final value: 6.906271264950195
+[Auto Sigma Min] sigma_min set to 0.124172464309847 using scale factor 200
+Using device: cuda
+Final sigmas: sigma_min=0.12417245656251907, sigma_max=24.83449363708496
+Generated sigma sequences. Karras: tensor([24.8345, 18.1169, 13.0184,  9.2006,  6.3841,  4.3402,  2.8840,  1.8677,  1.1748,  0.7147,  0.4183,  0.2341,  0.1242,  0.0000], device='cuda:0'), Exponential: tensor([24.8345, 15.9699, 10.2695,  6.6039,  4.2466,  2.7308,  1.7561,  1.1292,  0.7262,  0.4670,  0.3003,  0.1931,  0.1242,  0.0000], device='cuda:0')
+[Progress Initialized] Created progress tensor with 13 steps (excluding terminal step) on device: cuda
+[Initialization] Pre-allocated empty sigma sequence with shape: torch.Size([13]) on device: cuda
+[Sharpen Mask] Sharpening applied at steps: [10, 11, 12, 13]

sd_simple_kes_v1/image_generation_data/generation_log_20250813_085028.txt

@@ -0,0 +1,24 @@
+[Config Validation] Config validated and missing values filled successfully.
+[Randomization] sigma_min: No randomization applied. Using default value: 0.13757067353874633
+[Random Range] sigma_max: Picked random value 32.11483148741722 between 10 and 50
+[Randomization] sigma_max: Applied min/max randomization. Final value: 32.11483148741722
+[Randomization] start_blend: No randomization applied. Using default value: 0.10237033381422371
+[Randomization] end_blend: No randomization applied. Using default value: 0.5627048166151302
+[Randomization] sharpness: No randomization applied. Using default value: 0.9070742264431869
+[Randomization] early_stopping_threshold: No randomization applied. Using default value: 0.01
+[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
+[Random Range] rho: Picked random value 8.54421983240806 between 5.0 and 10.0
+[Randomization] rho: Applied min/max randomization. Final value: 8.54421983240806
+[Auto Sigma Min] sigma_min set to 0.1605741574370861 using scale factor 200
+Using device: cuda
+Final sigmas: sigma_min=0.16057415306568146, sigma_max=32.114830017089844
+Generated sigma sequences. Karras: tensor([32.1148, 22.9607, 16.1922, 11.2503,  7.6909,  5.1653,  3.4022,  2.1934,  1.3808,  0.8465,  0.5038,  0.2899,  0.1606,  0.0000], device='cuda:0'), Exponential: tensor([32.1148, 20.6516, 13.2801,  8.5398,  5.4916,  3.5314,  2.2709,  1.4603,  0.9390,  0.6039,  0.3883,  0.2497,  0.1606,  0.0000], device='cuda:0')
+[Progress Initialized] Created progress tensor with 13 steps (excluding terminal step) on device: cuda
+[Initialization] Pre-allocated empty sigma sequence with shape: torch.Size([13]) on device: cuda
+[Sharpen Mask] Sharpening applied at steps: [10, 11, 12, 13]

sd_simple_kes_v1/image_generation_data/generation_log_20250813_085243.txt

@@ -0,0 +1,24 @@
+[Config Validation] Config validated and missing values filled successfully.
+[Randomization] sigma_min: No randomization applied. Using default value: 0.13757067353874633
+[Random Range] sigma_max: Picked random value 25.33607589764972 between 10 and 50
+[Randomization] sigma_max: Applied min/max randomization. Final value: 25.33607589764972
+[Randomization] start_blend: No randomization applied. Using default value: 0.10237033381422371
+[Randomization] end_blend: No randomization applied. Using default value: 0.5627048166151302
+[Randomization] sharpness: No randomization applied. Using default value: 0.9070742264431869
+[Randomization] early_stopping_threshold: No randomization applied. Using default value: 0.01
+[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
+[Random Range] rho: Picked random value 5.103531052254309 between 5.0 and 10.0
+[Randomization] rho: Applied min/max randomization. Final value: 5.103531052254309
+[Auto Sigma Min] sigma_min set to 0.12668037948824862 using scale factor 200
+Using device: cuda
+Final sigmas: sigma_min=0.126680389046669, sigma_max=25.336074829101562
+Generated sigma sequences. Karras: tensor([25.3361, 19.1034, 14.1676, 10.3134,  7.3512,  5.1152,  3.4619,  2.2683,  1.4306,  0.8618,  0.4910,  0.2608,  0.1267,  0.0000], device='cuda:0'), Exponential: tensor([25.3361, 16.2925, 10.4769,  6.7372,  4.3324,  2.7860,  1.7915,  1.1521,  0.7408,  0.4764,  0.3063,  0.1970,  0.1267,  0.0000], device='cuda:0')
+[Progress Initialized] Created progress tensor with 13 steps (excluding terminal step) on device: cuda
+[Initialization] Pre-allocated empty sigma sequence with shape: torch.Size([13]) on device: cuda
+[Sharpen Mask] Sharpening applied at steps: [10, 11, 12, 13]

sd_simple_kes_v1/image_generation_data/generation_log_20250813_085423.txt

@@ -0,0 +1,24 @@
+[Config Validation] Config validated and missing values filled successfully.
+[Randomization] sigma_min: No randomization applied. Using default value: 0.13757067353874633
+[Random Range] sigma_max: Picked random value 33.4340927821948 between 10 and 50
+[Randomization] sigma_max: Applied min/max randomization. Final value: 33.4340927821948
+[Randomization] start_blend: No randomization applied. Using default value: 0.10237033381422371
+[Randomization] end_blend: No randomization applied. Using default value: 0.5627048166151302
+[Randomization] sharpness: No randomization applied. Using default value: 0.9070742264431869
+[Randomization] early_stopping_threshold: No randomization applied. Using default value: 0.01
+[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
+[Random Range] rho: Picked random value 9.108573697102198 between 5.0 and 10.0
+[Randomization] rho: Applied min/max randomization. Final value: 9.108573697102198
+[Auto Sigma Min] sigma_min set to 0.167170463910974 using scale factor 200
+Using device: cuda
+Final sigmas: sigma_min=0.1671704649925232, sigma_max=33.4340934753418
+Generated sigma sequences. Karras: tensor([33.4341, 23.7717, 16.6789, 11.5357,  7.8554,  5.2594,  3.4568,  2.2265,  1.4023,  0.8617,  0.5151,  0.2986,  0.1672,  0.0000], device='cuda:0'), Exponential: tensor([33.4341, 21.4999, 13.8256,  8.8906,  5.7171,  3.6764,  2.3641,  1.5203,  0.9776,  0.6287,  0.4043,  0.2600,  0.1672,  0.0000], device='cuda:0')
+[Progress Initialized] Created progress tensor with 13 steps (excluding terminal step) on device: cuda
+[Initialization] Pre-allocated empty sigma sequence with shape: torch.Size([13]) on device: cuda
+[Sharpen Mask] Sharpening applied at steps: [10, 11, 12, 13]

sd_simple_kes_v1/image_generation_data/generation_log_20250813_090056.txt

@@ -0,0 +1,24 @@
+[Config Validation] Config validated and missing values filled successfully.
+[Randomization] sigma_min: No randomization applied. Using default value: 0.13757067353874633
+[Random Range] sigma_max: Picked random value 27.46179158324268 between 10 and 50
+[Randomization] sigma_max: Applied min/max randomization. Final value: 27.46179158324268
+[Randomization] start_blend: No randomization applied. Using default value: 0.10237033381422371
+[Randomization] end_blend: No randomization applied. Using default value: 0.5627048166151302
+[Randomization] sharpness: No randomization applied. Using default value: 0.9070742264431869
+[Randomization] early_stopping_threshold: No randomization applied. Using default value: 0.01
+[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
+[Random Range] rho: Picked random value 8.143645894730136 between 5.0 and 10.0
+[Randomization] rho: Applied min/max randomization. Final value: 8.143645894730136
+[Auto Sigma Min] sigma_min set to 0.1373089579162134 using scale factor 200
+Using device: cuda
+Final sigmas: sigma_min=0.1373089700937271, sigma_max=27.4617919921875
+Generated sigma sequences. Karras: tensor([27.4618, 19.7189, 13.9617,  9.7354,  6.6759,  4.4948,  2.9658,  1.9136,  1.2043,  0.7370,  0.4371,  0.2501,  0.1373,  0.0000], device='cuda:0'), Exponential: tensor([27.4618, 17.6594, 11.3560,  7.3025,  4.6959,  3.0197,  1.9418,  1.2487,  0.8030,  0.5164,  0.3321,  0.2135,  0.1373,  0.0000], device='cuda:0')
+[Progress Initialized] Created progress tensor with 13 steps (excluding terminal step) on device: cuda
+[Initialization] Pre-allocated empty sigma sequence with shape: torch.Size([13]) on device: cuda
+[Sharpen Mask] Sharpening applied at steps: [10, 11, 12, 13]

sd_simple_kes_v1/kes_config/default_config.yaml

@@ -0,0 +1,123 @@
+device: "cuda"
+debug: true
+global_randomize: false
+#
+#randomization_type: asymmetric # Options: asymmetric, symmetric, exponential, or log #off is no longer a valid choice. Use the boolean flag for each variable to turn it on/off
+#randomization_percent: 0.2 #Set to a decimal value
+#
+sigma_scale_factor: 200
+sigma_auto_enabled: true
+sigma_auto_mode: sigma_min # Options: sigma_min, sigma_max
+#
+rho_rand: true
+rho_rand_min: 5.00
+rho_rand_max: 10.00
+rho: 7.571656624637901
+rho_enable_randomization_type: false
+rho_randomization_type: asymmetric
+rho_randomization_percent: 0.2
+#
+sigma_min_rand: false
+sigma_min_rand_min: 0.001
+sigma_min_rand_max: 0.02
+sigma_min: 0.13757067353874633
+sigma_min_enable_randomization_type: false
+sigma_min_randomization_type: asymmetric
+sigma_min_randomization_percent: 0.2
+#
+sigma_max_rand: true
+sigma_max_rand_min: 10  
+sigma_max_rand_max: 50
+sigma_max: 28.215968374619045
+sigma_max_enable_randomization_type: false
+sigma_max_randomization_type: asymmetric
+sigma_max_randomization_percent: 0.25
+#
+start_blend_rand: false
+start_blend_rand_min: 0.05
+start_blend_rand_max: 0.2
+start_blend: 0.10237033381422371
+start_blend_enable_randomization_type: false
+start_blend_randomization_type: asymmetric
+start_blend_randomization_percent: 0.2
+#
+end_blend_rand: false
+end_blend_rand_min: 0.4
+end_blend_rand_max: 0.8
+end_blend: 0.5627048166151302
+end_blend_enable_randomization_type: false
+end_blend_randomization_type: asymmetric
+end_blend_randomization_percent: 0.2
+#
+sharpness_rand: false
+sharpness_rand_min: 0.85
+sharpness_rand_max: 1.0
+sharpness: 0.9070742264431869
+sharpness_enable_randomization_type: false
+sharpness_randomization_type: asymmetric
+sharpness_randomization_percent: 0.2
+#
+early_stopping_threshold_rand: false
+early_stopping_threshold_rand_min: 0.001
+early_stopping_threshold_rand_max: 0.02
+early_stopping_threshold: 0.01
+early_stopping_threshold_enable_randomization_type: false
+early_stopping_threshold_randomization_type: asymmetric
+early_stopping_threshold_randomization_percent: 0.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
+#
+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
+#
+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
+#
+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

sd_simple_kes_v1/prompt_parser.py

@@ -0,0 +1,1599 @@
+from __future__ import annotations
+import re
+from collections import namedtuple
+import lark
+import random
+from functools import lru_cache
+import hashlib
+from itertools import product
+
+import os
+import logging
+logger = logging.getLogger(__name__)  # не настраиваем basicConfig в библиотеке
+
+# Фиче-флаги (можно переопределять через env):
+def _env_bool(name: str, default: str = "0") -> bool:
+    v = str(os.getenv(name, default)).strip().lower()
+    return v not in ("0", "", "false", "no", "off")
+
+SAFE_EMPTY = " "
+ALLOW_EMPTY_ALTERNATE   = _env_bool("ALLOW_EMPTY_ALTERNATE", "0")
+EXPAND_ALTERNATE_PER_STEP = _env_bool("EXPAND_ALTERNATE_PER_STEP", "1")
+GROUP_COMBO_LIMIT       = int(os.getenv("GROUP_COMBO_LIMIT", "100"))
+# подавлять одиночные ':' вне скобок в parse_prompt_attention
+SUPPRESS_STANDALONE_COLON = _env_bool("SUPPRESS_STANDALONE_COLON", "1")
+# Размер кэша (оставляем как у тебя, просто используем ниже)
+CACHE_SIZE = int(os.getenv('PROMPT_PARSER_CACHE_SIZE', 4096))
+
+# Грамматика Lark
+# Грамматика Lark (динамически подставляем правило для alternate)
+# динамическое правило для alternate
+_alt_rule = r' "[" prompt ("|" prompt)* "]" '                   # без пустых опций
+if ALLOW_EMPTY_ALTERNATE:
+    _alt_rule = r' "[" prompt ("|" [prompt])+ "]" '             # разрешить пустые опции
+
+# НЕ f-строка! просто r"""...""" + конкатенация
+_grammar = r"""
+!start: (prompt | /[][():|,]/+)*
+
+prompt: (scheduled | emphasized | grouped
+        | alternate | alternate_distinct
+        | alternate2 | alternate1
+        | top_level_sequence3 | top_level_sequence | sequence
+        | compound | numbered | and_rule
+        | plain | WHITESPACE)*
+
+!emphasized: "(" prompt ")"
+        | "(" prompt ":" prompt ")"
+        | "(" prompt ":" NUMBER ")"
+
+scheduled: "[" [prompt (":" prompt)+] "]" ":" NUMBER (step_range_list | reverse_flag | step_range_list reverse_flag)?
+reverse_flag: "reverse" | "r"
+step_range_list: step_range ("," step_range)*
+step_range: NUMBER "-" NUMBER | NUMBER "%" "-" NUMBER "%"
+
+alternate: """ + _alt_rule + r"""
+!alternate_distinct: "[" prompt ("|" prompt)* "]!"
+alternate1: (prompt) "|" (prompt)+
+alternate2: (plain | compound) ("|" (plain | compound))+
+
+grouped: "{" ((NUMBER_Q | prompt | sequence | grouped) ("," | "|")?)+ "}"
+
+top_level_sequence: prompt ("::" sequence)+ "!!" ("," plain)?
+top_level_sequence3: prompt ":::" sequence (WHITESPACE* "," WHITESPACE* sequence)* "!!!" (WHITESPACE* "," WHITESPACE* (plain | sequence))*
+sequence: prompt "::" prompt ("," | WHITESPACE)* nested_sequence* ("!" | ";")?
+nested_sequence: "::" prompt ("," | WHITESPACE)* ("!" | ";" | "~")?
+
+compound: /[a-zA-Z0-9]+(_[a-zA-Z0-9]+)+/
+numbered: NUMBER_Q ("!" | "_")? (grouped | sequence | compound | and_rule | plain | alternate | alternate_distinct | alternate2 | alternate1)
+and_rule: (plain | compound) ("&" (plain | compound))+
+WHITESPACE: /\s+/
+plain: /([^\\[\]\{\}\(\),&:!|]|\\.)+/
+
+%import common.SIGNED_NUMBER -> NUMBER
+%import common.INT -> NUMBER_Q
+"""
+
+schedule_parser = lark.Lark(_grammar, start="start")
+
+
+@lru_cache(maxsize=CACHE_SIZE)
+def hash_tree(tree: lark.Tree | lark.Token) -> str:
+    if isinstance(tree, lark.Tree):
+        return hashlib.md5((tree.data + ''.join(hash_tree(c) for c in tree.children)).encode()).hexdigest()
+    return hashlib.md5(str(tree).encode()).hexdigest()
+
+def resolve_tree(tree: lark.Tree | lark.Token, keep_spacing: bool = True) -> str:
+    if isinstance(tree, lark.Tree):
+        children = []
+        for child in tree.children:
+            if isinstance(child, lark.Token) and child.type == "WHITESPACE":
+                if keep_spacing:
+                    children.append(" ")
+                continue
+            children.append(resolve_tree(child, keep_spacing))
+        result = "".join(str(c) for c in children if c)
+        if keep_spacing:
+            result = result.replace('\\n', ' ').replace('\\t', ' ')
+            result = result.replace('\r\n', '\n').replace('\r', '\n')
+            result = result.replace('\n', ' ').replace('\t', ' ')
+            result = result.replace('\\n', ' ').replace('\\t', ' ')
+            return re.sub(r"[\s\u2028\u2029]+", " ", result).strip() if keep_spacing else result.strip()
+        else:
+            return result.strip()
+    return str(tree).strip()
+
+class ScheduleTransformer(lark.Transformer):
+    def __init__(self, total_steps: int, current_step: int = 1, seed: int | None = 42):
+        super().__init__()
+        self.total_steps = total_steps
+        self.current_step = current_step
+        self.seed = seed
+        self.rng = random.Random(seed) if seed is not None else random
+
+
+    def start(self, args):
+        s = "".join(str(arg) for arg in args if arg)
+        # owner::a::b!!, extra -> owner -> owner: a, b, extra
+        if "::" in s and "!!" in s and all(ch not in s for ch in "[]()"):
+            left, trailing = s.split("!!", 1)
+            owner, rest = left.split("::", 1)
+            descriptors = [x.strip(" ,~!;") for x in rest.split("::") if x.strip(" ,~!;")]
+            seq_text = f"{owner.strip()}: {', '.join(descriptors)}"
+            trailing_text = [t.strip(" ,") for t in trailing.split(",") if t.strip(" ,")]
+            out = f"{owner.strip()} -> {seq_text}"
+            if trailing_text:
+                out += f", {', '.join(trailing_text)}"
+            return out
+        # owner::a::b!  ->  owner: a, b
+        if "::" in s and (s.endswith("!") or s.endswith(";")) and all(ch not in s for ch in "[]()"):
+            owner, rest = s.split("::", 1)
+            rest = rest[:-1]
+            descriptors = [x.strip(" ,~!;") for x in rest.split("::") if x.strip(" ,~!;")]
+            return f"{owner.strip()}: {', '.join(descriptors)}"
+        return s
+
+    def prompt(self, args):
+        return "".join(str(arg) for arg in args if arg)
+
+    def plain(self, args):
+        return args[0].value
+
+    def compound(self, args):
+        return "_".join(str(arg) for arg in args)
+
+    def and_rule(self, args):
+        return " and ".join(resolve_tree(arg, keep_spacing=True) for arg in args if resolve_tree(arg))
+
+    def grouped(self, args):
+        return ", ".join(resolve_tree(arg, keep_spacing=True) for arg in args if resolve_tree(arg).strip(" ,|"))
+
+    def alternate(self, args):
+        vals = []
+        for arg in args:
+            s = resolve_tree(arg, keep_spacing=True)
+            if s or s == "":
+                vals.append(s)
+        return vals[(self.current_step - 1) % len(vals)] if vals else "empty_prompt"
+
+
+    def alternate_distinct(self, args):
+        options = [resolve_tree(arg, keep_spacing=True) for arg in args if resolve_tree(arg)]
+        return self.rng.choice(options) if options else "empty_prompt"
+    
+    def alternate1(self, args):
+        options = [resolve_tree(arg, keep_spacing=True) for arg in args if resolve_tree(arg)]
+        return self.rng.choice(options) if options else "empty_prompt"
+
+    def alternate2(self, args):
+        options = [resolve_tree(a, keep_spacing=True) for a in args if resolve_tree(a, keep_spacing=True)]
+        suffix = options[0].split("_", 1)[1] if options and "_" in options[0] else ""
+        combined = [(o if "_" in o or not suffix else f"{o}_{suffix}") for o in options]
+        return "|".join(combined) if combined else "empty_prompt"
+
+
+
+    def numbered(self, args):
+        # количество
+        quantity = int(args[0])
+
+        # флаг distinct: принимаем и "!" и "_", учитываем, что это может быть Token
+        distinct = False  # treat all numbered selections as distinct in visitor to avoid duplicate options due to parsing limits
+        if len(args) > 1:
+            mark = str(args[1])
+            distinct = mark in ("!", "_")
+
+        # цель (список опций/узел)
+        target = args[-1]
+
+        # собираем опции ровно один раз (не вызываем self.visit дважды!)
+        options = []
+        if isinstance(target, lark.Tree) and getattr(target, "data", None) in ("alternate", "alternate1", "alternate2"):
+            for child in target.children:
+                val = self.visit(child)
+                if val:
+                    options.append(val)
+        elif isinstance(target, lark.Token):
+            options = [resolve_tree(target, keep_spacing=True)]
+        else:
+            for child in getattr(target, "children", []):
+                val = self.visit(child)
+                if val:
+                    options.append(val)
+
+        if not options:
+            return "empty_prompt"
+
+        # выбор
+        if distinct:
+            # deterministic: take first N unique
+            seen = []
+            for opt in options:
+                if opt not in seen:
+                    seen.append(opt)
+                if len(seen) >= quantity:
+                    break
+            selected = seen if len(seen) >= quantity else seen + options[:max(0, quantity - len(seen))]
+        else:
+            selected = self.rng.choices(options, k=quantity)
+
+        return ", ".join(selected)
+
+    def sequence(self, args, parent=None):
+        owner = resolve_tree(args[0], keep_spacing=True) if parent is None else parent
+        descriptors = [resolve_tree(arg, keep_spacing=True).strip(" ,~!;") for arg in args[1:] if resolve_tree(arg).strip(" ,~!;")]
+        return f"{owner}: {', '.join(descriptors)}"
+
+    def top_level_sequence(self, args):
+        owner = resolve_tree(args[0], keep_spacing=True).strip()
+        sequences = []
+        trailing_text = []
+        for child in args[1:]:
+            if isinstance(child, lark.Tree) and child.data == "sequence":
+                sequences.append(self.sequence(child.children, owner))
+            elif isinstance(child, str) and child.strip() == "!!":
+                continue
+            else:
+                t = resolve_tree(child, keep_spacing=True).strip(" ,")
+                if t:
+                    trailing_text.append(t)
+        text = f"{owner} -> {', '.join(sequences)}"
+        if trailing_text:
+            text += f", {', '.join(trailing_text)}"
+        return text
+
+    def top_level_sequence3(self, args):
+        owner = resolve_tree(args[0], keep_spacing=True).strip()
+        sequences, trailing = [], []
+        for child in args[1:]:
+            if isinstance(child, lark.Tree) and child.data == "sequence":
+                sequences.append(self.sequence(child.children, owner))
+            else:
+                t = resolve_tree(child, keep_spacing=True).strip(" ,")
+                if t and t != "!!!":
+                    trailing.append(t)
+        text = f"{owner} -> {', '.join(sequences)}"
+        if trailing:
+            text += f", {', '.join(trailing)}"
+        return text
+
+
+
+    def nested_sequence(self, args):
+        # Извлекаем элементы, исключая завершающий символ
+        elements = [resolve_tree(arg, keep_spacing=True).strip(" ,~!;") for arg in args[:-1] if resolve_tree(arg).strip(" ,~!;")]
+        # Проверяем завершающий символ
+        terminator = args[-1] if args and isinstance(args[-1], str) else None
+        if terminator == "~":
+            return self.rng.choice(elements) if elements else "empty_prompt"
+        return f"[{' | '.join(elements)}]"
+    
+    def emphasized(self, args):
+        prompt = resolve_tree(args[0], keep_spacing=True)
+        try:
+            weight = float(args[1]) if len(args) > 1 and isinstance(args[1], lark.Token) and args[1].type == "NUMBER" else 1.1
+        except ValueError:
+            weight = 1.0
+        return f"({prompt}:{weight})"
+
+    def scheduled(self, args):
+        prompts = [arg for arg in args[:-1] if not isinstance(arg, lark.Token) or arg.type != "NUMBER"]
+        number_node = args[-1]
+        if isinstance(number_node, lark.Tree):
+            number_node = resolve_tree(number_node, keep_spacing=True)
+        try:
+            weight = float(number_node)
+        except ValueError:
+            weight = 1.0
+
+        boundary = int(weight * self.total_steps) if weight <= 1.0 else int(weight)
+        boundary = max(1, min(boundary, self.total_steps))
+
+        if not prompts:
+            return "empty_prompt"
+        if len(prompts) == 1:
+            return f"({resolve_tree(prompts[0], keep_spacing=True)}:{weight})" if self.current_step >= boundary else ""
+        step_increment = boundary / max(1, len(prompts))
+        for i, prompt in enumerate(prompts):
+            step = min(self.total_steps, int(i * step_increment)) if i < len(prompts) - 1 else self.total_steps
+            if self.current_step <= step:
+                return f"({resolve_tree(prompt, keep_spacing=True)}:{weight})"
+        return f"({resolve_tree(prompts[-1], keep_spacing=True)}:{weight})"
+
+class CollectSteps(lark.Visitor):
+
+    def visit_prompt(self, tree):
+        # Detect simple bracket scheduling like '... [a:b:c:3] ...' without pipes and turn into schedule
+        full = resolve_tree(tree, keep_spacing=True)
+        if '[' in full and ']' in full and '|' not in full and '(' not in full and ')' not in full:
+            pre, inner, post = full, "", ""
+            try:
+                lb = full.index('['); rb = full.rindex(']')
+                pre, inner, post = full[:lb], full[lb+1:rb], full[rb+1:]
+                parts = [p.strip() for p in inner.split(':') if p.strip()]
+                if len(parts) >= 2 and re.match(r'^[-+]?(?:\d+(?:\.\d+)?|\.\d+)(?:[eE][+-]?\d+)?$', parts[-1]):
+                    boundary_f = float(parts[-1])
+                    prompts = parts[:-1]
+                    if prompts:
+                        def _clamp(x): return max(1, min(int(round(x)), self.steps))
+                        schedules = []
+                        pre_s = self.prefix + pre
+                        suf_s = post + self.suffix
+                        if len(prompts) == 1:
+                            boundary = _clamp(boundary_f if boundary_f > 1.0 else boundary_f * self.steps)
+                            schedules.append([boundary, pre_s + self.suffix])
+                            schedules.append([self.steps, pre_s + prompts[0] + self.suffix])
+                            return [[e, _apply_and(t)] for e,t in schedules]
+                        else:
+                            boundary = _clamp(boundary_f if boundary_f > 1.0 else boundary_f * self.steps)
+                            if boundary < len(prompts):
+                                boundary = len(prompts)
+                            step_size = boundary / len(prompts)
+                            if int(round(step_size)) > 1:
+                                schedules.append([1, pre_s + self.suffix])
+                            for i, ptxt in enumerate(prompts):
+                                start = _clamp(int(round(i * step_size)) + 1)
+                                end   = _clamp(int(round((i + 1) * step_size)))
+                                if start < end:
+                                    schedules.append([end, pre_s + ptxt + self.suffix])
+                            if schedules and schedules[-1][0] < self.steps:
+                                schedules.append([self.steps, pre_s + prompts[-1] + self.suffix])
+                            return [[e, _apply_and(t)] for e,t in schedules] or [[self.steps, pre_s + prompts[-1] + self.suffix]]
+            except ValueError:
+                pass
+        # 2b) '[inner]:N' form (no pipes inside) -> schedule after boundary N
+        if '[' in full and ']' in full and '|' not in full:
+            import re as _re
+            m = _re.match(r'^(.*)\[(.*?)\]\s*:\s*([-+]?(?:\d+(?:\.\d+)?|\.\d+)(?:[eE][+-]?\d+)?)\s*(.*)$', full)
+            if m:
+                pre, inner, boundary_txt, post = m.groups()
+                if '(' not in inner and ')' not in inner:
+                    try:
+                        boundary_f = float(boundary_txt)
+                        prompts = [p.strip() for p in inner.split(':') if p.strip()] or []
+                        if not prompts and inner.strip():
+                            prompts = [inner.strip()]
+                        if prompts:
+                            def clamp(x): return max(1, min(int(round(x)), self.steps))
+                            pre_s = self.prefix + pre
+                            suf_s = post + self.suffix
+                            boundary = clamp(boundary_f if boundary_f > 1.0 else boundary_f * self.steps)
+                            if len(prompts) == 1:
+                                return [[boundary, pre_s + suf_s], [self.steps, pre_s + prompts[0] + suf_s]]
+                            if boundary < len(prompts):
+                                boundary = len(prompts)
+                            step_size = boundary / len(prompts)
+                            schedules = []
+                            if int(round(step_size)) > 1:
+                                schedules.append([1, pre_s + suf_s])
+                            for i, ptxt in enumerate(prompts):
+                                start = clamp(int(round(i * step_size)) + 1)
+                                end   = clamp(int(round((i + 1) * step_size)))
+                                if start < end:
+                                    schedules.append([end, pre_s + ptxt + suf_s])
+                            if schedules and schedules[-1][0] < self.steps:
+                                schedules.append([self.steps, pre_s + prompts[-1] + suf_s])
+                            return [[e, _apply_and(t)] for e,t in schedules] or [[self.steps, pre_s + prompts[-1] + suf_s]]
+                    except ValueError:
+                        pass
+
+        return self._default_visit(tree)
+    def __init__(self, steps, prefix="", suffix="", depth=0, use_scheduling=True, seed=None):
+        super().__init__()
+        self.steps = steps
+        self.prefix = prefix
+        self.suffix = suffix
+        self.depth = depth
+        self.use_scheduling = use_scheduling
+        self.seed = seed
+        self.rng = random.Random(seed) if seed is not None else random
+        self.schedules = []
+
+    def visit(self, tree):
+        if isinstance(tree, lark.Tree):
+            method_name = f"visit_{tree.data}"
+            method = getattr(self, method_name, self._default_visit)
+            return method(tree)
+        elif isinstance(tree, lark.Token):
+            return self._visit_token(tree)
+        return []
+
+    def visit_start(self, tree):
+        full = resolve_tree(tree, keep_spacing=True).strip()
+
+        # 0) owner::a::b!!, trailing -> owner -> owner: a, owner: b, trailing
+        if "::" in full and "!!" in full and all(ch not in full for ch in '[]()'):
+            left, trailing = full.split("!!", 1)
+            owner, rest = left.split("::", 1)
+            descriptors = [x.strip(' ,~!;') for x in rest.split('::') if x.strip(' ,~!;')]
+            sequences = [f"{owner.strip()}: {d}" for d in descriptors]
+            trailing_text = [t.strip(' ,') for t in trailing.split(',') if t.strip(' ,')]
+            out = f"{owner.strip()} -> {', '.join(sequences)}"
+            if trailing_text:
+                out += f", {', '.join(trailing_text)}"
+            return [[self.steps, self.prefix + out + self.suffix]]
+
+        # 1) owner::a::b!  ->  owner: a, b
+        if '::' in full and (full.endswith('!') or full.endswith(';')) and all(ch not in full for ch in '[]()'):
+            owner, rest = full.split('::', 1)
+            rest = rest[:-1]
+            descriptors = [x.strip(' ,~!;') for x in rest.split('::') if x.strip(' ,~!;')]
+            text = f"{owner.strip()}: {', '.join(descriptors)}"
+            return [[self.steps, self.prefix + text + self.suffix]]
+
+
+        # 2) ... [a:b:c:3] ...  (без '|') — равномерное расписание до границы 3 (или процента)
+        if '[' in full and ']' in full and '|' not in full and '(' not in full and ')' not in full:
+            try:
+                lb, rb = full.index('['), full.rindex(']')
+                pre, inner, post = full[:lb], full[lb+1:rb], full[rb+1:]
+                parts = [p.strip() for p in inner.split(':') if p.strip()]
+
+                if len(parts) >= 2 and re.match(r'^[-+]?(?:\d+(?:\.\d+)?|\.\d+)(?:[eE][+-]?\d+)?$', parts[-1]):
+                    boundary_f = float(parts[-1])
+                    prompts = parts[:-1]
+
+                    if prompts:
+                        def clamp(x):
+                            return max(1, min(int(round(x)), self.steps))
+
+                        schedules = []
+                        pre_s = self.prefix + pre
+                        suf_s = post + self.suffix
+
+                        if len(prompts) == 1:
+                            boundary = clamp(boundary_f if boundary_f > 1.0 else boundary_f * self.steps)
+                            schedules.append([boundary, pre_s + self.suffix])
+                            schedules.append([self.steps, pre_s + prompts[0] + self.suffix])
+                            return [[e, _apply_and(t)] for e,t in schedules]
+
+                        boundary = clamp(boundary_f if boundary_f > 1.0 else boundary_f * self.steps)
+                        if boundary < len(prompts):
+                            boundary = len(prompts)
+
+                        step_size = boundary / len(prompts)
+                        if int(round(step_size)) > 1:
+                            schedules.append([1, pre_s + self.suffix])
+
+                        for i, ptxt in enumerate(prompts):
+                            start = clamp(int(round(i * step_size)) + 1)
+                            end = clamp(int(round((i + 1) * step_size)))
+                            if start < end:
+                                schedules.append([end, pre_s + ptxt + self.suffix])
+
+                        if schedules and schedules[-1][0] < self.steps:
+                            schedules.append([self.steps, pre_s + prompts[-1] + self.suffix])
+
+                        return [[e, _apply_and(t)] for e,t in schedules] or [[self.steps, pre_s + prompts[-1] + self.suffix]]
+
+            except ValueError:
+                pass
+
+        # по умолчанию — стандартный обход
+        return self._default_visit(tree)
+
+
+    def _default_visit(self, tree):
+        schedules = []
+        has_tree_child = any(isinstance(c, lark.Tree) for c in tree.children)
+        for i, child in enumerate(tree.children):
+            if isinstance(child, lark.Token) and child.type == "WHITESPACE":
+                continue
+            # если есть структурные узлы — пропускаем сырые токены, иначе возникают дубликаты
+            if has_tree_child and isinstance(child, lark.Token):
+                continue
+            pre = "".join(
+                resolve_tree(c, keep_spacing=True)
+                for j, c in enumerate(tree.children)
+                if j < i and not (isinstance(c, lark.Token) and c.type == "WHITESPACE")
+            )
+            post = "".join(
+                resolve_tree(c, keep_spacing=True)
+                for j, c in enumerate(tree.children)
+                if j > i and not (isinstance(c, lark.Token) and c.type == "WHITESPACE")
+            )
+            collector = CollectSteps(
+                self.steps,
+                prefix=self.prefix + pre,
+                suffix=post + self.suffix,
+                depth=self.depth + 1,
+                use_scheduling=self.use_scheduling,
+                seed=self.seed,
+            )
+            child_schedules = collector.visit(child)
+            schedules.extend(child_schedules)
+        return [[e, _apply_and(t)] for e,t in schedules]
+
+
+    def _visit_token(self, token):
+        if token.type == "WHITESPACE":
+            return []
+        return [[self.steps, self.prefix + str(token) + self.suffix]]
+
+    def visit_plain(self, tree):
+        text = resolve_tree(tree, keep_spacing=True)
+        return [[self.steps, self.prefix + text + self.suffix]]
+
+    def visit_top_level_sequence3(self, tree):
+        transformer = ScheduleTransformer(self.steps, 1, self.seed)
+        text = transformer.transform(tree)
+        return [[self.steps, self.prefix + text + self.suffix]]
+
+    def visit_scheduled(self, tree):
+        if not tree.children:
+            return [[self.steps, self.prefix + "empty_prompt" + self.suffix]]
+
+        # 1) Извлечение как у тебя
+        prompts = [
+            p for p in tree.children
+            if not (isinstance(p, lark.Token) and p.type == "NUMBER")
+            and not (isinstance(p, lark.Tree) and getattr(p, "data", None) in ("step_range_list", "reverse_flag"))
+        ]
+        number_node = next((p for p in tree.children if isinstance(p, lark.Token) and p.type == "NUMBER"), None)
+        step_range_list = next((p for p in tree.children if isinstance(p, lark.Tree) and getattr(p, "data", None) == "step_range_list"), None)
+        is_reverse = any(isinstance(p, lark.Tree) and getattr(p, "data", None) == "reverse_flag" for p in tree.children)
+
+        try:
+            weight = float(number_node.value) if number_node is not None else 1.0
+        except (ValueError, TypeError, AttributeError):
+            weight = 1.0
+
+        if not prompts:
+            return [[self.steps, self.prefix + "empty_prompt" + self.suffix]]
+
+        # Вспомогалка
+        def _clamp_step(x: int) -> int:
+            return max(1, min(x, self.steps))
+
+        # 4) Интервалы
+        step_intervals = []
+        explicit_ranges = False
+        if step_range_list:
+            explicit_ranges = True
+            for sr in step_range_list.children:
+                if not (isinstance(sr, lark.Tree) and getattr(sr, "data", None) == "step_range"):
+                    continue
+                if len(sr.children) != 2:
+                    continue
+                start_txt = resolve_tree(sr.children[0], keep_spacing=False)
+                end_txt = resolve_tree(sr.children[1], keep_spacing=False)
+
+                def _to_steps(txt: str) -> int:
+                    s = txt.strip()
+                    if s.endswith("%"):
+                        try:
+                            return int(round(float(s[:-1]) / 100.0 * self.steps))
+                        except ValueError:
+                            return 1
+                    try:
+                        return int(round(float(s)))
+                    except ValueError:
+                        return 1
+
+                start_step = _clamp_step(_to_steps(start_txt))
+                end_step   = _clamp_step(_to_steps(end_txt))
+                if start_step < end_step:
+                    step_intervals.append((start_step, end_step))
+        else:
+            num_prompts = len(prompts)
+            boundary = int(round(weight * self.steps)) if weight <= 1.0 else int(round(weight))
+            boundary = _clamp_step(boundary)
+            if num_prompts == 1:
+                # Особый случай: один вариант внутри [] — включаем его ПОСЛЕ boundary
+                before_end = boundary
+                after_end  = self.steps
+                schedules = []
+                # BEFORE: без содержимого [], но сохраняем пробел между префиксом и суффиксом если нужен
+                spacer = " " if (self.prefix and not self.prefix.endswith(" ")) else ""
+                schedules.append([before_end, self.prefix + spacer + self.suffix])
+                # AFTER: с единственным текстом
+                last_text = resolve_tree(prompts[0], keep_spacing=True)
+                spacer2 = " " if (self.prefix and last_text and not self.prefix.endswith(" ")) else ""
+                schedules.append([after_end, self.prefix + spacer2 + last_text + self.suffix])
+                return [[e, _apply_and(t)] for e,t in schedules]
+            else:
+                # Несколько вариантов: равномерное деление в пределах boundary
+                if boundary < num_prompts:
+                    boundary = num_prompts
+                step_size = boundary / num_prompts
+                for i in range(num_prompts):
+                    start = int(round(i * step_size)) + 1
+                    end   = int(round((i + 1) * step_size))
+                    start = _clamp_step(start); end = _clamp_step(end)
+                    if start < end:
+                        step_intervals.append((start, end))
+
+        # 5) reverse
+        if is_reverse:
+            prompts = prompts[::-1]
+            step_intervals = step_intervals[::-1]
+
+        # 6) Формируем расписания
+        schedules = []
+
+        # ДО первого интервала (для явных диапазонов/несколько промптов)
+        if step_intervals and step_intervals[0][0] > 1:
+            schedules.append([step_intervals[0][0] - 1, self.prefix + self.suffix])
+
+        for i, (start, end) in enumerate(step_intervals[:len(prompts)]):
+            end = min(end, self.steps)
+            if start < end:
+                p = prompts[i]
+                if isinstance(p, lark.Tree):
+                    child_schedules = self.visit(p)
+                else:
+                    text = resolve_tree(p, keep_spacing=True)
+                    child_schedules = [[self.steps, text]]
+
+                for sched in child_schedules:
+                    schedules.append([end, self.prefix + sched[1] + self.suffix])
+
+        # ПОСЛЕ последнего интервала — берём последний prompt
+        if step_intervals and step_intervals[-1][1] < self.steps:
+            tail_text = resolve_tree(prompts[-1], keep_spacing=True)
+            schedules.append([self.steps, self.prefix + tail_text + self.suffix])
+
+        if not schedules:
+            return [[self.steps, self.prefix + resolve_tree(tree, keep_spacing=True) + self.suffix]]
+
+        return [[e, _apply_and(t)] for e,t in schedules]
+    
+    def visit_alternate(self, tree):
+        # Special-case: bracket content like "[a:b:c:3]" (no pipes) -> scheduled over boundary=3
+        inner_tokens = []
+        for child in tree.children:
+            if isinstance(child, lark.Token) and child.type in ("WHITESPACE",):
+                continue
+            t = resolve_tree(child, keep_spacing=True)
+            if t in ("[", "]"):
+                continue
+            inner_tokens.append(t)
+        inner_text = "".join(inner_tokens).strip()
+        if '|' not in inner_text and ':' in inner_text:
+            parts = [p.strip() for p in inner_text.split(':') if p.strip() != ""]
+            if len(parts) >= 2:
+                last = parts[-1]
+                try:
+                    boundary_f = float(last)
+                    prompts = parts[:-1]
+                    if prompts:
+                        # compute schedules similar to visit_emphasized scheduled handling
+                        def _clamp(x): return max(1, min(int(round(x)), self.steps))
+                        schedules = []
+                        if len(prompts) == 1:
+                            boundary = _clamp(boundary_f if boundary_f > 1.0 else boundary_f * self.steps)
+                            schedules.append([boundary, self.prefix + self.suffix])
+                            schedules.append([self.steps, self.prefix + prompts[0] + self.suffix])
+                            return [[e, _apply_and(t)] for e,t in schedules]
+                        else:
+                            boundary = _clamp(boundary_f if boundary_f > 1.0 else boundary_f * self.steps)
+                            if boundary < len(prompts):
+                                boundary = len(prompts)
+                            step_size = boundary / len(prompts)
+                            # pre
+                            if int(round(step_size)) > 1:
+                                schedules.append([1, self.prefix + self.suffix])
+                            for i, ptxt in enumerate(prompts):
+                                start = _clamp(int(round(i * step_size)) + 1)
+                                end   = _clamp(int(round((i + 1) * step_size)))
+                                if start < end:
+                                    schedules.append([end, self.prefix + ptxt + self.suffix])
+                            if schedules and schedules[-1][0] < self.steps:
+                                schedules.append([self.steps, self.prefix + prompts[-1] + self.suffix])
+                            return [[e, _apply_and(t)] for e,t in schedules] or [[self.steps, self.prefix + prompts[-1] + self.suffix]]
+                except ValueError:
+                    pass
+        options = []
+        for child in tree.children:
+            if isinstance(child, lark.Token) and child.type == "WHITESPACE":
+                continue
+            child_schedules = self.visit(child)
+            child_options = [
+                sched[1].strip(" ,|")
+                for sched in child_schedules
+                if sched[1].strip(" ,|")
+            ]
+            options.append(
+                child_options
+                or [resolve_tree(child, keep_spacing=True).strip(" ,|")]
+            )
+
+        if not options:
+            return [[self.steps, self.prefix + "empty_prompt" + self.suffix]]
+
+        if EXPAND_ALTERNATE_PER_STEP:
+            schedules = []
+            for step in range(1, self.steps + 1):
+                option = options[(step - 1) % len(options)]
+                for sched in option:
+                    schedules.append([step, self.prefix + sched + self.suffix])
+            return [[e, _apply_and(t)] for e,t in schedules]
+        else:
+            # фиксируем один вариант на весь прогон
+            # выбираем группу по текущему сид/рандому и элемент в группе
+            group = options[self.rng.randrange(len(options))]
+            choice = self.rng.choice(group) if group else "empty_prompt"
+            return [[self.steps, self.prefix + choice + self.suffix]]
+
+
+    def visit_alternate_distinct(self, tree):
+        options = []
+        for child in tree.children:
+            if isinstance(child, lark.Token) and child.type == "WHITESPACE":
+                continue
+            child_schedules = self.visit(child)
+            child_options = [
+                sched[1].strip(" ,|")
+                for sched in child_schedules
+                if sched[1].strip(" ,|")
+            ]
+            options.append(
+                child_options
+                or [resolve_tree(child, keep_spacing=True).strip(" ,|")]
+            )
+
+        # сплющиваем все варианты
+        flat = [opt for group in options for opt in group]
+        if not flat:
+            return [[self.steps, self.prefix + "empty_prompt" + self.suffix]]
+
+        selected = self.rng.choice(flat)
+        return [[self.steps, self.prefix + selected + self.suffix]]
+
+    def visit_alternate1(self, tree):
+        return self.visit_alternate_distinct(tree)
+
+    def visit_alternate2(self, tree):
+        options = [
+            resolve_tree(c, keep_spacing=True).strip()
+            for c in tree.children
+            if resolve_tree(c, keep_spacing=True).strip()
+        ]
+        suffix = options[0].split("_", 1)[1] if options and "_" in options[0] else ""
+        combined = []
+        for opt in options:
+            combined.append(opt if "_" in opt or not suffix else f"{opt}_{suffix}")
+        text = "|".join(combined) if combined else "empty_prompt"
+        return [[self.steps, self.prefix + text + self.suffix]]
+
+
+    def visit_grouped(self, tree):
+        all_options = []
+        for child in tree.children:
+            if isinstance(child, lark.Token) and child.type == "WHITESPACE":
+                continue
+            child_schedules = self.visit(child)
+            child_options = [sched[1].strip(" ,|") for sched in child_schedules if sched[1].strip(" ,|")]
+            all_options.append(child_options or [resolve_tree(child, keep_spacing=True).strip(" ,|")])
+        out = []
+        for i, combo in enumerate(product(*all_options)):
+            if i >= GROUP_COMBO_LIMIT:
+                break
+            text = ", ".join(combo).strip()
+            if text:
+                out.append([self.steps, self.prefix + text + self.suffix])
+
+        return out or [[self.steps, self.prefix + "empty_prompt" + self.suffix]]
+
+    def visit_sequence(self, tree):
+        transformer = ScheduleTransformer(self.steps, 1, self.seed)
+        text = transformer.transform(tree)
+        return [[self.steps, self.prefix + text + self.suffix]]
+
+    def visit_nested_sequence(self, tree):
+        # Извлекаем элементы, исключая завершающий символ
+        elements = [
+            resolve_tree(c, keep_spacing=True).strip(" ,~!;")
+            for c in tree.children[:-1]
+            if resolve_tree(c, keep_spacing=True).strip(" ,~!;")
+        ]
+        # Проверяем завершающий символ
+        terminator = tree.children[-1] if tree.children and isinstance(tree.children[-1], lark.Token) else None
+        if terminator and terminator.value == "~":
+            text = self.rng.choice(elements) if elements else "empty_prompt"
+        else:
+            text = f"[{' | '.join(elements)}]"
+        return [[self.steps, self.prefix + text + self.suffix]]
+
+    def visit_numbered(self, tree):
+        quantity = int(tree.children[0])
+        distinct = False
+        if len(tree.children) > 1:
+            mark = tree.children[1]
+            try:
+                if str(mark) in ('!', '_'):
+                    distinct = True
+            except Exception:
+                pass
+        target = tree.children[-1]
+
+        import lark as _l
+        options = []
+        def add_opts(node):
+            if isinstance(node, _l.Tree):
+                if getattr(node, "data", None) in ("alternate","alternate1","alternate2","prompt"):
+                    for ch in node.children:
+                        add_opts(ch)
+                else:
+                    txt = resolve_tree(node, keep_spacing=True).strip(" ,|")
+                    if txt:
+                        options.append(txt)
+            elif isinstance(node, _l.Token):
+                txt = str(node).strip(" ,|")
+                if txt:
+                    options.append(txt)
+
+        add_opts(target)
+        if not options:
+            child_schedules = self.visit(target)
+            options = [s[1].strip(" ,|") for s in child_schedules if s[1].strip(" ,|")]
+        if not options:
+            return [[self.steps, self.prefix + "empty_prompt" + self.suffix]]
+
+        if distinct:
+            seen = []
+            for opt in options:
+                if opt not in seen:
+                    seen.append(opt)
+                if len(seen) == quantity:
+                    break
+            if len(seen) < quantity:
+                seen += self.rng.choices(options, k=quantity - len(seen))
+            selected = seen
+        else:
+            selected = self.rng.choices(options, k=quantity)
+
+        return [[self.steps, self.prefix + ", ".join(selected) + self.suffix]]
+
+
+
+    def visit_and_rule(self, tree):
+        text = " and ".join(resolve_tree(c, keep_spacing=True) for c in tree.children if resolve_tree(c, keep_spacing=True))
+        return [[self.steps, self.prefix + text + self.suffix]]
+
+    def visit_emphasized(self, tree):
+        prompt = resolve_tree(tree.children[0], keep_spacing=True)
+        try:
+            weight = float(tree.children[1]) if len(tree.children) > 1 and isinstance(tree.children[1], lark.Token) and tree.children[1].type == "NUMBER" else 1.1
+        except (ValueError, TypeError):
+            weight = 1.1
+        return [[self.steps, self.prefix + f"({prompt}:{weight})" + self.suffix]]
+
+    def __call__(self, tree):
+        self.schedules = self.visit(tree)
+        # deduplicate identical entries while preserving order
+        uniq = []
+        seen = set()
+        for end_step, text in self.schedules or []:
+            key = (end_step, text)
+            if key not in seen:
+                uniq.append([end_step, text])
+                seen.add(key)
+        return uniq or [[self.steps, self.prefix + resolve_tree(tree, keep_spacing=True) + self.suffix]]
+
+def at_step_from_schedule(step: int, schedule: list[list[int | str]]) -> str:
+    """
+    schedule: [[end_step:int, text:str], ...] — по возрастанию end_step
+    Возвращает text, активный на переданном step.
+    """
+    if not schedule:
+        return ""
+    for end_step, text in schedule:
+        try:
+            if step <= int(end_step):
+                return text
+        except Exception:
+            # на всякий случай — если end_step внезапно не число
+            continue
+    return schedule[-1][1]
+
+def at_step(step: int, prompt_or_schedule, *, steps: int | None = None,
+            seed: int | None = 42, use_visitor: bool = True) -> str:
+    """
+    Универсальная обёртка:
+    - Если передали готовый schedule -> используем его
+    - Если передали строку промпта -> строим schedule и берём значение
+    """
+    # Готовый список [[end_step, text], ...]
+    if isinstance(prompt_or_schedule, list) and prompt_or_schedule and isinstance(prompt_or_schedule[0], list):
+        return at_step_from_schedule(step, prompt_or_schedule)
+
+    # Строка промпта
+    prompt = str(prompt_or_schedule)
+    if steps is None:
+        raise ValueError("steps is required when passing a prompt string to at_step(...)")
+    sched = get_schedule(prompt, steps, use_scheduling=True, seed=seed, use_visitor=use_visitor)
+    return at_step_from_schedule(step, sched)
+
+@lru_cache(maxsize=CACHE_SIZE)
+def _apply_and(text: str) -> str:
+    import re as _re
+    return _re.sub(r'\s*&\s*', ' and ', text)
+
+@lru_cache(maxsize=CACHE_SIZE)
+def get_schedule(prompt: str, steps: int, use_scheduling: bool, seed: int | None, use_visitor: bool = True):
+    import re as _re
+
+    # Пустой промпт → безопасный токен
+    if not str(prompt).strip():
+        return [[steps, SAFE_EMPTY]]
+    # Литеральные \n и \t -> реальные переводы/табуляции,
+    # чтобы одиночный m_seq не «съедал» две логические последовательности
+    if "\\n" in prompt or "\\t" in prompt:
+        prompt = prompt.replace("\\n", "\n").replace("\\t", "\t")
+    # --- Быстрые пути ---
+
+    # TL3: owner::: ... !!!
+    m_tl3 = _re.match(r'^\s*([^:\[\]\{\}\(\)]+?):::(.+?)!!!(?:,\s*(.*))?\s*$', prompt, _re.S)
+    if m_tl3:
+        owner, rest, trailing = m_tl3.groups()
+
+        # соберём части до "!!!"
+        parts = [p.strip() for p in rest.split(',') if p.strip()]
+        seq_texts = []
+        for seg in parts:
+            seg = seg.rstrip('!;').strip()
+            toks = [t.strip() for t in seg.split('::') if t.strip()]
+            if toks:
+                label, descs = toks[0], toks[1:]
+                s = f"{owner.strip()}: {label}"
+                if descs:
+                    s += f", {', '.join(descs)}"
+                seq_texts.append(s)
+
+        # НОВОЕ: распарсить хвост после "!!!," — если это sequence, преобразуем
+        trailing_texts = []
+        if trailing:
+            for t in trailing.split(','):
+                t = t.strip()
+                if not t:
+                    continue
+                # вид "weapon::sword!" или с ';'
+                mseq = _re.match(r'^\s*([^:\[\]\{\}\(\)]+?)::(.+?)([!;])\s*$', t)
+                if mseq:
+                    seq_owner, rest2, _term = mseq.groups()
+                    descs = [x.strip(' ,~!;') for x in rest2.split('::') if x.strip(' ,~!;')]
+                    trailing_texts.append(f"{seq_owner.strip()}: {', '.join(descs)}")
+                else:
+                    trailing_texts.append(t)
+
+        text = f"{owner.strip()} -> {', '.join(seq_texts)}"
+        if trailing_texts:
+            text += f", {', '.join(trailing_texts)}"
+        return [[steps, _apply_and(text)]]
+
+
+    # Numbered с квадратными скобками: "3![a|b|c]" или "3[a|b|c]"
+    m_num_alt = _re.match(r'^\s*(\d+)\s*([!_])?\s*\[([^\]]+)\]\s*$', str(prompt))
+    if m_num_alt:
+        import random as _rnd
+        qty_txt, mark, inner = m_num_alt.groups()
+        quantity = int(qty_txt)
+        options = [x.strip() for x in inner.split('|')]
+        options = [opt if opt else SAFE_EMPTY for opt in options]
+        options_unique = list(dict.fromkeys(options)) or [SAFE_EMPTY]
+        if mark:  # distinct
+            if quantity <= len(options_unique):
+                chosen = options_unique[:quantity]
+            else:
+                need = quantity - len(options_unique)
+                pad = (options_unique * ((need + len(options_unique) - 1)//len(options_unique)))[:need]
+                chosen = options_unique + pad
+        else:  # с повторами
+            rng = _rnd.Random(seed) if seed is not None else _rnd
+            chosen = rng.choices(options_unique, k=quantity)
+        return [[steps, ', '.join(chosen)]]
+
+    # '[a:b:...:N]' (+ префикс/суффикс)
+    m_inner = _re.match(r'^(.*)\[(.*?)\](.*)$', prompt)
+    if m_inner and ':' in m_inner.group(2) and '|' not in m_inner.group(2):
+        pre, inner, post = m_inner.groups()
+        parts = [p.strip() for p in inner.split(':') if p.strip()]
+        try:
+            if len(parts) >= 2 and _re.fullmatch(r'[-+]?(?:\d+(?:\.\d+)?|\.\d+)(?:[eE][+-]?\d+)?', parts[-1]):
+                boundary_f = float(parts[-1])
+                prompts = parts[:-1]
+                clamp = lambda x: max(1, min(int(round(x)), steps))
+                boundary = clamp(boundary_f if boundary_f > 1.0 else boundary_f * steps)
+                if len(prompts) == 1:
+                    return [[boundary, f"{pre}{post}"], [steps, f"{pre}{prompts[0]}{post}"]]
+                if prompts:
+                    b = max(boundary, len(prompts))
+                    step_size = b / len(prompts)
+                    schedules = []
+                    if int(round(step_size)) > 1:
+                        schedules.append([1, f"{pre}{post}"])
+                    for i, ptxt in enumerate(prompts):
+                        start = clamp(int(round(i * step_size)) + 1)
+                        end   = clamp(int(round((i + 1) * step_size)))
+                        if start < end:
+                            schedules.append([end, f"{pre}{ptxt}{post}"])
+                    if schedules and schedules[-1][0] < steps:
+                        schedules.append([steps, f"{pre}{prompts[-1]}{post}"])
+                    return [[e, _apply_and(t)] for e, t in schedules] or [[steps, f"{pre}{prompts[-1]}{post}"]]
+        except Exception:
+            pass
+
+    # '[...]:N' c префиксом/суффиксом
+    m_with_pre = _re.match(r'^(.*)\[(.*?)\]\s*:\s*([-+]?(?:\d+(?:\.\d+)?|\.\d+)(?:[eE][+-]?\d+)?)\s*(.*)$', prompt)
+    if m_with_pre:
+        pre, inner, boundary_txt, post = m_with_pre.groups()
+        try:
+            boundary_f = float(boundary_txt)
+            clamp = lambda x: max(1, min(int(round(x)), steps))
+            boundary = clamp(boundary_f if boundary_f > 1.0 else boundary_f * steps)
+            inner_prompts = [p.strip() for p in inner.split(':') if p.strip()]
+            if len(inner_prompts) == 1:
+                return [[boundary, f"{pre}{post}"], [steps, f"{pre}{inner_prompts[0]}{post}"]]
+        except Exception:
+            pass
+
+    # '[...]:N' простой
+    m_simple = _re.match(r'^\s*\[(.*?)\]\s*:\s*([-+]?(?:\d+(?:\.\d+)?|\.\d+)(?:[eE][+-]?\d+)?)\s*$', prompt)
+    if m_simple:
+        inner, boundary_txt = m_simple.groups()
+        try:
+            boundary_f = float(boundary_txt)
+            clamp = lambda x: max(1, min(int(round(x)), steps))
+            boundary = clamp(boundary_f if boundary_f > 1.0 else boundary_f * steps)
+            return [[boundary, ""], [steps, inner.strip()]]
+        except Exception:
+            pass
+
+    # 'owner::...!!' (, trailing)?
+    m_toplevel = _re.match(r'^\s*([^:\[\]\{\}\(\)]+?)::(.+?)!!(?:,\s*(.*))?\s*$', prompt)
+    if m_toplevel:
+        owner, rest, trailing = m_toplevel.groups()
+
+        # основная часть до "!!"
+        descriptors = [x.strip(' ,~!;') for x in rest.split('::') if x.strip(' ,~!;')]
+        seqs = [f"{owner.strip()}: {', '.join(descriptors)}"] if descriptors else []
+
+        # НОВОЕ: ра��парсить хвост после "!!," — если это sequence, преобразуем
+        trailing_texts = []
+        if trailing:
+            for t in trailing.split(','):
+                t = t.strip()
+                if not t:
+                    continue
+                # вид "weapon::sword!" или с ';'
+                mseq = _re.match(r'^\s*([^:\[\]\{\}\(\)]+?)::(.+?)([!;])\s*$', t)
+                if mseq:
+                    seq_owner, rest2, _term = mseq.groups()
+                    descs = [
+                        x.strip(' ,~!;') for x in rest2.split('::') if x.strip(' ,~!;')
+                    ]
+                    trailing_texts.append(f"{seq_owner.strip()}: {', '.join(descs)}")
+                else:
+                    trailing_texts.append(t)
+
+        out = f"{owner.strip()} -> {seqs[0] if seqs else ''}".rstrip()
+        if trailing_texts:
+            out += f", {', '.join(trailing_texts)}"
+        return [[steps, _apply_and(out)]]
+
+
+    # 'owner::...!' или ';'
+    m_seq = _re.match(r'^\s*([^:\[\]\{\}\(\)]+?)::(.+?)([!;])\s*$', prompt)
+    if m_seq and '|' not in prompt and '[' not in prompt and ']' not in prompt and '(' not in prompt and ')' not in prompt:
+        owner, rest, _term = m_seq.groups()
+        descriptors = [x.strip(' ,~!;') for x in rest.split('::') if x.strip(' ,~!;')]
+        return [[steps, _apply_and(f"{owner.strip()}: {', '.join(descriptors)}")]]
+
+    # Явные диапазоны: "[...]:N a-b,c-d [r]"
+    m_ranges = _re.match(r'^\s*\[([^\]]+)\]\s*:\s*([-+]?(?:\d+(?:\.\d+)?|\.\d+)(?:[eE][+-]?\d+)?)\s+([0-9%\-\s,]+)(?:\s+(r|reverse))?\s*$', prompt)
+    if m_ranges:
+        inner, steps_txt, ranges_txt, rev = m_ranges.groups()
+
+        def _to_steps(txt: str) -> int:
+            s = txt.strip()
+            if s.endswith('%'):
+                try:
+                    return max(1, min(steps, int(round(float(s[:-1]) / 100.0 * steps))))
+                except Exception:
+                    return 1
+            try:
+                return max(1, min(steps, int(round(float(s)))))
+            except Exception:
+                return 1
+
+        prompts = [p.strip() for p in inner.split(':') if p.strip()]
+        if rev:
+            prompts = list(reversed(prompts))
+
+        ranges = []
+        for part in ranges_txt.split(','):
+            if '-' in part:
+                a, b = part.split('-', 1)
+                ra, rb = _to_steps(a), _to_steps(b)
+                if ra < rb:
+                    ranges.append((ra, rb))
+
+        schedules = []
+        if ranges and ranges[0][0] > 1:
+            schedules.append([ranges[0][0] - 1, ""])
+        for i, (start, end) in enumerate(ranges[:len(prompts)]):
+            schedules.append([min(end, steps), prompts[i]])
+        if ranges and ranges[-1][1] < steps and prompts:
+            schedules.append([steps, prompts[-1]])
+        return [[e, _apply_and(t)] for e, t in schedules] or [[steps, _apply_and(inner.strip())]]
+
+    # --- обычный парсинг Lark ---
+    try:
+        tree = schedule_parser.parse(prompt)
+    except lark.exceptions.LarkError as e:
+        logger.warning("Prompt parse failed: '%s' — %s", prompt, e)
+        return [[steps, prompt]]
+
+    collector = CollectSteps(steps, use_scheduling=use_scheduling, seed=seed)
+    schedules = collector(tree)
+    try:
+        schedules.sort(key=lambda x: int(x[0]))
+    except Exception:
+        pass
+    if not schedules:
+        return [[steps, prompt]]
+
+    if not use_visitor:
+        rebuilt = []
+        for end_step, _ in schedules:
+            transformer = ScheduleTransformer(total_steps=steps, current_step=end_step, seed=seed)
+            text = transformer.transform(tree)
+            rebuilt.append([end_step, _apply_and(text)])
+        return rebuilt
+
+    return [[e, _apply_and(t)] for e, t in schedules]
+    
+def get_learned_conditioning_prompt_schedules(
+    prompts: list[str],
+    base_steps: int,
+    hires_steps: int | None = None,
+    use_old_scheduling: bool = False,
+    seed: int | None = 42,
+    use_visitor: bool = True,
+):
+    """
+    Возвращает список расписаний по одному на каждый промпт:
+        [
+          [[end_step, text], ...],   # для prompts[0]
+          [[end_step, text], ...],   # для prompts[1]
+          ...
+        ]
+    """
+    # Выбор количества шагов по правилам A1111-совместимости
+    steps = hires_steps if (hires_steps is not None and not use_old_scheduling) else base_steps
+    # Когда включать "расписания": если нет hires_steps или явно просили старый режим
+    use_scheduling = (hires_steps is None) or use_old_scheduling
+
+    # Аккуратный проход по каждому промпту через кэшируемую get_schedule(...)
+    prompt_schedules = [
+        get_schedule(p, steps, use_scheduling, seed, use_visitor=use_visitor)
+        for p in prompts
+    ]
+    return prompt_schedules
+    
+ScheduledPromptConditioning = namedtuple("ScheduledPromptConditioning", ["end_at_step", "cond"])
+
+class SdConditioning(list):
+    def __init__(self, prompts, is_negative_prompt=False, width=None, height=None, copy_from=None):
+        super().__init__()
+        self.extend(prompts)
+        if copy_from is None:
+            copy_from = prompts
+        self.is_negative_prompt = is_negative_prompt or getattr(copy_from, 'is_negative_prompt', False)
+        self.width = width or getattr(copy_from, 'width', None)
+        self.height = height or getattr(copy_from, 'height', None)
+
+def get_learned_conditioning(model, prompts: SdConditioning | list[str], steps, hires_steps=None, use_old_scheduling=False):
+    res = []
+    prompt_schedules = get_learned_conditioning_prompt_schedules(prompts, steps, hires_steps, use_old_scheduling)
+    cache = {}
+
+    for prompt, prompt_schedule in zip(prompts, prompt_schedules):
+        if not prompt_schedule:
+            raise ValueError(f"Empty schedule for prompt '{prompt}'")
+        cached = cache.get(prompt, None)
+        if cached is not None:
+            res.append(cached)
+            continue
+
+        texts = SdConditioning([x[1] for x in prompt_schedule], copy_from=prompts)
+        conds = model.get_learned_conditioning(texts)
+        cond_schedule = []
+
+        for i, (end_at_step, _) in enumerate(prompt_schedule):
+            if isinstance(conds, dict):
+                cond = {k: v[i] for k, v in conds.items()}
+            else:
+                cond = conds[i]
+            cond_schedule.append(ScheduledPromptConditioning(end_at_step, cond))
+
+        cache[prompt] = cond_schedule
+        res.append(cond_schedule)
+
+    return res
+    
+def get_multicond_learned_conditioning(model, prompts: SdConditioning | list[str], steps, hires_steps=None, use_old_scheduling=False):
+    steps = hires_steps if hires_steps is not None and not use_old_scheduling else steps
+    prompt_schedules = get_learned_conditioning_prompt_schedules(prompts, steps, hires_steps, use_old_scheduling)
+    conds_list, prompt_flat_list, prompt_indexes = get_multicond_prompt_list(prompts)
+    
+    cache = {}
+    res = []
+    for prompt, schedule, conds in zip(prompts, prompt_schedules, conds_list):
+        if not schedule:
+            raise ValueError(f"Empty schedule for prompt '{prompt}'")
+        cached = cache.get(prompt, None)
+        if cached is not None:
+            res.append(cached)
+            continue
+        
+        texts = SdConditioning([str(x[1]) for x in schedule], copy_from=prompts)
+        try:
+            model_conds = model.get_learned_conditioning(texts)
+        except Exception:
+            raise ValueError(f"Conditioning failed for prompt '{prompt}'")
+        
+        prompt_schedule = []
+        for index, weight in conds:
+            cond_schedule = []
+            for i, (end_at_step, _) in enumerate(schedule):
+                try:
+                    end_at_step = int(end_at_step)
+                except ValueError:
+                    raise ValueError(f"Invalid step boundary in schedule for prompt '{prompt}'")
+                if isinstance(model_conds, dict):
+                    cond = {k: v[i] for k, v in model_conds.items()}
+                else:
+                    cond = model_conds[i]
+                cond_schedule.append(ScheduledPromptConditioning(end_at_step, cond))
+            prompt_schedule.append(ComposableScheduledPromptConditioning(cond_schedule, weight))
+        
+        shape = model_conds.shape if not isinstance(model_conds, dict) else model_conds['crossattn'].shape
+        cache[prompt] = MulticondLearnedConditioning(shape, [prompt_schedule])
+        res.append(cache[prompt])
+    
+    shapes = {r.shape for r in res}
+    if len(shapes) > 1:
+        raise ValueError("Inconsistent tensor shapes across subprompts.")
+    
+    if len(res) == 1:
+        return res[0]
+    # склейка батчей из нескольких MulticondLearnedConditioning
+    agg_batch = []
+    for mc in res:
+        agg_batch.extend(mc.batch)
+    return MulticondLearnedConditioning(shapes.pop(), agg_batch)
+
+re_AND = re.compile(r"\bAND\b(?!_PERP|_SALT|_TOPK)", re.I)
+re_weight = re.compile(r"^((?:\s|.)*?)(?:\s*:\s*([-+]?(?:\d+\.?\d*|\d*\.\d+)(?:[eE][-+]?\d+)?))?\s*$")
+
+def get_multicond_prompt_list(prompts: SdConditioning | list[str]):
+    res_indexes = []
+    prompt_indexes = {}
+    prompt_flat_list = SdConditioning(prompts)
+    prompt_flat_list.clear()
+
+    for prompt in prompts:
+        subprompts = re_AND.split(prompt)
+        indexes = []
+        for subprompt in subprompts:
+            match = re_weight.search(subprompt)
+            text, weight = match.groups() if match is not None else (subprompt, 1.0)
+
+            # Нормализация пустых подпрамптов → SAFE_EMPTY
+            text = (text or "").strip()
+            if not text:
+                text = SAFE_EMPTY
+
+            try:
+                weight = float(weight) if weight is not None else 1.0
+            except ValueError:
+                weight = 1.0
+
+            index = prompt_indexes.get(text, None)
+            if index is None:
+                index = len(prompt_flat_list)
+                prompt_flat_list.append(text)
+                prompt_indexes[text] = index
+
+            indexes.append((index, weight))
+        res_indexes.append(indexes)
+
+    return res_indexes, prompt_flat_list, prompt_indexes
+
+
+class ComposableScheduledPromptConditioning:
+    def __init__(self, schedules, weight=1.0):
+        self.schedules: list[ScheduledPromptConditioning] = schedules
+        self.weight: float = weight
+
+class MulticondLearnedConditioning:
+    def __init__(self, shape, batch):
+        self.shape: tuple = shape
+        self.batch: list[list[ComposableScheduledPromptConditioning]] = batch
+
+class DictWithShape(dict):
+    def __init__(self, x, shape=None):
+        super().__init__()
+        self.update(x)
+        self._shape = shape
+
+    @property
+    def shape(self):
+        if self._shape is not None:
+            return self._shape
+        any_val = self.get("crossattn")
+        if any_val is None and self:
+            any_val = next(iter(self.values()))
+        return getattr(any_val, "shape", None)
+        
+def reconstruct_cond_batch(c: list[list[ScheduledPromptConditioning]], current_step):
+    import torch
+    if not c or not c[0]:
+        raise ValueError("Empty conditioning schedule")
+    param = c[0][0].cond
+    if param is None:
+        raise ValueError("Invalid conditioning parameter")
+    is_dict = isinstance(param, dict)
+    if is_dict:
+        dict_cond = param
+        res = {k: torch.zeros((len(c),) + v.shape, device=getattr(v, "device", "cpu"), dtype=getattr(v, "dtype", torch.float32)) for k, v in dict_cond.items()}
+        res = DictWithShape(res, (len(c),) + dict_cond.get('crossattn', next(iter(dict_cond.values()))).shape)
+    else:
+        res = torch.zeros((len(c),) + param.shape, device=getattr(param, "device", "cpu"), dtype=getattr(param, "dtype", torch.float32))
+
+    for i, cond_schedule in enumerate(c):
+        target_index = 0
+        for current, entry in enumerate(cond_schedule):
+            if current_step <= entry.end_at_step:
+                target_index = current
+                break
+        if is_dict:
+            for k, v in cond_schedule[target_index].cond.items():
+                res[k][i] = v
+        else:
+            res[i] = cond_schedule[target_index].cond
+    return res
+
+def stack_conds(tensors):
+    import torch
+    token_count = max([x.shape[0] for x in tensors])
+    for i in range(len(tensors)):
+        if tensors[i].shape[0] != token_count:
+            last_vector = tensors[i][-1: ]
+            last_vector_repeated = last_vector.repeat([token_count - tensors[i].shape[0], 1])
+            tensors[i] = torch.vstack([tensors[i], last_vector_repeated])
+    return torch.stack(tensors)
+
+def reconstruct_multicond_batch(c: MulticondLearnedConditioning, current_step):
+    import torch
+    if not c.batch or not c.batch[0]:
+        raise ValueError("Empty multicond batch")
+    param = c.batch[0][0].schedules[0].cond
+    if param is None:
+        raise ValueError("Invalid conditioning parameter")
+    tensors = []
+    conds_list = []
+    for composable_prompts in c.batch:
+        conds_for_batch = []
+        for composable_prompt in composable_prompts:
+            target_index = 0
+            for current, entry in enumerate(composable_prompt.schedules):
+                try:
+                    end_at_step = int(entry.end_at_step)
+                except ValueError:
+                    end_at_step = current_step
+                if current_step <= end_at_step:
+                    target_index = current
+                    break
+            conds_for_batch.append((len(tensors), composable_prompt.weight))
+            tensors.append(composable_prompt.schedules[target_index].cond)
+        conds_list.append(conds_for_batch)
+
+    if isinstance(tensors[0], dict):
+        keys = list(tensors[0].keys())
+        stacked = {k: stack_conds([x[k] for x in tensors]) for k in keys}
+        stacked = DictWithShape(stacked, stacked.get('crossattn', next(iter(stacked.values()))).shape)
+    else:
+        stacked = stack_conds(tensors).to(device=getattr(param, "device", "cpu"), dtype=getattr(param, "dtype", torch.float32))
+    return conds_list, stacked
+
+re_attention = re.compile(r"""
+\\\(|
+\\\)|
+\\\[|
+\\]|
+\\\\|
+\\|
+\(|
+\[|
+:\s*([+-]?(?:\d+(?:\.\d+)?|\.\d+)(?:[eE][+-]?\d+)?)\s*\)|
+\)|
+]|
+[^\\()\[\]:]+|
+:
+""", re.X)
+
+re_break = re.compile(r"\s*\bBREAK\b\s*", re.S)
+
+def parse_prompt_attention(text):
+    # пустой ввод -> безопасный токен
+    if not text or not str(text).strip():
+        return [[SAFE_EMPTY, 1.0]]
+
+    # normalize newlines to spaces for stable tokenization
+    text = str(text).replace('\r\n', '\n').replace('\r', '\n')
+    text = text.replace('\n', ' ').replace('\\n', ' ')
+
+    res = []
+    round_brackets = []
+    square_brackets = []
+    round_bracket_multiplier = 1.1
+    square_bracket_multiplier = 1 / 1.1
+
+    def multiply_range(start_position, multiplier):
+        for p in range(start_position, len(res)):
+            res[p][1] *= multiplier
+
+    pending_colon = False
+    last_token_index = -1
+
+    for m in re_attention.finditer(text):
+        text_match = m.group(0)
+        wgrp = m.group(1)  # число для ( ... : <num> )
+
+        if text_match.startswith('\\'):
+            res.append([text_match[1:], 1.0])
+            last_token_index = len(res) - 1
+
+        elif text_match == '(':
+            round_brackets.append(len(res)); pending_colon = False
+
+        elif text_match == '[':
+            square_brackets.append(len(res)); pending_colon = False
+
+        elif wgrp is not None and round_brackets:
+            try:
+                multiply_range(round_brackets.pop(), float(wgrp))
+            except ValueError:
+                multiply_range(round_brackets.pop(), 1.0)
+            pending_colon = False
+
+        elif text_match == ')' and round_brackets:
+            multiply_range(round_brackets.pop(), round_bracket_multiplier)
+            pending_colon = False
+
+        elif text_match == ']' and square_brackets:
+            multiply_range(square_brackets.pop(), square_bracket_multiplier)
+            pending_colon = False
+
+        elif text_match == ':' and not round_brackets and not square_brackets:
+            if 'SUPPRESS_STANDALONE_COLON' in globals() and SUPPRESS_STANDALONE_COLON:
+                pending_colon = True
+            else:
+                res.append([':', 1.0])
+                last_token_index = len(res) - 1
+                pending_colon = False
+
+        else:
+            chunk = text_match
+
+            if pending_colon and not (round_brackets or square_brackets):
+                # применяем число после ':' к предыдущему НОРМАЛЬНОМУ токену
+                mnum = re.match(r"^\s*([-+]?(?:\d+(?:\.\d+)?|\.\d+)(?:[eE][+-]?\d+)?)", chunk)
+                if mnum:
+                    j = last_token_index
+                    while j >= 0 and res[j][0] in (':', 'BREAK'):
+                        j -= 1
+                    if j >= 0:
+                        try:
+                            res[j][1] = float(mnum.group(1))
+                            chunk = chunk[mnum.end():]
+                        except ValueError:
+                            pass
+                pending_colon = False
+
+            # режем по BREAK
+            parts = re.split(re_break, chunk)
+            for i, part in enumerate(parts):
+                if i > 0:
+                    res.append(["BREAK", -1])
+                s = part.strip()
+                if not s:
+                    continue
+                if ('SUPPRESS_STANDALONE_COLON' in globals() and SUPPRESS_STANDALONE_COLON) and s == ":":
+                    continue
+                res.append([s, 1.0])
+                last_token_index = len(res) - 1
+
+    if round_brackets or square_brackets:
+        pass
+
+    if not res:
+        return [[SAFE_EMPTY, 1.0]]
+
+    # второй проход: word:weight ИЛИ word±weight
+    rx_inline = re.compile(
+        r'(?:'
+        r'(\b[^\s:(){}\[\]]+)\s*:\s*'  # g1: word
+        r'([-+]?(?:\d+(?:\.\d+)?|\.\d+)(?:[eE][+-]?\d+)?)'  # g2: weight
+        r')|(?:'
+        r'(\b[^\s:(){}\[\]]+)\s*'      # g3: word
+        r'([-+](?:\d+(?:\.\d+)?|\.\d+)(?:[eE][+-]?\d+)?)'   # g4: weight with sign
+        r')'
+    )
+
+    new_res = []
+    for txt, w in res:
+        if txt == "BREAK" or w != 1.0:
+            new_res.append([txt, w])
+            continue
+        pos = 0; changed = False
+        for mm in rx_inline.finditer(txt):
+            pre = txt[pos:mm.start()]
+            if pre and pre.strip().upper() != "AND":
+                new_res.append([pre, 1.0])
+            if mm.group(1) is not None:
+                word, wt = mm.group(1), float(mm.group(2))
+            else:
+                word, wt = mm.group(3), float(mm.group(4))
+            new_res.append([word, wt]); changed = True
+            pos = mm.end()
+        if changed:
+            tail = txt[pos:]
+            if tail:
+                new_res.append([tail, 1.0])
+        else:
+            new_res.append([txt, w])
+    res = new_res
+
+    # убираем лидирующее "AND "
+    norm = []
+    for t, w in res:
+        if t != "BREAK":
+            nt = re.sub(r'^\s*AND\s+', '', t, flags=re.I).strip()
+            if nt:
+                norm.append([nt, w])
+        else:
+            norm.append([t, w])
+    res = norm
+
+    # схлопываем соседей с одинаковым весом
+    i = 0
+    while i + 1 < len(res):
+        if res[i][1] == res[i + 1][1] and res[i][0] not in (':','BREAK') and res[i + 1][0] not in (':','BREAK'):
+            res[i][0] += res[i + 1][0]
+            res.pop(i + 1)
+        else:
+            i += 1
+
+    return res
+
+if __name__ == "__main__":
+    import doctest, random
+    doctest.testmod(optionflags=doctest.NORMALIZE_WHITESPACE)
+    random.seed(42)
+
+    g = lambda p: get_learned_conditioning_prompt_schedules([p], 10)[0]
+
+    # scheduled — базовые
+    assert g("test") == [[10, 'test']]
+    assert g("a [b:3]") == [[3, 'a '], [10, 'a b']]
+    assert g("[(a:2):3]") == [[3, ''], [10, '(a:2)']]
+
+    # grouped — лимит не нарушаем (на больших группах просто проверить длину)
+    big = "{[a|b|c|d|e|f|g],[h|i|j|k|l|m|n],[o|p|q|r|s|t|u]}"
+    res = g(big)
+    assert len(res) <= GROUP_COMBO_LIMIT
+
+    # numbered — distinct (! и _)
+    # здесь сравни повторы/без повторов по длине множества выбранных
+    # (если хочется — можно парсить строку и split(', '))
+
+    # alternate_distinct — фиксированный выбор
+    g2 = lambda p: get_learned_conditioning_prompt_schedules([p], 6)[0]
+    one = g2("[cat|dog|fox]!")
+    assert len(set([txt for _, txt in one])) == 1  # один и тот же вариант на всех шагах
+
+    print("All integration tests passed!")

sd_simple_kes_v1/simple_kes_v1.py

@@ -0,0 +1,457 @@
+import torch
+import logging
+from modules.sd_simple_kes_v1.get_sigmas import get_sigmas_karras, get_sigmas_exponential 
+import os
+import yaml
+import random
+from datetime import datetime
+import warnings
+import math
+from typing import Optional
+import json
+from modules.sd_simple_kes_v1.validate_config import validate_config
+
+
+
+def simple_kes_scheduler_v1(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 = "cuda", logger=None, **kwargs)->torch.Tensor:         
+        self.steps = n if n is not None else 25         
+        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_v1", "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)
+    
+          
+                     
+    
+    def __call__(self):        
+        sigmas = self.compute_sigmas()
+        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")
+
+        self.save_generation_settings()
+        return sigmas
+      
+    def save_generation_settings(self):
+        timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+        folder = os.path.join("modules", "sd_simple_kes_v1", "image_generation_data")
+        os.makedirs(folder, exist_ok=True)
+        filename = os.path.join(folder, f"generation_log_{timestamp}.txt")
+
+        with open(filename, "w") as f:
+            for line in self.logger.log_buffer:  # 🔄 Use logger's buffer
+                f.write(f"{line}\n")
+
+        self.log(f"[SimpleKEScheduler] Generation log saved to {filename}")
+        self.logger.log_buffer.clear()  # 🔄 Clear logger’s buffer, not self.log_buffer   
+    
+    def load_config(self):
+        try:
+            with open(self.config_path, 'r') 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 start_sigmas(self, steps, sigma_min, sigma_max, device):
+        """Retrieve randomized sigma_min and sigma_max using the structured randomizer, respecting auto mode."""
+        #self.log(f"[DEBUG Start Sigmas] Using pre-randomized sigma_min={self.sigma_min}, sigma_max={self.sigma_max}")
+        # Apply auto scaling if enabled       
+
+        # Ensure sigma_min is less than sigma_max
+        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}")
+        return steps, self.sigma_min, self.sigma_max, device
+    
+    def compute_sigmas(self)->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)
+
+        """
+        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.
+        """
+             
+                  
+        # Use the self.get_random_or_default function for each parameter
+        #if randomize = false, then it checks for each variable for randomize, if true, then that particular option is randomized, with the others using default or config defined 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)    
+         
+        
+        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}")
+
+        # 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
+            
+        # Now it's safe to compute sigmas
+        start = math.log(self.sigma_max)
+        end = math.log(self.sigma_min)
+        self.sigmas = torch.linspace(start, end, self.steps, device=self.device).exp()       
+
+        # Ensure sigmas contain valid values before using them
+        if torch.any(self.sigmas > 0):  
+            self.sigma_min, self.sigma_max = self.sigmas[self.sigmas > 0].min(), self.sigmas.max()            
+        else:
+            # If sigmas 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}")
+            
+        self.log(f"Using device: {self.device}")
+        # Generate sigma sequences using Karras and Exponential methods
+        self.start_sigmas(steps=self.steps, sigma_min=self.sigma_min, sigma_max=self.sigma_max, device=self.device)
+        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) 
+        #self.log(f"[DEBUG] Randomized Values: sigma_min={self.sigma_min}, sigma_max={self.sigma_max}")
+                  
+        # Match lengths of sigma sequences
+        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}")
+        
+         # Expand sigma_max slightly to account for smoother transitions  
+        self.sigma_max = self.sigma_max * 1.1
+      
+        # Define progress and initialize blend factor
+        self.progress = torch.linspace(0, 1, len(self.sigmas_karras)).to(self.device)        
+        meaningful_steps = len(self.progress) - 1  # Adjust for appended zero step        
+        self.log(f"[Progress Initialized] Created progress tensor with {meaningful_steps} steps (excluding terminal step) on device: {self.device}")
+
+
+        
+        sigs = torch.zeros_like(self.sigmas_karras).to(self.device)
+        self.log(f"[Initialization] Pre-allocated empty sigma sequence with shape: torch.Size([{meaningful_steps}]) on device: {self.device}")
+       
+
+        # Iterate through each step, dynamically adjust blend factor, step size, and noise scaling        
+        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])
+        #self.log(f"[Padding] Adjusted sigma sequences to matching length: {meaningful_steps + 1} steps.")
+        for i in range(len(self.sigmas_karras)):    
+                  
+            # Adaptive step size and blend factor calculations
+            self.step_size = self.initial_step_size * (1 - self.progress[i]) + self.final_step_size * self.progress[i] * self.step_size_factor  # 0.8 default value Adjusted to avoid over-smoothing
+            
+            self.dynamic_blend_factor = self.start_blend * (1 - self.progress[i]) + self.end_blend * self.progress[i]            
+            self.noise_scale = self.initial_noise_scale * (1 - self.progress[i]) + self.final_noise_scale * self.progress[i] * self.noise_scale_factor  
+            smooth_blend = torch.sigmoid((self.dynamic_blend_factor - 0.5) * self.smooth_blend_factor) # Increase scaling factor to smooth transitions more           
+            
+            # Compute blended sigma values
+            blended_sigma = self.sigmas_karras[i] * (1 - smooth_blend) + self.sigmas_exponential[i] * smooth_blend           
+            
+            # Apply step size and noise scaling
+            sigs[i] = blended_sigma * self.step_size * self.noise_scale
+
+        # Optional: Adaptive sharpening based on sigma values
+        self.sharpen_mask = torch.where(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.log(f"[Sharpen Mask] Sharpening applied at steps: {sharpen_indices}")
+        #self.log(f"sharpen_mask created {self.sharpen_mask} with device {self.device}"   )
+        sigs = sigs * self.sharpen_mask
+        #self.log(f"Sigs after sharpen_mask: {sigs}")
+        
+        # Implement early stop criteria based on sigma convergence
+        change = torch.abs(sigs[1:] - sigs[:-1])
+        if torch.all(change < self.early_stopping_threshold):
+            self.log("Early stopping criteria met."   )
+            return sigs[:len(change) + 1].to(self.device)
+        
+        if torch.isnan(sigs).any() or torch.isinf(sigs).any():
+            raise ValueError("Invalid sigma values detected (NaN or Inf).")
+
+        return sigs.to(self.device)

sd_simple_kes_v1/validate_config.py

@@ -0,0 +1,65 @@
+from typing import Optional, Dict, Any
+
+
+RANDOMIZATION_TYPE_ALIASES = {
+    'symmetric': 'symmetric', 'sym': 'symmetric', 's': 'symmetric',
+    'asymmetric': 'asymmetric', 'assym': 'asymmetric', 'a': 'asymmetric',
+    'off': 'off', 'none': 'off'
+}
+
+DEFAULT_RANDOMIZATION_TYPE = 'asymmetric'
+DEFAULT_RANDOMIZATION_PERCENT = 0.2
+
+
+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)
+
+    # Correction for negative base values
+    for key, value in config.items():
+        if isinstance(value, (int, float)) and not key.endswith(('_rand', '_rand_min', '_rand_max', '_randomization_percent')):  # Skip randomization booleans and ranges
+            if value < 0:
+                updated_config[key] = abs(value)
+                log(f"[Config Correction] {key} was negative. Converted to absolute value: {updated_config[key]}")
+
+    # Existing randomization validation...
+    for key, value in config.items():
+        if key.endswith('_rand'):
+            base_key = key.replace('_rand', '')
+
+            if not isinstance(value, bool):
+                updated_config[key] = False
+                log(f"[Config Correction] {key} was not boolean. Set to False.")
+
+            type_key = f"{base_key}_randomization_type"
+            if type_key not in config:
+                updated_config[type_key] = 'asymmetric'
+                log(f"[Config Correction] {type_key} missing. Set to 'asymmetric'.")
+
+            percent_key = f"{base_key}_randomization_percent"
+            if percent_key not in config:
+                updated_config[percent_key] = 0.2
+                log(f"[Config Correction] {percent_key} missing. Set to 0.2.")
+
+            min_key = f"{base_key}_rand_min"
+            max_key = f"{base_key}_rand_max"
+            if base_key in config:
+                base_value = updated_config[base_key]  # Updated with absolute value if needed
+                percent = updated_config[percent_key]
+
+                if min_key not in config:
+                    updated_config[min_key] = base_value * (1 - percent)
+                    log(f"[Config Correction] {min_key} missing. Auto-calculated from base.")
+
+                if max_key not in config:
+                    updated_config[max_key] = base_value * (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
+