rework RNG to use generators instead of generating noises beforehand

1 files changed, 10 insertions, 79 deletions

diff --git a/modules/processing.py b/modules/processing.py
index aa72b132..2df5e8c7 100644
--- a/modules/processing.py
+++ b/modules/processing.py
@@ -14,7 +14,7 @@ from skimage import exposure
 from typing import Any, Dict, List

 

 import modules.sd_hijack

-from modules import devices, prompt_parser, masking, sd_samplers, lowvram, generation_parameters_copypaste, extra_networks, sd_vae_approx, scripts, sd_samplers_common, sd_unet, errors

+from modules import devices, prompt_parser, masking, sd_samplers, lowvram, generation_parameters_copypaste, extra_networks, sd_vae_approx, scripts, sd_samplers_common, sd_unet, errors, rng

 from modules.sd_hijack import model_hijack

 from modules.sd_samplers_common import images_tensor_to_samples, decode_first_stage, approximation_indexes

 from modules.shared import opts, cmd_opts, state

@@ -186,6 +186,7 @@ class StableDiffusionProcessing:
         self.cached_c = StableDiffusionProcessing.cached_c

         self.uc = None

         self.c = None

+        self.rng: rng.ImageRNG = None

 

         self.user = None

 

@@ -475,82 +476,9 @@ class Processed:
         return self.token_merging_ratio_hr if for_hr else self.token_merging_ratio

 

 

-# from https://discuss.pytorch.org/t/help-regarding-slerp-function-for-generative-model-sampling/32475/3

-def slerp(val, low, high):

-    low_norm = low/torch.norm(low, dim=1, keepdim=True)

-    high_norm = high/torch.norm(high, dim=1, keepdim=True)

-    dot = (low_norm*high_norm).sum(1)

-

-    if dot.mean() > 0.9995:

-        return low * val + high * (1 - val)

-

-    omega = torch.acos(dot)

-    so = torch.sin(omega)

-    res = (torch.sin((1.0-val)*omega)/so).unsqueeze(1)*low + (torch.sin(val*omega)/so).unsqueeze(1) * high

-    return res

-

-

 def create_random_tensors(shape, seeds, subseeds=None, subseed_strength=0.0, seed_resize_from_h=0, seed_resize_from_w=0, p=None):

-    eta_noise_seed_delta = opts.eta_noise_seed_delta or 0

-    xs = []

-

-    # if we have multiple seeds, this means we are working with batch size>1; this then

-    # enables the generation of additional tensors with noise that the sampler will use during its processing.

-    # Using those pre-generated tensors instead of simple torch.randn allows a batch with seeds [100, 101] to

-    # produce the same images as with two batches [100], [101].

-    if p is not None and p.sampler is not None and (len(seeds) > 1 and opts.enable_batch_seeds or eta_noise_seed_delta > 0):

-        sampler_noises = [[] for _ in range(p.sampler.number_of_needed_noises(p))]

-    else:

-        sampler_noises = None

-

-    for i, seed in enumerate(seeds):

-        noise_shape = shape if seed_resize_from_h <= 0 or seed_resize_from_w <= 0 else (shape[0], seed_resize_from_h//8, seed_resize_from_w//8)

-

-        subnoise = None

-        if subseeds is not None and subseed_strength != 0:

-            subseed = 0 if i >= len(subseeds) else subseeds[i]

-

-            subnoise = devices.randn(subseed, noise_shape)

-

-        # randn results depend on device; gpu and cpu get different results for same seed;

-        # the way I see it, it's better to do this on CPU, so that everyone gets same result;

-        # but the original script had it like this, so I do not dare change it for now because

-        # it will break everyone's seeds.

-        noise = devices.randn(seed, noise_shape)

-

-        if subnoise is not None:

-            noise = slerp(subseed_strength, noise, subnoise)

-

-        if noise_shape != shape:

-            x = devices.randn(seed, shape)

-            dx = (shape[2] - noise_shape[2]) // 2

-            dy = (shape[1] - noise_shape[1]) // 2

-            w = noise_shape[2] if dx >= 0 else noise_shape[2] + 2 * dx

-            h = noise_shape[1] if dy >= 0 else noise_shape[1] + 2 * dy

-            tx = 0 if dx < 0 else dx

-            ty = 0 if dy < 0 else dy

-            dx = max(-dx, 0)

-            dy = max(-dy, 0)

-

-            x[:, ty:ty+h, tx:tx+w] = noise[:, dy:dy+h, dx:dx+w]

-            noise = x

-

-        if sampler_noises is not None:

-            cnt = p.sampler.number_of_needed_noises(p)

-

-            if eta_noise_seed_delta > 0:

-                devices.manual_seed(seed + eta_noise_seed_delta)

-

-            for j in range(cnt):

-                sampler_noises[j].append(devices.randn_without_seed(tuple(noise_shape)))

-

-        xs.append(noise)

-

-    if sampler_noises is not None:

-        p.sampler.sampler_noises = [torch.stack(n).to(shared.device) for n in sampler_noises]

-

-    x = torch.stack(xs).to(shared.device)

-    return x

+    g = rng.ImageRNG(shape, seeds, subseeds=subseeds, subseed_strength=subseed_strength, seed_resize_from_h=seed_resize_from_h, seed_resize_from_w=seed_resize_from_w)

+    return g.next()

 

 

 class DecodedSamples(list):

@@ -769,6 +697,8 @@ def process_images_inner(p: StableDiffusionProcessing) -> Processed:
             p.seeds = p.all_seeds[n * p.batch_size:(n + 1) * p.batch_size]

             p.subseeds = p.all_subseeds[n * p.batch_size:(n + 1) * p.batch_size]

 

+            p.rng = rng.ImageRNG((opt_C, p.height // opt_f, p.width // opt_f), p.seeds, subseeds=p.subseeds, subseed_strength=p.subseed_strength, seed_resize_from_h=p.seed_resize_from_h, seed_resize_from_w=p.seed_resize_from_w)

+

             if p.scripts is not None:

                 p.scripts.before_process_batch(p, batch_number=n, prompts=p.prompts, seeds=p.seeds, subseeds=p.subseeds)

 

@@ -1072,7 +1002,7 @@ class StableDiffusionProcessingTxt2Img(StableDiffusionProcessing):
     def sample(self, conditioning, unconditional_conditioning, seeds, subseeds, subseed_strength, prompts):

         self.sampler = sd_samplers.create_sampler(self.sampler_name, self.sd_model)

 

-        x = create_random_tensors([opt_C, self.height // opt_f, self.width // opt_f], seeds=seeds, subseeds=subseeds, subseed_strength=self.subseed_strength, seed_resize_from_h=self.seed_resize_from_h, seed_resize_from_w=self.seed_resize_from_w, p=self)

+        x = self.rng.next()

         samples = self.sampler.sample(self, x, conditioning, unconditional_conditioning, image_conditioning=self.txt2img_image_conditioning(x))

         del x

 

@@ -1160,7 +1090,8 @@ class StableDiffusionProcessingTxt2Img(StableDiffusionProcessing):
 

         samples = samples[:, :, self.truncate_y//2:samples.shape[2]-(self.truncate_y+1)//2, self.truncate_x//2:samples.shape[3]-(self.truncate_x+1)//2]

 

-        noise = create_random_tensors(samples.shape[1:], seeds=seeds, subseeds=subseeds, subseed_strength=subseed_strength, p=self)

+        self.rng = rng.ImageRNG(samples.shape[1:], self.seeds, subseeds=self.subseeds, subseed_strength=self.subseed_strength, seed_resize_from_h=self.seed_resize_from_h, seed_resize_from_w=self.seed_resize_from_w)

+        noise = self.rng.next()

 

         # GC now before running the next img2img to prevent running out of memory

         devices.torch_gc()

@@ -1418,7 +1349,7 @@ class StableDiffusionProcessingImg2Img(StableDiffusionProcessing):
         self.image_conditioning = self.img2img_image_conditioning(image, self.init_latent, image_mask)

 

     def sample(self, conditioning, unconditional_conditioning, seeds, subseeds, subseed_strength, prompts):

-        x = create_random_tensors([opt_C, self.height // opt_f, self.width // opt_f], seeds=seeds, subseeds=subseeds, subseed_strength=self.subseed_strength, seed_resize_from_h=self.seed_resize_from_h, seed_resize_from_w=self.seed_resize_from_w, p=self)

+        x = self.rng.next()

 

         if self.initial_noise_multiplier != 1.0:

             self.extra_generation_params["Noise multiplier"] = self.initial_noise_multiplier