Update 3-bmab/sd_bmab/sd_override/txt2img.py

3-bmab/sd_bmab/sd_override/txt2img.py

@@ -144,38 +144,94 @@ def create_random_tensors(shape, seeds, subseeds=None, subseed_strength=0.0, see
         return self.sample_hr_pass(samples, decoded_samples, seeds, subseeds, subseed_strength, prompts)
     
     def sample_progressive(self, conditioning, unconditional_conditioning, seeds, subseeds, subseed_strength, prompts):
-        is_sdxl = getattr(self.sd_model, 'is_sdxl', False)
+        import numpy as np
+        import torch
+
+        # SDXL больше НЕ клампим: используем ровно то, что пришло из UI
+        min_scale = float(self.progressive_growing_min_scale)
+        max_scale = float(self.progressive_growing_max_scale)
+        steps_cnt = int(self.progressive_growing_steps)
+
+        # Если хочешь позволять "shrink", оставь как есть.
+        # Если нужен только рост, раскомментируй:
+        # if min_scale > max_scale:
+        #     min_scale, max_scale = max_scale, min_scale
+
+        # Равномерные масштабы без SDXL-клампов
+        resolution_steps = np.linspace(min_scale, max_scale, steps_cnt)
+
+        # Вспомогательно: привести к кратности opt_f и не дать упасть до 0
+        def _snap(v: float) -> int:
+            from modules.processing import opt_f
+            x = int(v)
+            x = max(opt_f, x)
+            x = (x // opt_f) * opt_f
+            return max(opt_f, x)
+
+        # Стартовое разрешение (никаких 512/1536 клампов)
+        initial_width = _snap(self.width * resolution_steps[0])
+        initial_height = _snap(self.height * resolution_steps[0])
+
+        from modules.processing import opt_C, create_random_tensors, decode_latent_batch
+        from modules import devices
+
+        x = create_random_tensors(
+            (opt_C, initial_height // opt_f, initial_width // opt_f),
+            seeds,
+            subseeds=subseeds,
+            subseed_strength=subseed_strength,
+            seed_resize_from_h=self.seed_resize_from_h,
+            seed_resize_from_w=self.seed_resize_from_w,
+            p=self
+        )
+
+        samples = self.sampler.sample(
+            self,
+            x,
+            conditioning,
+            unconditional_conditioning,
+            image_conditioning=self.txt2img_image_conditioning(x)
+        )
+
+        total_stages = len(resolution_steps)
+
+        for i in range(1, total_stages):
+            target_width = _snap(self.width * resolution_steps[i])
+            target_height = _snap(self.height * resolution_steps[i])
+
+            # Ресэмпл латентов до следующего шага без SDXL-клампов
+            samples = torch.nn.functional.interpolate(
+                samples,
+                size=(target_height // opt_f, target_width // opt_f),
+                mode='bicubic',
+                align_corners=False
+            )
 
-        if is_sdxl:
-            min_scale = max(0.5, self.progressive_growing_min_scale)
-        else:
-            min_scale = self.progressive_growing_min_scale
-
-        resolution_steps = np.linspace(min_scale, self.progressive_growing_max_scale, self.progressive_growing_steps)
-
-        initial_width = max(512 if is_sdxl else 64, int(self.width * resolution_steps[0]))
-        initial_height = max(512 if is_sdxl else 64, int(self.height * resolution_steps[0]))
-
-        x = create_random_tensors((opt_C, initial_height // opt_f, initial_width // opt_f), seeds, subseeds=subseeds, subseed_strength=subseed_strength, seed_resize_from_h=self.seed_resize_from_h, seed_resize_from_w=self.seed_resize_from_w, p=self)
-        samples = self.sampler.sample(self, x, conditioning, unconditional_conditioning, image_conditioning=self.txt2img_image_conditioning(x))
-
-        for i in range(1, len(resolution_steps)):
-            target_width = int(self.width * resolution_steps[i])
-            target_height = int(self.height * resolution_steps[i])
-
-            if is_sdxl:
-                target_width = max(512, min(1536, target_width))
-                target_height = max(512, min(1536, target_height))
+            if self.progressive_growing_refinement:
+                # хотя бы 1 шаг на стадию
+                steps_for_refinement = max(1, self.steps // total_stages)
+
+                noise = create_random_tensors(
+                    samples.shape[1:],  # (C, H/8, W/8)
+                    seeds,
+                    subseeds=subseeds,
+                    subseed_strength=subseed_strength,
+                    seed_resize_from_h=self.seed_resize_from_h,
+                    seed_resize_from_w=self.seed_resize_from_w,
+                    p=self
+                )
 
-            samples = torch.nn.functional.interpolate(samples, size=(target_height // opt_f, target_width // opt_f), mode='bicubic', align_corners=False)
+                decoded = decode_latent_batch(
+                    self.sd_model,
+                    samples,
+                    target_device=devices.cpu,
+                    check_for_nans=True
+                )
+                decoded = torch.stack(decoded).float()
+                decoded = torch.clamp((decoded + 1.0) / 2.0, 0.0, 1.0)  # [0..1]
+                src = decoded * 2.0 - 1.0                               # [-1..1]
 
-            if self.progressive_growing_refinement:
-                steps_for_refinement = self.steps // len(resolution_steps)
-                noise = create_random_tensors(samples.shape[1:], seeds, subseeds=subseeds, subseed_strength=subseed_strength, seed_resize_from_h=self.seed_resize_from_h, seed_resize_from_w=self.seed_resize_from_w, p=self)
-                decoded_samples = decode_latent_batch(self.sd_model, samples, target_device=devices.cpu, check_for_nans=True)
-                decoded_samples = torch.stack(decoded_samples).float()
-                decoded_samples = torch.clamp((decoded_samples + 1.0) / 2.0, min=0.0, max=1.0)
-                self.image_conditioning = self.img2img_image_conditioning(decoded_samples * 2 - 1, samples)
+                self.image_conditioning = self.img2img_image_conditioning(src, samples)
 
                 samples = self.sampler.sample_img2img(
                     self,
@@ -188,6 +244,7 @@ def create_random_tensors(shape, seeds, subseeds=None, subseed_strength=0.0, see
                 )
 
         return samples
+
     
     def sample_hr_pass(self, samples, decoded_samples, seeds, subseeds, subseed_strength, prompts):
         if shared.state.interrupted: