Merge branch 'master' into master

1 files changed, 26 insertions, 7 deletions

diff --git a/modules/processing.py b/modules/processing.py
index a1138491..605c541e 100644
--- a/modules/processing.py
+++ b/modules/processing.py
@@ -13,10 +13,11 @@ from skimage import exposure
 from typing import Any, Dict, List, Optional

 

 import modules.sd_hijack

-from modules import devices, prompt_parser, masking, sd_samplers, lowvram, generation_parameters_copypaste, script_callbacks, extra_networks

+from modules import devices, prompt_parser, masking, sd_samplers, lowvram, generation_parameters_copypaste, script_callbacks, extra_networks, sd_vae_approx, scripts

 from modules.sd_hijack import model_hijack

 from modules.shared import opts, cmd_opts, state

 import modules.shared as shared

+import modules.paths as paths

 import modules.face_restoration

 import modules.images as images

 import modules.styles

@@ -184,7 +185,12 @@ class StableDiffusionProcessing:
         conditioning = 2. * (conditioning - depth_min) / (depth_max - depth_min) - 1.

         return conditioning

 

-    def inpainting_image_conditioning(self, source_image, latent_image, image_mask = None):

+    def edit_image_conditioning(self, source_image):

+        conditioning_image = self.sd_model.get_first_stage_encoding(self.sd_model.encode_first_stage(source_image))

+

+        return conditioning_image

+

+    def inpainting_image_conditioning(self, source_image, latent_image, image_mask=None):

         self.is_using_inpainting_conditioning = True

 

         # Handle the different mask inputs

@@ -203,7 +209,7 @@ class StableDiffusionProcessing:
 

         # Create another latent image, this time with a masked version of the original input.

         # Smoothly interpolate between the masked and unmasked latent conditioning image using a parameter.

-        conditioning_mask = conditioning_mask.to(source_image.device).to(source_image.dtype)

+        conditioning_mask = conditioning_mask.to(device=source_image.device, dtype=source_image.dtype)

         conditioning_image = torch.lerp(

             source_image,

             source_image * (1.0 - conditioning_mask),

@@ -222,11 +228,16 @@ class StableDiffusionProcessing:
         return image_conditioning

 

     def img2img_image_conditioning(self, source_image, latent_image, image_mask=None):

+        source_image = devices.cond_cast_float(source_image)

+

         # HACK: Using introspection as the Depth2Image model doesn't appear to uniquely

         # identify itself with a field common to all models. The conditioning_key is also hybrid.

         if isinstance(self.sd_model, LatentDepth2ImageDiffusion):

             return self.depth2img_image_conditioning(source_image)

 

+        if self.sd_model.cond_stage_key == "edit":

+            return self.edit_image_conditioning(source_image)

+

         if self.sampler.conditioning_key in {'hybrid', 'concat'}:

             return self.inpainting_image_conditioning(source_image, latent_image, image_mask=image_mask)

 

@@ -439,8 +450,6 @@ def create_infotext(p, all_prompts, all_seeds, all_subseeds, comments=None, iter
         "Size": f"{p.width}x{p.height}",

         "Model hash": getattr(p, 'sd_model_hash', None if not opts.add_model_hash_to_info or not shared.sd_model.sd_model_hash else shared.sd_model.sd_model_hash),

         "Model": (None if not opts.add_model_name_to_info or not shared.sd_model.sd_checkpoint_info.model_name else shared.sd_model.sd_checkpoint_info.model_name.replace(',', '').replace(':', '')),

-        "Batch size": (None if p.batch_size < 2 else p.batch_size),

-        "Batch pos": (None if p.batch_size < 2 else position_in_batch),

         "Variation seed": (None if p.subseed_strength == 0 else all_subseeds[index]),

         "Variation seed strength": (None if p.subseed_strength == 0 else p.subseed_strength),

         "Seed resize from": (None if p.seed_resize_from_w == 0 or p.seed_resize_from_h == 0 else f"{p.seed_resize_from_w}x{p.seed_resize_from_h}"),

@@ -580,10 +589,14 @@ def process_images_inner(p: StableDiffusionProcessing) -> Processed:
         with devices.autocast():

             p.init(p.all_prompts, p.all_seeds, p.all_subseeds)

 

+            # for OSX, loading the model during sampling changes the generated picture, so it is loaded here

+            if shared.opts.live_previews_enable and opts.show_progress_type == "Approx NN":

+                sd_vae_approx.model()

+

             if not p.disable_extra_networks:

                 extra_networks.activate(p, extra_network_data)

 

-        with open(os.path.join(shared.script_path, "params.txt"), "w", encoding="utf8") as file:

+        with open(os.path.join(paths.data_path, "params.txt"), "w", encoding="utf8") as file:

             processed = Processed(p, [], p.seed, "")

             file.write(processed.infotext(p, 0))

 

@@ -634,7 +647,8 @@ def process_images_inner(p: StableDiffusionProcessing) -> Processed:
             if p.n_iter > 1:

                 shared.state.job = f"Batch {n+1} out of {p.n_iter}"

 

-            with devices.autocast():

+

+            with devices.without_autocast() if devices.unet_needs_upcast else devices.autocast():

                 if type(p) == StableDiffusionProcessingTxt2Img:

                     if p.enable_hr:

                         if p.hr_prompt != '':

@@ -684,6 +698,11 @@ def process_images_inner(p: StableDiffusionProcessing) -> Processed:
 

                 image = Image.fromarray(x_sample)

 

+                if p.scripts is not None:

+                    pp = scripts.PostprocessImageArgs(image)

+                    p.scripts.postprocess_image(p, pp)

+                    image = pp.image

+

                 if p.color_corrections is not None and i < len(p.color_corrections):

                     if opts.save and not p.do_not_save_samples and opts.save_images_before_color_correction:

                         image_without_cc = apply_overlay(image, p.paste_to, i, p.overlay_images)