update forge classic to 1.7

README.md

@@ -18,7 +18,7 @@ The name "Forge" is inspired by "Minecraft Forge". This project aims to become t
 
 <br>
 
-## Features [May. 21]
+## Features [May. 28]
 > Most base features of the original [Automatic1111 Webui](https://github.com/AUTOMATIC1111/stable-diffusion-webui) should still function
 
 #### New Features
@@ -55,17 +55,23 @@ The name "Forge" is inspired by "Minecraft Forge". This project aims to become t
 > - Both `fp16_accumulation` and `cublas_ops` achieve the same speed up; if you already install/update to PyTorch **2.7.0**, you do not need to go for `cublas_ops`
 > - The `fp16_accumulation` and `cublas_ops` require `fp16` precision, thus is not compatible with the `fp8` operation
 
+- [X] Persistent LoRA Patching
+    - speed up LoRA loading in subsequent generations
+    - see [Commandline](#by-classic)
 - [X] Implement new Samplers
     - *(ported from reForge Webui)*
 - [X] Implement Scheduler Dropdown
     - *(backported from Automatic1111 Webui upstream)*
-    - enable in **Settings/UI alternatives**
+    - enable in **Settings/UI Alternatives**
+- [X] Add `CFG` slider to the `Hires. fix` section
 - [X] Implement RescaleCFG
     - reduce burnt colors; mainly for `v-pred` checkpoints
-    - enable in **Settings/UI alternatives**
+    - enable in **Settings/UI Alternatives**
 - [X] Implement MaHiRo
     - alternative CFG calculation; improve prompt adherence
-    - enable in **Settings/UI alternatives**
+    - enable in **Settings/UI Alternatives**
+- [X] Implement full precision calculation for `Mask blur` blending
+    - enable in **Settings/img2img**
 - [X] Implement `diskcache` for hashes
     - *(backported from Automatic1111 Webui upstream)*
 - [X] Implement `skip_early_cond`
@@ -117,13 +123,14 @@ The name "Forge" is inspired by "Minecraft Forge". This project aims to become t
 - [X] Remove unused `args_parser`
 - [X] Remove unused `shared_options`
 - [X] Remove legacy codes
-- [X] Remove duplicated upscaler codes
+- [X] Fix some typos
+- [X] Remove redundant upscaler codes
     - put every upscaler inside the `ESRGAN` folder
-    - optimize upscaler logics
+- [X] Optimize upscaler logics
 - [X] Improve color correction
 - [X] Improve hash caching
 - [X] Improve error logs
-    - no longer just print `TypeError: 'NoneType' object is not iterable`
+    - no longer print `TypeError: 'NoneType' object is not iterable`
 - [X] Revamp settings
     - improve formatting
     - update descriptions
@@ -135,7 +142,7 @@ The name "Forge" is inspired by "Minecraft Forge". This project aims to become t
     - change `visible` toggle to `interactive` toggle; now the UI will no longer jump around
     - improved `Presets` application
 - [X] Disable Refiner by default
-    - enable again in **Settings/UI alternatives**
+    - enable again in **Settings/UI Alternatives**
 - [X] Disable Tree View by default
     - enable again in **Settings/Extra Networks**
 - [X] Run `text encoder` on CPU by default
@@ -150,7 +157,7 @@ The name "Forge" is inspired by "Minecraft Forge". This project aims to become t
     - `torch==2.7.0+cu128`
     - `xformers==0.0.30`
 
-> [!Tip]
+> [!Note]
 > If your GPU does not support the latest PyTorch, manually [install](#install-older-pytorch) older version of PyTorch
 
 - [X] No longer install `open-clip` twice
@@ -208,6 +215,10 @@ The name "Forge" is inspired by "Minecraft Forge". This project aims to become t
 > [!Important]
 > This simply **replaces** the `models` folder, rather than adding on top of it
 
+- `--persistent-patches`: Enable the persistent LoRA patching
+    - no longer apply LoRA every single generation, if the weight is unchanged
+    - save around 1 second per generation when using LoRA
+
 - `--fast-fp16`: Enable the `allow_fp16_accumulation` option
     - requires PyTorch **2.7.0** +
 - `--sage`: Install the `sageattention` package to speed up generation

extensions-builtin/sd_forge_neveroom/scripts/forge_never_oom.py

@@ -1,5 +1,6 @@
 from ldm_patched.modules import model_management
-from modules import scripts
+from modules.ui_components import FormRow
+from modules import scripts, shared
 
 import gradio as gr
 
@@ -18,34 +19,35 @@ class NeverOOMForForge(scripts.Script):
         return scripts.AlwaysVisible
 
     def ui(self, *args, **kwargs):
-        with gr.Accordion(open=False, label=self.title()):
-            unet_enabled = gr.Checkbox(
-                label="Enabled for UNet (always offload)",
-                value=False,
-            )
-            vae_enabled = gr.Checkbox(
-                label="Enabled for VAE (always tile)",
-                value=False,
-            )
-        return unet_enabled, vae_enabled
+        with gr.Accordion(label=self.title(), open=False):
+            with FormRow():
+                unet_enable = gr.Checkbox(value=False, label="Enable for UNet", info="always offload to memory")
+                vae_enable = gr.Checkbox(value=False, label="Enabled for VAE", info="always tiled encoding/decoding")
+            with FormRow():
+                tile_size = gr.Slider(minimum=64, maximum=1024, step=64, value=512, label="Tile Size", info="in pixels")
+                tile_overlap = gr.Slider(minimum=16, maximum=256, step=4, value=64, label="Tile Overlap", info="in pixels")
 
-    def process(self, p, *script_args, **kwargs):
-        unet_enabled, vae_enabled = script_args
+        return unet_enable, vae_enable, tile_size, tile_overlap
 
-        if unet_enabled:
-            print("NeverOOM Enabled for UNet")
+    def process(self, p, unet_enable: bool, vae_enable: bool, tile_size: int, tile_overlap: int, **kwargs):
 
-        if vae_enabled:
-            print("NeverOOM Enabled for VAE")
+        if unet_enable:
+            print("[Never OOM] Enabled for UNet")
 
-        model_management.VAE_ALWAYS_TILED = vae_enabled
+        if vae_enable:
+            print("[Never OOM] Enabled for VAE")
+            shared.opts.tile_size = tile_size
+            shared.opts.tile_overlap = min(tile_size // 4, tile_overlap)
+
+        model_management.VAE_ALWAYS_TILED = vae_enable
+
+        if self.previous_unet_enabled != unet_enable:
+            self.previous_unet_enabled = unet_enable
 
-        if self.previous_unet_enabled != unet_enabled:
             model_management.unload_all_models()
-            if unet_enabled:
+            if unet_enable:
                 self.original_vram_state = model_management.vram_state
                 model_management.vram_state = model_management.VRAMState.NO_VRAM
             else:
                 model_management.vram_state = self.original_vram_state
-            print(f"VRAM State Changed To {model_management.vram_state.name}")
-            self.previous_unet_enabled = unet_enabled
+            print(f"Changed VRAM State To {model_management.vram_state.name}")

extensions-builtin/xyz/lib_xyz/axis_application.py

@@ -98,5 +98,14 @@ def apply_override(field, boolean: bool = False):
     return fun
 
 
+def apply_size(p, x: str, xs) -> None:
+    try:
+        width, height = x.split("x")
+        p.width = int(width.strip())
+        p.height = int(height.strip())
+    except Exception:
+        print(f"Invalid size in XYZ plot: {x}")
+
+
 def do_nothing(p, x, xs):
     pass

extensions-builtin/xyz/lib_xyz/builtins.py

@@ -8,6 +8,7 @@ from .axis_application import (
     apply_order,
     apply_override,
     apply_prompt,
+    apply_size,
     apply_styles,
     apply_uni_pc_order,
     apply_vae,
@@ -43,6 +44,7 @@ builtin_options = [
     AxisOptionImg2Img("Sampler", str, apply_field("sampler_name"), format_value=format_value, confirm=confirm_samplers, choices=sd_samplers.visible_sampler_names),
     AxisOption("Checkpoint name", str, apply_checkpoint, format_value=format_remove_path, confirm=confirm_checkpoints, cost=1.0, choices=lambda: sorted(sd_models.checkpoints_list, key=str.casefold)),
     AxisOption("Negative Guidance minimum sigma", float, apply_field("s_min_uncond")),
+    AxisOption("Size", str, apply_size),
     AxisOption("Sigma Churn", float, apply_field("s_churn")),
     AxisOption("Sigma min", float, apply_field("s_tmin")),
     AxisOption("Sigma max", float, apply_field("s_tmax")),

ldm_patched/k_diffusion/sampling.py

@@ -407,6 +407,51 @@ def sample_dpmpp_2m(model, x, sigmas, extra_args=None, callback=None, disable=No
     return x
 
 
+@torch.no_grad()
+def sample_dpmpp_2m_sde(model, x, sigmas, extra_args=None, callback=None, disable=None, eta=1.0, s_noise=1.0, noise_sampler=None, solver_type="midpoint"):
+    """DPM-Solver++(2M) SDE"""
+
+    if solver_type not in {"heun", "midpoint"}:
+        raise ValueError("solver_type must be 'heun' or 'midpoint'")
+
+    seed = extra_args.get("seed", None)
+    sigma_min, sigma_max = sigmas[sigmas > 0].min(), sigmas.max()
+    noise_sampler = BrownianTreeNoiseSampler(x, sigma_min, sigma_max, seed=seed, cpu=True) if noise_sampler is None else noise_sampler
+    extra_args = {} if extra_args is None else extra_args
+    s_in = x.new_ones([x.shape[0]])
+
+    old_denoised = None
+    h_last = None
+    h = None
+
+    for i in trange(len(sigmas) - 1, disable=disable):
+        denoised = model(x, sigmas[i] * s_in, **extra_args)
+        if callback is not None:
+            callback({"x": x, "i": i, "sigma": sigmas[i], "sigma_hat": sigmas[i], "denoised": denoised})
+        if sigmas[i + 1] == 0:
+            x = denoised
+        else:
+            t, s = -sigmas[i].log(), -sigmas[i + 1].log()
+            h = s - t
+            eta_h = eta * h
+
+            x = sigmas[i + 1] / sigmas[i] * (-eta_h).exp() * x + (-h - eta_h).expm1().neg() * denoised
+
+            if old_denoised is not None:
+                r = h_last / h
+                if solver_type == "heun":
+                    x = x + ((-h - eta_h).expm1().neg() / (-h - eta_h) + 1) * (1 / r) * (denoised - old_denoised)
+                elif solver_type == "midpoint":
+                    x = x + 0.5 * (-h - eta_h).expm1().neg() * (1 / r) * (denoised - old_denoised)
+
+            if eta:
+                x = x + noise_sampler(sigmas[i], sigmas[i + 1]) * sigmas[i + 1] * (-2 * eta_h).expm1().neg().sqrt() * s_noise
+
+        old_denoised = denoised
+        h_last = h
+    return x
+
+
 @torch.no_grad()
 def sample_dpmpp_3m_sde(model, x, sigmas, extra_args=None, callback=None, disable=None, eta=1.0, s_noise=1.0, noise_sampler=None):
     """DPM-Solver++(3M) SDE"""

ldm_patched/ldm/modules/diffusionmodules/model.py

@@ -549,7 +549,7 @@ class Decoder(nn.Module):
                 _h = self.up[i_level].upsample(h)
                 del h
                 h = _h
-            torch.cuda.empty_cache()
+            model_management.soft_empty_cache()
 
         # end
         if self.give_pre_end:

ldm_patched/modules/args_parser.py

@@ -1,5 +1,10 @@
-# Reference: https://github.com/comfyanonymous/ComfyUI
+"""
+Credit: ComfyUI
+https://github.com/comfyanonymous/ComfyUI
 
+- Edited by. Forge Official
+- Edited by. Haoming02
+"""
 
 import argparse
 import enum
@@ -77,6 +82,7 @@ parser.add_argument("--cuda-stream", action="store_true")
 parser.add_argument("--pin-shared-memory", action="store_true")
 
 parser.add_argument("--fast-fp16", action="store_true")
+parser.add_argument("--persistent-patches", action="store_true")
 
 
 class SageAttentionAPIs(enum.Enum):

ldm_patched/modules/model_management.py

@@ -1,8 +1,11 @@
-# 1st edit by https://github.com/comfyanonymous/ComfyUI
-# 2nd edit by Forge Official
+"""
+Credit: ComfyUI
+https://github.com/comfyanonymous/ComfyUI
 
+- Edited by. Forge Official
+- Edited by. Haoming02
+"""
 
-import gc
 import time
 from enum import Enum
 from functools import lru_cache
@@ -376,11 +379,9 @@ class LoadedModel:
         if disable_async_load:
             patch_model_to = self.device
 
-        self.model.model_patches_to(self.device)
-        self.model.model_patches_to(self.model.model_dtype())
+        self.model.model_patches_to(device=self.device, dtype=self.model.model_dtype())
 
         try:
-            # TODO: do something with loras and offloading to CPU
             self.real_model = self.model.patch_model(device_to=patch_model_to)
         except Exception as e:
             self.model.unpatch_model(self.model.offload_device)
@@ -434,7 +435,7 @@ class LoadedModel:
 
         return self.real_model
 
-    def model_unload(self, avoid_model_moving: bool = False):
+    def model_unload(self, *, avoid_model_moving: bool = False):
         if self.model_accelerated:
             for m in self.real_model.modules():
                 if hasattr(m, "prev_ldm_patched_cast_weights"):
@@ -446,7 +447,7 @@ class LoadedModel:
         if avoid_model_moving:
             self.model.unpatch_model()
         else:
-            self.model.unpatch_model(self.model.offload_device)
+            self.model.unpatch_model(device_to=self.model.offload_device)
             self.model.model_patches_to(self.model.offload_device)
 
     def __eq__(self, other: "LoadedModel"):
@@ -471,7 +472,6 @@ def unload_model_clones(model):
     if len(to_unload) > 0:
         print(f"Reusing {len(to_unload)} loaded model{'s' if len(to_unload) > 1 else ''}")
         soft_empty_cache()
-        gc.collect()
 
 
 def free_memory(memory_required, device, keep_loaded=[]):

ldm_patched/modules/model_patcher.py

@@ -1,15 +1,63 @@
-# 1st edit by https://github.com/comfyanonymous/ComfyUI
-# 2nd edit by Forge Official
+"""
+Credit: ComfyUI
+https://github.com/comfyanonymous/ComfyUI
 
+- Edited by. Forge Official
+- Edited by. Haoming02
+"""
 
 import copy
 import inspect
 
+import torch
+
 import ldm_patched.modules.model_management
 import ldm_patched.modules.utils
-import torch
+from ldm_patched.modules.args_parser import args
+
+extra_weight_calculators = {}  # backward compatibility
+
+
+PERSISTENT_PATCHES = args.persistent_patches
+if PERSISTENT_PATCHES:
+    print("[Experimental] Persistent Patches:", PERSISTENT_PATCHES)
+
+
+class PatchStatus:
+    def __init__(self):
+        self.current = 0  # the current status of the ModelPatcher
+        self.updated = 0  # the last time a patch was modified
+
+    def require_patch(self) -> bool:
+        if not PERSISTENT_PATCHES:
+            return True
+
+        return self.current == 0
+
+    def require_unpatch(self) -> bool:
+        if not PERSISTENT_PATCHES:
+            return True
+
+        if not PatchStatus.has_lora():
+            return True
+
+        return self.current != self.updated
+
+    def patch(self):
+        if self.updated > 0:
+            self.current = self.updated
+
+    def unpatch(self):
+        self.current = 0
+
+    def update(self):
+        self.updated += 1
 
-extra_weight_calculators = {}
+    @staticmethod
+    def has_lora() -> bool:
+        from modules.shared import sd_model
+
+        return sd_model.current_lora_hash != str([])
 
 
 class ModelPatcher:
@@ -24,13 +72,11 @@ class ModelPatcher:
         self.model_size()
         self.load_device = load_device
         self.offload_device = offload_device
-        if current_device is None:
-            self.current_device = self.offload_device
-        else:
-            self.current_device = current_device
-
+        self.current_device = self.offload_device if current_device is None else current_device
         self.weight_inplace_update = weight_inplace_update
 
+        self.patch_status = PatchStatus()
+
     def model_size(self):
         if self.size > 0:
             return self.size
@@ -46,21 +92,22 @@ class ModelPatcher:
             self.offload_device,
             self.size,
             self.current_device,
-            weight_inplace_update=self.weight_inplace_update,
+            self.weight_inplace_update,
         )
-        n.patches = {}
+
         for k in self.patches:
             n.patches[k] = self.patches[k][:]
 
+        n.backup = self.backup
         n.object_patches = self.object_patches.copy()
         n.model_options = copy.deepcopy(self.model_options)
         n.model_keys = self.model_keys
+        n.patch_status = self.patch_status
+
         return n
 
     def is_clone(self, other):
-        if hasattr(other, "model") and self.model is other.model:
-            return True
-        return False
+        return getattr(other, "model", None) is self.model
 
     def memory_required(self, input_shape):
         return self.model.memory_required(input_shape=input_shape)
@@ -135,26 +182,26 @@ class ModelPatcher:
     def add_object_patch(self, name, obj):
         self.object_patches[name] = obj
 
-    def model_patches_to(self, device):
-        to = self.model_options["transformer_options"]
+    def model_patches_to(self, device, *, dtype=None):
+        to: dict[str, dict[str, list["torch.Tensor"] | dict[str, "torch.Tensor"]]] = self.model_options["transformer_options"]
         if "patches" in to:
             patches = to["patches"]
             for name in patches:
                 patch_list = patches[name]
                 for i in range(len(patch_list)):
                     if hasattr(patch_list[i], "to"):
-                        patch_list[i] = patch_list[i].to(device)
+                        patch_list[i] = patch_list[i].to(device=device, dtype=dtype)
         if "patches_replace" in to:
             patches = to["patches_replace"]
             for name in patches:
                 patch_list = patches[name]
                 for k in patch_list:
                     if hasattr(patch_list[k], "to"):
-                        patch_list[k] = patch_list[k].to(device)
+                        patch_list[k] = patch_list[k].to(device=device, dtype=dtype)
         if "model_function_wrapper" in self.model_options:
-            wrap_func = self.model_options["model_function_wrapper"]
+            wrap_func: "torch.Tensor" = self.model_options["model_function_wrapper"]
             if hasattr(wrap_func, "to"):
-                self.model_options["model_function_wrapper"] = wrap_func.to(device)
+                self.model_options["model_function_wrapper"] = wrap_func.to(device=device, dtype=dtype)
 
     def model_dtype(self):
         if hasattr(self.model, "get_dtype"):
@@ -169,6 +216,7 @@ class ModelPatcher:
                 current_patches.append((strength_patch, patches[k], strength_model))
                 self.patches[k] = current_patches
 
+        self.patch_status.update()
         return list(p)
 
     def get_key_patches(self, filter_prefix=None):
@@ -201,7 +249,10 @@ class ModelPatcher:
                 self.object_patches_backup[k] = old
             ldm_patched.modules.utils.set_attr_raw(self.model, k, self.object_patches[k])
 
-        if patch_weights:
+        if not patch_weights:
+            return self.model
+
+        if self.patches and self.patch_status.require_patch():
             model_sd = self.model_state_dict()
             for key in self.patches:
                 if key not in model_sd:
@@ -226,9 +277,11 @@ class ModelPatcher:
                     ldm_patched.modules.utils.set_attr(self.model, key, out_weight)
                 del temp_weight
 
-            if device_to is not None:
-                self.model.to(device_to)
-                self.current_device = device_to
+            self.patch_status.patch()
+
+        if device_to is not None:
+            self.model.to(device_to)
+            self.current_device = device_to
 
         return self.model
 
@@ -403,16 +456,18 @@ class ModelPatcher:
         return weight
 
     def unpatch_model(self, device_to=None):
-        keys = list(self.backup.keys())
+        if self.backup and self.patch_status.require_unpatch():
+            keys = list(self.backup.keys())
 
-        if self.weight_inplace_update:
-            for k in keys:
-                ldm_patched.modules.utils.copy_to_param(self.model, k, self.backup[k])
-        else:
-            for k in keys:
-                ldm_patched.modules.utils.set_attr(self.model, k, self.backup[k])
+            if self.weight_inplace_update:
+                for k in keys:
+                    ldm_patched.modules.utils.copy_to_param(self.model, k, self.backup[k])
+            else:
+                for k in keys:
+                    ldm_patched.modules.utils.set_attr(self.model, k, self.backup[k])
 
-        self.backup = {}
+            self.backup.clear()
+            self.patch_status.unpatch()
 
         if device_to is not None:
             self.model.to(device_to)
@@ -422,7 +477,7 @@ class ModelPatcher:
         for k in keys:
             ldm_patched.modules.utils.set_attr_raw(self.model, k, self.object_patches_backup[k])
 
-        self.object_patches_backup = {}
+        self.object_patches_backup.clear()
 
     def __del__(self):
         del self.patches

ldm_patched/modules/sd.py

@@ -1,16 +1,15 @@
 # Reference: https://github.com/comfyanonymous/ComfyUI
 
 
+import torch
+
 import ldm_patched.modules.lora
 import ldm_patched.modules.model_patcher
-import ldm_patched.modules.supported_models_base
 import ldm_patched.modules.utils
-import ldm_patched.t2ia.adapter
 import ldm_patched.taesd.taesd
-import torch
-
-from ldm_patched.ldm.models.autoencoder import AutoencoderKL, AutoencodingEngine
+from ldm_patched.ldm.models.autoencoder import AutoencoderKL
 from ldm_patched.modules import model_management
+from modules.shared import opts
 
 from . import diffusers_convert
 
@@ -218,7 +217,11 @@ class VAE:
         n.output_device = self.output_device
         return n
 
-    def decode_tiled_(self, samples, tile_x=64, tile_y=64, overlap=16):
+    def decode_tiled_(self, samples, tile_x=0, tile_y=0, overlap=0):
+        tile_x = int(tile_x or (opts.tile_size / 8))
+        tile_y = int(tile_y or (opts.tile_size / 8))
+        overlap = int(overlap or (opts.tile_overlap / 8))
+
         steps = samples.shape[0] * ldm_patched.modules.utils.get_tiled_scale_steps(samples.shape[3], samples.shape[2], tile_x, tile_y, overlap)
         steps += samples.shape[0] * ldm_patched.modules.utils.get_tiled_scale_steps(samples.shape[3], samples.shape[2], tile_x // 2, tile_y * 2, overlap)
         steps += samples.shape[0] * ldm_patched.modules.utils.get_tiled_scale_steps(samples.shape[3], samples.shape[2], tile_x * 2, tile_y // 2, overlap)
@@ -267,7 +270,11 @@ class VAE:
         )
         return output
 
-    def encode_tiled_(self, pixel_samples, tile_x=512, tile_y=512, overlap=64):
+    def encode_tiled_(self, pixel_samples, tile_x=0, tile_y=0, overlap=0):
+        tile_x = int(tile_x or opts.tile_size)
+        tile_y = int(tile_y or opts.tile_size)
+        overlap = int(overlap or opts.tile_overlap)
+
         steps = pixel_samples.shape[0] * ldm_patched.modules.utils.get_tiled_scale_steps(pixel_samples.shape[3], pixel_samples.shape[2], tile_x, tile_y, overlap)
         steps += pixel_samples.shape[0] * ldm_patched.modules.utils.get_tiled_scale_steps(
             pixel_samples.shape[3],
@@ -363,9 +370,9 @@ class VAE:
         else:
             return wrapper(self.decode_inner, samples_in)
 
-    def decode_tiled(self, samples, tile_x=64, tile_y=64, overlap=16):
+    def decode_tiled(self, samples):
         model_management.load_model_gpu(self.patcher)
-        output = self.decode_tiled_(samples, tile_x, tile_y, overlap)
+        output = self.decode_tiled_(samples)
         return output.movedim(1, -1)
 
     def encode_inner(self, pixel_samples):
@@ -405,10 +412,10 @@ class VAE:
         else:
             return wrapper(self.encode_inner, pixel_samples)
 
-    def encode_tiled(self, pixel_samples, tile_x=512, tile_y=512, overlap=64):
+    def encode_tiled(self, pixel_samples):
         model_management.load_model_gpu(self.patcher)
         pixel_samples = pixel_samples.movedim(-1, 1)
-        samples = self.encode_tiled_(pixel_samples, tile_x=tile_x, tile_y=tile_y, overlap=overlap)
+        samples = self.encode_tiled_(pixel_samples)
         return samples
 
     def get_sd(self):

modules/cmd_args.py

@@ -11,14 +11,12 @@ parser.add_argument("-f", action="store_true", help=argparse.SUPPRESS)  # allows
 
 parser.add_argument("--update-all-extensions", action="store_true", help="launch.py argument: download updates for all extensions when starting the program")
 parser.add_argument("--skip-python-version-check", action="store_true", help="launch.py argument: do not check python version")
+parser.add_argument("--skip-prepare-environment", action="store_true", help="launch.py argument: skip all environment preparation")
 parser.add_argument("--skip-torch-cuda-test", action="store_true", help="launch.py argument: do not check if CUDA is able to work properly")
+parser.add_argument("--skip-install", action="store_true", help="launch.py argument: skip installation of packages")
 parser.add_argument("--reinstall-xformers", action="store_true", help="launch.py argument: install the appropriate version of xformers even if you have some version already installed")
 parser.add_argument("--reinstall-torch", action="store_true", help="launch.py argument: install the appropriate version of torch even if you have some version already installed")
-parser.add_argument("--update-check", action="store_true", help="launch.py argument: check for updates at startup")
-parser.add_argument("--test-server", action="store_true", help="launch.py argument: configure server for testing")
 parser.add_argument("--log-startup", action="store_true", help="launch.py argument: print a detailed log of what's happening at startup")
-parser.add_argument("--skip-prepare-environment", action="store_true", help="launch.py argument: skip all environment preparation")
-parser.add_argument("--skip-install", action="store_true", help="launch.py argument: skip installation of packages")
 parser.add_argument("--dump-sysinfo", action="store_true", help="launch.py argument: dump limited sysinfo file (without information about extensions, options) to disk and quit")
 parser.add_argument("--loglevel", type=str, help="log level; one of: CRITICAL, ERROR, WARNING, INFO, DEBUG", default=None)
 parser.add_argument("--data-dir", type=normalized_filepath, default=os.path.dirname(os.path.dirname(os.path.realpath(__file__))), help="base path where all user data is stored")
@@ -30,11 +28,8 @@ parser.add_argument("--vae-dir", type=normalized_filepath, default=None, help="P
 parser.add_argument("--gfpgan-dir", type=normalized_filepath, help="GFPGAN directory", default=("./src/gfpgan" if os.path.exists("./src/gfpgan") else "./GFPGAN"))
 parser.add_argument("--gfpgan-model", type=normalized_filepath, help="GFPGAN model file name", default=None)
 parser.add_argument("--no-half", action="store_true", help="do not switch the model to 16-bit floats")
-parser.add_argument("--no-half-vae", action="store_true", help="do not switch the VAE model to 16-bit floats")
-parser.add_argument("--no-progressbar-hiding", action="store_true", help="do not hide progressbar in gradio UI (we hide it because it slows down ML if you have hardware acceleration in browser)")
 parser.add_argument("--embeddings-dir", type=normalized_filepath, default=os.path.join(models_path, "embeddings"), help="textual inversion directory")
 parser.add_argument("--localizations-dir", type=normalized_filepath, default=os.path.join(script_path, "localizations"), help="localizations directory")
-parser.add_argument("--upcast-sampling", action="store_true", help="upcast sampling. No effect with --no-half. Usually produces similar results to --no-half with better performance while using less memory.")
 parser.add_argument("--share", action="store_true", help="use share=True for gradio and make the UI accessible through their site")
 parser.add_argument("--ngrok", type=str, help="ngrok authtoken, alternative to gradio --share", default=None)
 parser.add_argument("--ngrok-options", type=json.loads, help='The options to pass to ngrok in JSON format, e.g.: \'{"authtoken_from_env":true, "basic_auth":"user:password", "oauth_provider":"google", "oauth_allow_emails":"[email protected]"}\'', default=dict())
@@ -44,11 +39,9 @@ parser.add_argument("--gfpgan-models-path", type=normalized_filepath, help="Path
 parser.add_argument("--esrgan-models-path", type=normalized_filepath, help="Path to directory with ESRGAN model file(s).", default=os.path.join(models_path, "ESRGAN"))
 parser.add_argument("--xformers", action="store_true", help="enable xformers for cross attention layers")
 parser.add_argument("--sage", action="store_true", help="enable sage for cross attention layers")
-parser.add_argument("--force-enable-xformers", action="store_true", help="enable xformers for cross attention layers regardless of whether the checking code thinks you can run it; do not make bug reports if this fails to work")
 parser.add_argument("--disable-nan-check", action="store_true", help="do not check if produced images/latent spaces have nans; useful for running without a checkpoint in CI")
 parser.add_argument("--use-cpu", nargs="+", help="use CPU as torch device for specified modules", default=[], type=str.lower)
 parser.add_argument("--use-ipex", action="store_true", help="use Intel XPU as torch device")
-parser.add_argument("--disable-model-loading-ram-optimization", action="store_true", help="disable an optimization that reduces RAM use when loading a model")
 parser.add_argument("--listen", action="store_true", help="launch gradio with 0.0.0.0 as server name, allowing to respond to network requests")
 parser.add_argument("--port", type=int, help="launch gradio with given server port, you need root/admin rights for ports < 1024, defaults to 7860 if available", default=None)
 parser.add_argument("--ui-config-file", type=str, help="filename to use for ui configuration", default=os.path.join(data_path, "ui-config.json"))
@@ -67,7 +60,6 @@ parser.add_argument("--theme", type=str, help="launches the UI with light or dar
 parser.add_argument("--use-textbox-seed", action="store_true", help="use textbox for seeds in UI (no up/down, but possible to input long seeds)", default=False)
 parser.add_argument("--disable-console-progressbars", action="store_true", help="do not output progressbars to console", default=False)
 parser.add_argument("--vae-path", type=normalized_filepath, help="Checkpoint to use as VAE; setting this argument disables all settings related to VAE", default=None)
-parser.add_argument("--disable-safe-unpickle", action="store_true", help="disable checking pytorch models for malicious code", default=False)
 parser.add_argument("--api", action="store_true", help="use api=True to launch the API together with the webui (use --nowebui instead for only the API)")
 parser.add_argument("--api-auth", type=str, help='Set authentication for API like "username:password"; or comma-delimit multiple like "u1:p1,u2:p2,u3:p3"', default=None)
 parser.add_argument("--api-log", action="store_true", help="use api-log=True to enable logging of all API requests")
@@ -101,3 +93,6 @@ parser.add_argument("--fps", type=int, default=30, help="refresh rate for thread
 pkm = parser.add_mutually_exclusive_group()
 pkm.add_argument("--uv", action="store_true", help="Use the uv package manager")
 pkm.add_argument("--uv-symlink", action="store_true", help="Use the uv package manager with symlink")
+
+# ===== backward compatibility ===== #
+parser.add_argument("--disable-safe-unpickle", action="store_true", help="does absolutely nothing", default=False)  # adetailer

modules/mac_specific.py

@@ -12,7 +12,7 @@ log = logging.getLogger(__name__)
 
 # before torch version 1.13, has_mps is only available in nightly pytorch and macOS 12.3+,
 # use check `getattr` and try it for compatibility.
-# in torch version 1.13, backends.mps.is_available() and backends.mps.is_built() are introduced in to check mps availabilty,
+# in torch version 1.13, backends.mps.is_available() and backends.mps.is_built() are introduced in to check mps availability,
 # since torch 2.0.1+ nightly build, getattr(torch, 'has_mps', False) was deprecated, see https://github.com/pytorch/pytorch/pull/103279
 def check_for_mps() -> bool:
     if version.parse(torch.__version__) <= version.parse("2.0.1"):

modules/processing.py

@@ -1,38 +1,54 @@
 from __future__ import annotations
+
+import hashlib
 import json
 import math
 import os
+import random
 import sys
-import hashlib
 from dataclasses import dataclass, field
+from typing import Any
 
-import torch
+import cv2
 import numpy as np
+import torch
+from einops import repeat
 from PIL import Image, ImageOps
-import random
-import cv2
 from skimage.exposure import match_histograms
-from typing import Any
 
-import modules.sd_hijack
-from modules import devices, prompt_parser, masking, sd_samplers, infotext_utils, extra_networks, sd_vae_approx, scripts, sd_samplers_common, sd_unet, errors, rng
-from modules.rng import slerp # noqa: F401
-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
-import modules.shared as shared
-import modules.paths as paths
 import modules.face_restoration
-import modules.images as images
-import modules.styles
+import modules.paths as paths
+import modules.sd_hijack
 import modules.sd_models as sd_models
 import modules.sd_vae as sd_vae
-
-from einops import repeat, rearrange
+import modules.shared as shared
+import modules.styles  # noqa
+import modules.images as images  # noqa (circular import)
+from modules import (
+    devices,
+    errors,
+    extra_networks,
+    infotext_utils,
+    masking,
+    prompt_parser,
+    rng,
+    scripts,
+    sd_samplers,
+    sd_samplers_common,
+    sd_unet,
+    sd_vae_approx,
+)
+from modules.rng import slerp  # noqa
+from modules.sd_hijack import model_hijack
 from modules.sd_models import apply_token_merging
-from modules_forge.forge_util import apply_circular_forge
+from modules.sd_samplers_common import (
+    approximation_indexes,
+    decode_first_stage,
+    images_tensor_to_samples,
+)
+from modules.shared import cmd_opts, opts, state
 from modules_forge.forge_loader import apply_alpha_schedule_override
-
+from modules_forge.forge_util import apply_circular_forge
 
 # some of those options should not be changed at all because they would break the model, so I removed them from options.
 opt_C = 4
@@ -59,7 +75,7 @@ def apply_color_correction(correction_target: np.ndarray, original_image: Image.
 
 def uncrop(image, dest_size, paste_loc):
     x, y, w, h = paste_loc
-    base_image = Image.new('RGBA', dest_size)
+    base_image = Image.new("RGBA", dest_size)
     image = images.resize_image(1, image, w, h)
     base_image.paste(image, (x, y))
     image = base_image
@@ -67,33 +83,59 @@ def uncrop(image, dest_size, paste_loc):
     return image
 
 
-def apply_overlay(image, paste_loc, overlay):
+def apply_overlay_precise(image: Image.Image, paste_loc: tuple[int], overlay: tuple[Image.Image, np.ndarray]):
+    _overlay, _mask = overlay
+
+    if paste_loc is not None:
+        image = uncrop(image, (_overlay.width, _overlay.height), paste_loc)
+
+    original_denoised_image = image.copy()
+
+    overlay_rgb = np.array(_overlay).astype(np.float32) / 255.0
+    image_np = np.array(image).astype(np.float32) / 255.0
+    image_rgb = image_np[:, :, :3]
+
+    _mask = np.expand_dims(_mask, axis=-1)
+    final = image_rgb * _mask + overlay_rgb * (1.0 - _mask)
+
+    _image = np.clip((final * 255.0).round(), 0, 255).astype(np.uint8)
+    image = Image.fromarray(_image)
+
+    return image, original_denoised_image
+
+
+def apply_overlay(image: Image.Image, paste_loc: tuple[int], overlay: Image.Image):
     if overlay is None:
         return image, image.copy()
 
+    if opts.img2img_inpaint_precise_mask:
+        return apply_overlay_precise(image, paste_loc, overlay)
+
     if paste_loc is not None:
         image = uncrop(image, (overlay.width, overlay.height), paste_loc)
 
     original_denoised_image = image.copy()
 
-    image = image.convert('RGBA')
+    image = image.convert("RGBA")
     image.alpha_composite(overlay)
-    image = image.convert('RGB')
+    image = image.convert("RGB")
 
     return image, original_denoised_image
 
+
 def create_binary_mask(image, round=True):
-    if image.mode == 'RGBA' and image.getextrema()[-1] != (255, 255):
+    if image.mode == "RGBA" and image.getextrema()[-1] != (255, 255):
         if round:
             image = image.split()[-1].convert("L").point(lambda x: 255 if x > 128 else 0)
         else:
             image = image.split()[-1].convert("L")
     else:
-        image = image.convert('L')
+        image = image.convert("L")
     return image
 
+
 def txt2img_image_conditioning(sd_model, x, width, height):
-    if sd_model.model.conditioning_key in {'hybrid', 'concat'}: # Inpainting models
+    if sd_model.model.conditioning_key in {"hybrid", "concat"}:  # Inpainting models
 
         # The "masked-image" in this case will just be all 0.5 since the entire image is masked.
         image_conditioning = torch.ones(x.shape[0], 3, height, width, device=x.device) * 0.5
@@ -105,19 +147,18 @@ def txt2img_image_conditioning(sd_model, x, width, height):
 
         return image_conditioning
 
-    elif sd_model.model.conditioning_key == "crossattn-adm": # UnCLIP models
+    elif sd_model.model.conditioning_key == "crossattn-adm":  # UnCLIP models
 
-        return x.new_zeros(x.shape[0], 2*sd_model.noise_augmentor.time_embed.dim, dtype=x.dtype, device=x.device)
+        return x.new_zeros(x.shape[0], 2 * sd_model.noise_augmentor.time_embed.dim, dtype=x.dtype, device=x.device)
 
     else:
         sd = sd_model.model.state_dict()
-        diffusion_model_input = sd.get('diffusion_model.input_blocks.0.0.weight', None)
+        diffusion_model_input = sd.get("diffusion_model.input_blocks.0.0.weight", None)
         if diffusion_model_input is not None:
             if diffusion_model_input.shape[1] == 9:
                 # The "masked-image" in this case will just be all 0.5 since the entire image is masked.
                 image_conditioning = torch.ones(x.shape[0], 3, height, width, device=x.device) * 0.5
-                image_conditioning = images_tensor_to_samples(image_conditioning,
-                                                              approximation_indexes.get(opts.sd_vae_encode_method))
+                image_conditioning = images_tensor_to_samples(image_conditioning, approximation_indexes.get(opts.sd_vae_encode_method))
 
                 # Add the fake full 1s mask to the first dimension.
                 image_conditioning = torch.nn.functional.pad(image_conditioning, (0, 0, 0, 0, 1, 0), value=1.0)
@@ -236,7 +277,7 @@ class StableDiffusionProcessing:
         self.s_min_uncond = self.s_min_uncond if self.s_min_uncond is not None else opts.s_min_uncond
         self.s_churn = self.s_churn if self.s_churn is not None else opts.s_churn
         self.s_tmin = self.s_tmin if self.s_tmin is not None else opts.s_tmin
-        self.s_tmax = (self.s_tmax if self.s_tmax is not None else opts.s_tmax) or float('inf')
+        self.s_tmax = (self.s_tmax if self.s_tmax is not None else opts.s_tmax) or float("inf")
         self.s_noise = self.s_noise if self.s_noise is not None else opts.s_noise
 
         self.extra_generation_params = self.extra_generation_params or {}
@@ -296,7 +337,7 @@ class StableDiffusionProcessing:
         self.comments[text] = 1
 
     def txt2img_image_conditioning(self, x, width=None, height=None):
-        self.is_using_inpainting_conditioning = self.sd_model.model.conditioning_key in {'hybrid', 'concat'}
+        self.is_using_inpainting_conditioning = self.sd_model.model.conditioning_key in {"hybrid", "concat"}
 
         return txt2img_image_conditioning(self.sd_model, x, width or self.width, height or self.height)
 
@@ -308,8 +349,8 @@ class StableDiffusionProcessing:
     def unclip_image_conditioning(self, source_image):
         c_adm = self.sd_model.embedder(source_image)
         if self.sd_model.noise_augmentor is not None:
-            noise_level = 0 # TODO: Allow other noise levels?
-            c_adm, noise_level_emb = self.sd_model.noise_augmentor(c_adm, noise_level=repeat(torch.tensor([noise_level]).to(c_adm.device), '1 -> b', b=c_adm.shape[0]))
+            noise_level = 0  # TODO: Allow other noise levels?
+            c_adm, noise_level_emb = self.sd_model.noise_augmentor(c_adm, noise_level=repeat(torch.tensor([noise_level]).to(c_adm.device), "1 -> b", b=c_adm.shape[0]))
             c_adm = torch.cat((c_adm, noise_level_emb), 1)
         return c_adm
 
@@ -335,11 +376,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(device=source_image.device, dtype=source_image.dtype)
-        conditioning_image = torch.lerp(
-            source_image,
-            source_image * (1.0 - conditioning_mask),
-            getattr(self, "inpainting_mask_weight", shared.opts.inpainting_mask_weight)
-        )
+        conditioning_image = torch.lerp(source_image, source_image * (1.0 - conditioning_mask), getattr(self, "inpainting_mask_weight", shared.opts.inpainting_mask_weight))
 
         # Encode the new masked image using first stage of network.
         conditioning_image = self.sd_model.get_first_stage_encoding(self.sd_model.encode_first_stage(conditioning_image))
@@ -358,14 +395,14 @@ class StableDiffusionProcessing:
         if self.sd_model.cond_stage_key == "edit":
             return self.edit_image_conditioning(source_image)
 
-        if self.sampler.conditioning_key in {'hybrid', 'concat'}:
+        if self.sampler.conditioning_key in {"hybrid", "concat"}:
             return self.inpainting_image_conditioning(source_image, latent_image, image_mask=image_mask, round_image_mask=round_image_mask)
 
         if self.sampler.conditioning_key == "crossattn-adm":
             return self.unclip_image_conditioning(source_image)
 
         sd = self.sampler.model_wrap.inner_model.model.state_dict()
-        diffusion_model_input = sd.get('diffusion_model.input_blocks.0.0.weight', None)
+        diffusion_model_input = sd.get("diffusion_model.input_blocks.0.0.weight", None)
         if diffusion_model_input is not None:
             if diffusion_model_input.shape[1] == 9:
                 return self.inpainting_image_conditioning(source_image, latent_image, image_mask=image_mask)
@@ -394,7 +431,7 @@ class StableDiffusionProcessing:
         return self.token_merging_ratio or opts.token_merging_ratio
 
     def setup_prompts(self):
-        if isinstance(self.prompt,list):
+        if isinstance(self.prompt, list):
             self.all_prompts = self.prompt
         elif isinstance(self.negative_prompt, list):
             self.all_prompts = [self.prompt] * len(self.negative_prompt)
@@ -505,7 +542,7 @@ class Processed:
         self.height = p.height
         self.sampler_name = p.sampler_name
         self.cfg_scale = p.cfg_scale
-        self.image_cfg_scale = getattr(p, 'image_cfg_scale', None)
+        self.image_cfg_scale = getattr(p, "image_cfg_scale", None)
         self.steps = p.steps
         self.batch_size = p.batch_size
         self.restore_faces = p.restore_faces
@@ -516,7 +553,7 @@ class Processed:
         self.sd_vae_hash = p.sd_vae_hash
         self.seed_resize_from_w = p.seed_resize_from_w
         self.seed_resize_from_h = p.seed_resize_from_h
-        self.denoising_strength = getattr(p, 'denoising_strength', None)
+        self.denoising_strength = getattr(p, "denoising_strength", None)
         self.extra_generation_params = p.extra_generation_params
         self.index_of_first_image = index_of_first_image
         self.styles = p.styles
@@ -611,7 +648,7 @@ def decode_latent_batch(model, batch, target_device=None, check_for_nans=False):
 
 
 def get_fixed_seed(seed):
-    if seed == '' or seed is None:
+    if seed == "" or seed is None:
         seed = -1
     elif isinstance(seed, str):
         try:
@@ -643,8 +680,8 @@ def create_infotext(p, all_prompts, all_seeds, all_subseeds, comments=None, iter
     if all_negative_prompts is None:
         all_negative_prompts = p.all_negative_prompts
 
-    clip_skip = getattr(p, 'clip_skip', opts.CLIP_stop_at_last_layers)
-    enable_hr = getattr(p, 'enable_hr', False)
+    clip_skip = getattr(p, "clip_skip", opts.CLIP_stop_at_last_layers)
+    enable_hr = getattr(p, "enable_hr", False)
     token_merging_ratio = p.get_token_merging_ratio()
     token_merging_ratio_hr = p.get_token_merging_ratio(for_hr=True)
 
@@ -663,7 +700,7 @@ def create_infotext(p, all_prompts, all_seeds, all_subseeds, comments=None, iter
         "Sampler": p.sampler_name,
         "Schedule type": p.scheduler,
         "CFG scale": p.cfg_scale,
-        "Image CFG scale": getattr(p, 'image_cfg_scale', None),
+        "Image CFG scale": getattr(p, "image_cfg_scale", None),
         "Seed": p.all_seeds[0] if use_main_prompt else all_seeds[index],
         "Face restoration": opts.face_restoration_model if p.restore_faces else None,
         "Size": f"{p.width}x{p.height}",
@@ -681,7 +718,7 @@ def create_infotext(p, all_prompts, all_seeds, all_subseeds, comments=None, iter
         "ENSD": opts.eta_noise_seed_delta if uses_ensd else None,
         "Token merging ratio": None if token_merging_ratio == 0 else token_merging_ratio,
         "Token merging ratio hr": None if not enable_hr or token_merging_ratio_hr == 0 else token_merging_ratio_hr,
-        "Init image hash": getattr(p, 'init_img_hash', None),
+        "Init image hash": getattr(p, "init_img_hash", None),
         "RNG": opts.randn_source if opts.randn_source != "GPU" else None,
         "NGMS": None if p.s_min_uncond == 0 else p.s_min_uncond,
         "Tiling": True if p.tiling else None,
@@ -701,7 +738,7 @@ def create_infotext(p, all_prompts, all_seeds, all_subseeds, comments=None, iter
             errors.report(f'Error creating infotext for key "{key}"', exc_info=True)
             generation_params[key] = None
 
-    generation_params_text = ", ".join([k if k == v else f'{k}: {infotext_utils.quote(v)}' for k, v in generation_params.items() if v is not None])
+    generation_params_text = ", ".join([k if k == v else f"{k}: {infotext_utils.quote(v)}" for k, v in generation_params.items() if v is not None])
 
     negative_prompt_text = f"\nNegative prompt: {negative_prompt}" if negative_prompt else ""
 
@@ -717,17 +754,17 @@ def process_images(p: StableDiffusionProcessing) -> Processed:
     try:
         # if no checkpoint override or the override checkpoint can't be found, remove override entry and load opts checkpoint
         # and if after running refiner, the refiner model is not unloaded - webui swaps back to main model here, if model over is present it will be reloaded afterwards
-        if sd_models.checkpoint_aliases.get(p.override_settings.get('sd_model_checkpoint')) is None:
-            p.override_settings.pop('sd_model_checkpoint', None)
+        if sd_models.checkpoint_aliases.get(p.override_settings.get("sd_model_checkpoint")) is None:
+            p.override_settings.pop("sd_model_checkpoint", None)
             sd_models.reload_model_weights()
 
         for k, v in p.override_settings.items():
             opts.set(k, v, is_api=True, run_callbacks=False)
 
-            if k == 'sd_model_checkpoint':
+            if k == "sd_model_checkpoint":
                 sd_models.reload_model_weights()
 
-            if k == 'sd_vae':
+            if k == "sd_vae":
                 sd_vae.reload_vae_weights()
 
         sd_samplers.fix_p_invalid_sampler_and_scheduler(p)
@@ -740,7 +777,7 @@ def process_images(p: StableDiffusionProcessing) -> Processed:
             for k, v in stored_opts.items():
                 setattr(opts, k, v)
 
-                if k == 'sd_vae':
+                if k == "sd_vae":
                     sd_vae.reload_vae_weights()
 
     return res
@@ -750,7 +787,7 @@ def process_images_inner(p: StableDiffusionProcessing) -> Processed:
     """this is the main loop that both txt2img and img2img use; it calls func_init once inside all the scopes and func_sample once per batch"""
 
     if isinstance(p.prompt, list):
-        assert(len(p.prompt) > 0)
+        assert len(p.prompt) > 0
     else:
         assert p.prompt is not None
 
@@ -768,7 +805,7 @@ def process_images_inner(p: StableDiffusionProcessing) -> Processed:
     if p.refiner_checkpoint not in (None, "", "None", "none"):
         p.refiner_checkpoint_info = sd_models.get_closet_checkpoint_match(p.refiner_checkpoint)
         if p.refiner_checkpoint_info is None:
-            raise Exception(f'Could not find checkpoint with name {p.refiner_checkpoint}')
+            raise Exception(f"Could not find checkpoint with name {p.refiner_checkpoint}")
 
     p.sd_model_name = shared.sd_model.sd_checkpoint_info.name_for_extra
     p.sd_model_hash = shared.sd_model.sd_model_hash
@@ -823,10 +860,10 @@ def process_images_inner(p: StableDiffusionProcessing) -> Processed:
             sd_models.reload_model_weights()  # model can be changed for example by refiner
 
             p.sd_model.forge_objects = p.sd_model.forge_objects_original.shallow_copy()
-            p.prompts = p.all_prompts[n * p.batch_size:(n + 1) * p.batch_size]
-            p.negative_prompts = p.all_negative_prompts[n * p.batch_size:(n + 1) * p.batch_size]
-            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.prompts = p.all_prompts[n * p.batch_size : (n + 1) * p.batch_size]
+            p.negative_prompts = p.all_negative_prompts[n * p.batch_size : (n + 1) * p.batch_size]
+            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)
 
@@ -874,11 +911,11 @@ def process_images_inner(p: StableDiffusionProcessing) -> Processed:
                 p.scripts.post_sample(p, ps)
                 samples_ddim = ps.samples
 
-            if getattr(samples_ddim, 'already_decoded', False):
+            if getattr(samples_ddim, "already_decoded", False):
                 x_samples_ddim = samples_ddim
             else:
-                if opts.sd_vae_decode_method != 'Full':
-                    p.extra_generation_params['VAE Decoder'] = opts.sd_vae_decode_method
+                if opts.sd_vae_decode_method != "Full":
+                    p.extra_generation_params["VAE Decoder"] = opts.sd_vae_decode_method
                 x_samples_ddim = decode_latent_batch(p.sd_model, samples_ddim, target_device=devices.cpu, check_for_nans=True)
 
             x_samples_ddim = torch.stack(x_samples_ddim).float()
@@ -893,8 +930,8 @@ def process_images_inner(p: StableDiffusionProcessing) -> Processed:
             if p.scripts is not None:
                 p.scripts.postprocess_batch(p, x_samples_ddim, batch_number=n)
 
-                p.prompts = p.all_prompts[n * p.batch_size:(n + 1) * p.batch_size]
-                p.negative_prompts = p.all_negative_prompts[n * p.batch_size:(n + 1) * p.batch_size]
+                p.prompts = p.all_prompts[n * p.batch_size : (n + 1) * p.batch_size]
+                p.negative_prompts = p.all_negative_prompts[n * p.batch_size : (n + 1) * p.batch_size]
 
                 batch_params = scripts.PostprocessBatchListArgs(list(x_samples_ddim))
                 p.scripts.postprocess_batch_list(p, batch_params, batch_number=n)
@@ -908,7 +945,7 @@ def process_images_inner(p: StableDiffusionProcessing) -> Processed:
             for i, x_sample in enumerate(x_samples_ddim):
                 p.batch_index = i
 
-                x_sample = 255. * np.moveaxis(x_sample.cpu().numpy(), 0, 2)
+                x_sample = 255.0 * np.moveaxis(x_sample.cpu().numpy(), 0, 2)
                 x_sample = x_sample.astype(np.uint8)
 
                 if p.restore_faces:
@@ -969,14 +1006,14 @@ def process_images_inner(p: StableDiffusionProcessing) -> Processed:
 
                 if mask_for_overlay is not None:
                     if opts.return_mask or opts.save_mask:
-                        image_mask = mask_for_overlay.convert('RGB')
+                        image_mask = mask_for_overlay.convert("RGB")
                         if save_samples and opts.save_mask:
                             images.save_image(image_mask, p.outpath_samples, "", p.seeds[i], p.prompts[i], opts.samples_format, info=infotext(i), p=p, suffix="-mask")
                         if opts.return_mask:
                             output_images.append(image_mask)
 
                     if opts.return_mask_composite or opts.save_mask_composite:
-                        image_mask_composite = Image.composite(original_denoised_image.convert('RGBA').convert('RGBa'), Image.new('RGBa', image.size), images.resize_image(2, mask_for_overlay, image.width, image.height).convert('L')).convert('RGBA')
+                        image_mask_composite = Image.composite(original_denoised_image.convert("RGBA").convert("RGBa"), Image.new("RGBa", image.size), images.resize_image(2, mask_for_overlay, image.width, image.height).convert("L")).convert("RGBA")
                         if save_samples and opts.save_mask_composite:
                             images.save_image(image_mask_composite, p.outpath_samples, "", p.seeds[i], p.prompts[i], opts.samples_format, info=infotext(i), p=p, suffix="-mask-composite")
                         if opts.return_mask_composite:
@@ -1054,8 +1091,10 @@ class StableDiffusionProcessingTxt2Img(StableDiffusionProcessing):
     hr_checkpoint_name: str = None
     hr_sampler_name: str = None
     hr_scheduler: str = None
-    hr_prompt: str = ''
-    hr_negative_prompt: str = ''
+    hr_cfg_scale: float = None
+    hr_rescale_cfg: float = None
+    hr_prompt: str = ""
+    hr_negative_prompt: str = ""
     force_task_id: str = None
 
     cached_hr_uc = [None, None]
@@ -1128,57 +1167,68 @@ class StableDiffusionProcessingTxt2Img(StableDiffusionProcessing):
                 self.truncate_y = (self.hr_upscale_to_y - target_h) // opt_f
 
     def init(self, all_prompts, all_seeds, all_subseeds):
-        if self.enable_hr:
-            self.extra_generation_params["Denoising strength"] = self.denoising_strength
+        if not self.enable_hr:
+            return
 
-            if self.hr_checkpoint_name and self.hr_checkpoint_name != 'Use same checkpoint':
-                self.hr_checkpoint_info = sd_models.get_closet_checkpoint_match(self.hr_checkpoint_name)
+        self.extra_generation_params["Denoising strength"] = self.denoising_strength
 
-                if self.hr_checkpoint_info is None:
-                    raise Exception(f'Could not find checkpoint with name {self.hr_checkpoint_name}')
+        if self.hr_checkpoint_name and self.hr_checkpoint_name != "Use same checkpoint":
+            self.hr_checkpoint_info = sd_models.get_closet_checkpoint_match(self.hr_checkpoint_name)
 
-                if shared.sd_model.sd_checkpoint_info == self.hr_checkpoint_info:
-                    self.hr_checkpoint_info = None
-                else:
-                    self.extra_generation_params["Hires checkpoint"] = self.hr_checkpoint_info.short_title
+            if self.hr_checkpoint_info is None:
+                raise Exception(f"Could not find checkpoint with name {self.hr_checkpoint_name}")
+
+            if shared.sd_model.sd_checkpoint_info == self.hr_checkpoint_info:
+                self.hr_checkpoint_info = None
+            else:
+                self.extra_generation_params["Hires checkpoint"] = self.hr_checkpoint_info.short_title
 
-            if self.hr_sampler_name is not None and self.hr_sampler_name != self.sampler_name:
-                self.extra_generation_params["Hires sampler"] = self.hr_sampler_name
+        if self.hr_sampler_name is not None and self.hr_sampler_name != self.sampler_name:
+            self.extra_generation_params["Hires sampler"] = self.hr_sampler_name
 
-            self.extra_generation_params["Hires schedule type"] = None  # to be set in sd_samplers_kdiffusion.py
- 
-            if self.hr_scheduler is None:
-                self.hr_scheduler = self.scheduler
+        self.extra_generation_params["Hires schedule type"] = None  # to be set in sd_samplers_kdiffusion.py
 
-            if tuple(self.hr_prompt) != tuple(self.prompt):
-                self.extra_generation_params["Hires prompt"] = self.hr_prompt
+        if self.hr_scheduler is None:
+            self.hr_scheduler = self.scheduler
 
-            if tuple(self.hr_negative_prompt) != tuple(self.negative_prompt):
-                self.extra_generation_params["Hires negative prompt"] = self.hr_negative_prompt
+        if self.hr_cfg_scale != self.cfg_scale:
+            self.extra_generation_params["Hires CFG Scale"] = self.hr_cfg_scale
 
-            self.latent_scale_mode = shared.latent_upscale_modes.get(self.hr_upscaler, None) if self.hr_upscaler is not None else shared.latent_upscale_modes.get(shared.latent_upscale_default_mode, "nearest")
-            if self.enable_hr and self.latent_scale_mode is None:
-                if not any(x.name == self.hr_upscaler for x in shared.sd_upscalers):
-                    raise Exception(f"could not find upscaler named {self.hr_upscaler}")
+        if self.hr_rescale_cfg:
+            from modules.processing_scripts.rescale_cfg import ScriptRescaleCFG
 
-            self.calculate_target_resolution()
+            ScriptRescaleCFG.apply_rescale_cfg(self, self.hr_rescale_cfg)
+            self.extra_generation_params["Hires Rescale CFG"] = self.hr_rescale_cfg
 
-            if not state.processing_has_refined_job_count:
-                if state.job_count == -1:
-                    state.job_count = self.n_iter
-                if getattr(self, 'txt2img_upscale', False):
-                    total_steps = (self.hr_second_pass_steps or self.steps) * state.job_count
-                else:
-                    total_steps = (self.steps + (self.hr_second_pass_steps or self.steps)) * state.job_count
-                shared.total_tqdm.updateTotal(total_steps)
-                state.job_count = state.job_count * 2
-                state.processing_has_refined_job_count = True
+        if tuple(self.hr_prompt) != tuple(self.prompt):
+            self.extra_generation_params["Hires prompt"] = self.hr_prompt
 
-            if self.hr_second_pass_steps:
-                self.extra_generation_params["Hires steps"] = self.hr_second_pass_steps
+        if tuple(self.hr_negative_prompt) != tuple(self.negative_prompt):
+            self.extra_generation_params["Hires negative prompt"] = self.hr_negative_prompt
 
-            if self.hr_upscaler is not None:
-                self.extra_generation_params["Hires upscaler"] = self.hr_upscaler
+        self.latent_scale_mode = shared.latent_upscale_modes.get(self.hr_upscaler, None) if self.hr_upscaler is not None else shared.latent_upscale_modes.get(shared.latent_upscale_default_mode, "nearest")
+        if self.enable_hr and self.latent_scale_mode is None:
+            if not any(x.name == self.hr_upscaler for x in shared.sd_upscalers):
+                raise Exception(f"could not find upscaler named {self.hr_upscaler}")
+
+        self.calculate_target_resolution()
+
+        if not state.processing_has_refined_job_count:
+            if state.job_count == -1:
+                state.job_count = self.n_iter
+            if getattr(self, "txt2img_upscale", False):
+                total_steps = (self.hr_second_pass_steps or self.steps) * state.job_count
+            else:
+                total_steps = (self.steps + (self.hr_second_pass_steps or self.steps)) * state.job_count
+            shared.total_tqdm.updateTotal(total_steps)
+            state.job_count = state.job_count * 2
+            state.processing_has_refined_job_count = True
+
+        if self.hr_second_pass_steps:
+            self.extra_generation_params["Hires steps"] = self.hr_second_pass_steps
+
+        if self.hr_upscaler is not None:
+            self.extra_generation_params["Hires upscaler"] = self.hr_upscaler
 
     def sample(self, conditioning, unconditional_conditioning, seeds, subseeds, subseed_strength, prompts):
         self.sampler = sd_samplers.create_sampler(self.sampler_name, self.sd_model)
@@ -1199,8 +1249,8 @@ class StableDiffusionProcessingTxt2Img(StableDiffusionProcessing):
                 image = torch.from_numpy(np.expand_dims(image, axis=0))
                 image = image.to(shared.device, dtype=torch.float32)
 
-                if opts.sd_vae_encode_method != 'Full':
-                    self.extra_generation_params['VAE Encoder'] = opts.sd_vae_encode_method
+                if opts.sd_vae_encode_method != "Full":
+                    self.extra_generation_params["VAE Encoder"] = opts.sd_vae_encode_method
 
                 samples = images_tensor_to_samples(image, approximation_indexes.get(opts.sd_vae_encode_method), self.sd_model)
                 decoded_samples = None
@@ -1215,11 +1265,7 @@ class StableDiffusionProcessingTxt2Img(StableDiffusionProcessing):
             apply_token_merging(self.sd_model, self.get_token_merging_ratio())
 
             if self.scripts is not None:
-                self.scripts.process_before_every_sampling(self,
-                                                           x=x,
-                                                           noise=x,
-                                                           c=conditioning,
-                                                           uc=unconditional_conditioning)
+                self.scripts.process_before_every_sampling(self, x=x, noise=x, c=conditioning, uc=unconditional_conditioning)
 
             if self.modified_noise is not None:
                 x = self.modified_noise
@@ -1284,7 +1330,7 @@ class StableDiffusionProcessingTxt2Img(StableDiffusionProcessing):
 
             batch_images = []
             for i, x_sample in enumerate(lowres_samples):
-                x_sample = 255. * np.moveaxis(x_sample.cpu().numpy(), 0, 2)
+                x_sample = 255.0 * np.moveaxis(x_sample.cpu().numpy(), 0, 2)
                 x_sample = x_sample.astype(np.uint8)
                 image = Image.fromarray(x_sample)
 
@@ -1298,15 +1344,15 @@ class StableDiffusionProcessingTxt2Img(StableDiffusionProcessing):
             decoded_samples = torch.from_numpy(np.array(batch_images))
             decoded_samples = decoded_samples.to(shared.device, dtype=torch.float32)
 
-            if opts.sd_vae_encode_method != 'Full':
-                self.extra_generation_params['VAE Encoder'] = opts.sd_vae_encode_method
+            if opts.sd_vae_encode_method != "Full":
+                self.extra_generation_params["VAE Encoder"] = opts.sd_vae_encode_method
             samples = images_tensor_to_samples(decoded_samples, approximation_indexes.get(opts.sd_vae_encode_method))
 
             image_conditioning = self.img2img_image_conditioning(decoded_samples, samples)
 
         shared.state.nextjob()
 
-        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]
+        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]
 
         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()
@@ -1328,11 +1374,7 @@ class StableDiffusionProcessingTxt2Img(StableDiffusionProcessing):
         apply_token_merging(self.sd_model, self.get_token_merging_ratio(for_hr=True))
 
         if self.scripts is not None:
-            self.scripts.process_before_every_sampling(self,
-                                                       x=samples,
-                                                       noise=noise,
-                                                       c=self.hr_c,
-                                                       uc=self.hr_uc)
+            self.scripts.process_before_every_sampling(self, x=samples, noise=noise, c=self.hr_c, uc=self.hr_uc)
 
         if self.modified_noise is not None:
             noise = self.modified_noise
@@ -1362,10 +1404,10 @@ class StableDiffusionProcessingTxt2Img(StableDiffusionProcessing):
         if not self.enable_hr:
             return
 
-        if self.hr_prompt == '':
+        if self.hr_prompt == "":
             self.hr_prompt = self.prompt
 
-        if self.hr_negative_prompt == '':
+        if self.hr_negative_prompt == "":
             self.hr_negative_prompt = self.negative_prompt
 
         if isinstance(self.hr_prompt, list):
@@ -1430,8 +1472,8 @@ class StableDiffusionProcessingTxt2Img(StableDiffusionProcessing):
         res = super().parse_extra_network_prompts()
 
         if self.enable_hr:
-            self.hr_prompts = self.all_hr_prompts[self.iteration * self.batch_size:(self.iteration + 1) * self.batch_size]
-            self.hr_negative_prompts = self.all_hr_negative_prompts[self.iteration * self.batch_size:(self.iteration + 1) * self.batch_size]
+            self.hr_prompts = self.all_hr_prompts[self.iteration * self.batch_size : (self.iteration + 1) * self.batch_size]
+            self.hr_negative_prompts = self.all_hr_negative_prompts[self.iteration * self.batch_size : (self.iteration + 1) * self.batch_size]
 
             self.hr_prompts, self.hr_extra_network_data = extra_networks.parse_prompts(self.hr_prompts)
 
@@ -1515,19 +1557,24 @@ class StableDiffusionProcessingImg2Img(StableDiffusionProcessing):
                 np_mask = cv2.GaussianBlur(np_mask, (1, kernel_size), self.mask_blur_y)
                 image_mask = Image.fromarray(np_mask)
 
+            if opts.img2img_inpaint_precise_mask and self.mask_blur_x * self.mask_blur_y > 0:
+                _np_mask = np.array(image_mask).astype(np.float32) / 255.0
+                kernel_size = 2 * int(2.5 * self.mask_blur_x + 0.5) + 1
+                _image_mask = cv2.GaussianBlur(_np_mask, (kernel_size, kernel_size), self.mask_blur_x)
+
             if self.mask_blur_x > 0 or self.mask_blur_y > 0:
                 self.extra_generation_params["Mask blur"] = self.mask_blur
 
             if self.inpaint_full_res:
                 self.mask_for_overlay = image_mask
-                mask = image_mask.convert('L')
+                mask = image_mask.convert("L")
                 crop_region = masking.get_crop_region(mask, self.inpaint_full_res_padding)
                 crop_region = masking.expand_crop_region(crop_region, self.width, self.height, mask.width, mask.height)
                 x1, y1, x2, y2 = crop_region
 
                 mask = mask.crop(crop_region)
                 image_mask = images.resize_image(2, mask, self.width, self.height)
-                self.paste_to = (x1, y1, x2-x1, y2-y1)
+                self.paste_to = (x1, y1, x2 - x1, y2 - y1)
 
                 self.extra_generation_params["Inpaint area"] = "Only masked"
                 self.extra_generation_params["Masked area padding"] = self.inpaint_full_res_padding
@@ -1558,10 +1605,12 @@ class StableDiffusionProcessingImg2Img(StableDiffusionProcessing):
                 image = images.resize_image(self.resize_mode, image, self.width, self.height)
 
             if image_mask is not None:
-                image_masked = Image.new('RGBa', (image.width, image.height))
-                image_masked.paste(image.convert("RGBA").convert("RGBa"), mask=ImageOps.invert(self.mask_for_overlay.convert('L')))
-
-                self.overlay_images.append(image_masked.convert('RGBA'))
+                if opts.img2img_inpaint_precise_mask:
+                    self.overlay_images.append((image, _image_mask))
+                else:
+                    image_masked = Image.new("RGBa", (image.width, image.height))
+                    image_masked.paste(image.convert("RGBA").convert("RGBa"), mask=ImageOps.invert(self.mask_for_overlay.convert("L")))
+                    self.overlay_images.append(image_masked.convert("RGBA"))
 
             # crop_region is not None if we are doing inpaint full res
             if crop_region is not None:
@@ -1573,7 +1622,7 @@ class StableDiffusionProcessingImg2Img(StableDiffusionProcessing):
                     image = masking.fill(image, latent_mask)
 
                     if self.inpainting_fill == 0:
-                        self.extra_generation_params["Masked content"] = 'fill'
+                        self.extra_generation_params["Masked content"] = "fill"
 
             if add_color_corrections:
                 self.color_corrections.append(setup_color_correction(image))
@@ -1600,8 +1649,8 @@ class StableDiffusionProcessingImg2Img(StableDiffusionProcessing):
         image = torch.from_numpy(batch_images)
         image = image.to(shared.device, dtype=torch.float32)
 
-        if opts.sd_vae_encode_method != 'Full':
-            self.extra_generation_params['VAE Encoder'] = opts.sd_vae_encode_method
+        if opts.sd_vae_encode_method != "Full":
+            self.extra_generation_params["VAE Encoder"] = opts.sd_vae_encode_method
 
         self.init_latent = images_tensor_to_samples(image, approximation_indexes.get(opts.sd_vae_encode_method), self.sd_model)
         devices.torch_gc()
@@ -1611,7 +1660,7 @@ class StableDiffusionProcessingImg2Img(StableDiffusionProcessing):
 
         if image_mask is not None:
             init_mask = latent_mask
-            latmask = init_mask.convert('RGB').resize((self.init_latent.shape[3], self.init_latent.shape[2]))
+            latmask = init_mask.convert("RGB").resize((self.init_latent.shape[3], self.init_latent.shape[2]))
             latmask = np.moveaxis(np.array(latmask, dtype=np.float32), 2, 0) / 255
             latmask = latmask[0]
             if self.mask_round:
@@ -1623,12 +1672,12 @@ class StableDiffusionProcessingImg2Img(StableDiffusionProcessing):
 
             # this needs to be fixed to be done in sample() using actual seeds for batches
             if self.inpainting_fill == 2:
-                self.init_latent = self.init_latent * self.mask + create_random_tensors(self.init_latent.shape[1:], all_seeds[0:self.init_latent.shape[0]]) * self.nmask
-                self.extra_generation_params["Masked content"] = 'latent noise'
+                self.init_latent = self.init_latent * self.mask + create_random_tensors(self.init_latent.shape[1:], all_seeds[0 : self.init_latent.shape[0]]) * self.nmask
+                self.extra_generation_params["Masked content"] = "latent noise"
 
             elif self.inpainting_fill == 3:
                 self.init_latent = self.init_latent * self.mask
-                self.extra_generation_params["Masked content"] = 'latent nothing'
+                self.extra_generation_params["Masked content"] = "latent nothing"
 
         self.image_conditioning = self.img2img_image_conditioning(image * 2 - 1, self.init_latent, image_mask, self.mask_round)
 
@@ -1643,11 +1692,7 @@ class StableDiffusionProcessingImg2Img(StableDiffusionProcessing):
         apply_token_merging(self.sd_model, self.get_token_merging_ratio())
 
         if self.scripts is not None:
-            self.scripts.process_before_every_sampling(self,
-                                                       x=self.init_latent,
-                                                       noise=x,
-                                                       c=conditioning,
-                                                       uc=unconditional_conditioning)
+            self.scripts.process_before_every_sampling(self, x=self.init_latent, noise=x, c=conditioning, uc=unconditional_conditioning)
 
         if self.modified_noise is not None:
             x = self.modified_noise

modules/processing_scripts/comments.py

@@ -1,7 +1,11 @@
 import re
+from typing import TYPE_CHECKING
 
 from modules import script_callbacks, scripts, shared
 
+if TYPE_CHECKING:
+    from modules.processing import StableDiffusionProcessing
+
 
 def strip_comments(text):
     text = re.sub("(^|\n)#[^\n]*(\n|$)", "\n", text)  # while line comment
@@ -17,7 +21,7 @@ class ScriptComments(scripts.Script):
     def show(self, is_img2img):
         return scripts.AlwaysVisible
 
-    def process(self, p, *args):
+    def process(self, p: "StableDiffusionProcessing", *args):
         if not shared.opts.enable_prompt_comments:
             return
 
@@ -27,6 +31,13 @@ class ScriptComments(scripts.Script):
         p.main_prompt = strip_comments(p.main_prompt)
         p.main_negative_prompt = strip_comments(p.main_negative_prompt)
 
+        if getattr(p, "enable_hr", False):
+            p.all_hr_prompts = [strip_comments(x) for x in p.all_hr_prompts]
+            p.all_hr_negative_prompts = [strip_comments(x) for x in p.all_hr_negative_prompts]
+
+            p.hr_prompt = strip_comments(p.hr_prompt)
+            p.hr_negative_prompt = strip_comments(p.hr_negative_prompt)
+
 
 def before_token_counter(params: script_callbacks.BeforeTokenCounterParams):
     if not shared.opts.enable_prompt_comments:

modules/processing_scripts/rescale_cfg.py

@@ -43,6 +43,13 @@ class ScriptRescaleCFG(scripts.ScriptBuiltinUI):
     def process_before_every_sampling(self, p, cfg, *args, **kwargs):
         if not opts.show_rescale_cfg or cfg < 0.05:
             return
+        if p.is_hr_pass:
+            return
+
+        self.apply_rescale_cfg(p, cfg)
+
+    @staticmethod
+    def apply_rescale_cfg(p, cfg):
 
         @torch.inference_mode()
         def rescale_cfg(args):

modules/processing_scripts/sampler.py

@@ -26,14 +26,14 @@ class ScriptSampler(scripts.ScriptBuiltinUI):
 
         with FormRow(elem_id=f"sampler_selection_{self.tabname}"):
             self.sampler_name = gr.Dropdown(
-                label="Sampling method",
+                label="Sampling Method",
                 elem_id=f"{self.tabname}_sampling",
                 choices=sampler_names,
                 value=sampler_names[0],
             )
             if shared.opts.show_scheduler:
                 self.scheduler = gr.Dropdown(
-                    label="Schedule type",
+                    label="Schedule Type",
                     elem_id=f"{self.tabname}_scheduler",
                     choices=scheduler_names,
                     value=scheduler_names[0],
@@ -43,10 +43,10 @@ class ScriptSampler(scripts.ScriptBuiltinUI):
                 self.scheduler.do_not_save_to_config = True
             self.steps = gr.Slider(
                 minimum=1,
-                maximum=150,
+                maximum=128,
                 step=1,
                 elem_id=f"{self.tabname}_steps",
-                label="Sampling steps",
+                label="Sampling Steps",
                 value=20,
             )
 

modules/rng.py

@@ -40,7 +40,7 @@ def randn_local(seed, shape):
 
 
 def randn_like(x):
-    """Generate a tensor with random numbers from a normal distribution using the previously initialized genrator.
+    """Generate a tensor with random numbers from a normal distribution using the previously initialized generator.
 
     Use either randn() or manual_seed() to initialize the generator."""
 
@@ -54,7 +54,7 @@ def randn_like(x):
 
 
 def randn_without_seed(shape, generator=None):
-    """Generate a tensor with random numbers from a normal distribution using the previously initialized genrator.
+    """Generate a tensor with random numbers from a normal distribution using the previously initialized generator.
 
     Use either randn() or manual_seed() to initialize the generator."""
 

modules/scripts_postprocessing.py

@@ -59,7 +59,7 @@ class ScriptPostprocessing:
     args_to = None
 
     order = 1000
-    """scripts will be ordred by this value in postprocessing UI"""
+    """scripts will be ordered by this value in postprocessing UI"""
 
     name = None
     """this function should return the title of the script."""

modules/sd_hijack_clip.py

@@ -215,7 +215,7 @@ class FrozenCLIPEmbedderWithCustomWordsBase(torch.nn.Module):
         be a multiple of 77; and C is dimensionality of each token - for SD1 it's 768, for SD2 it's 1024, and for SDXL it's 1280.
         An example shape returned by this function can be: (2, 77, 768).
         For SDXL, instead of returning one tensor above, it returns a tuple with two: the other one with shape (B, 1280) with pooled values.
-        Webui usually sends just one text at a time through this function - the only time when texts is an array with more than one elemenet
+        Webui usually sends just one text at a time through this function - the only time when texts is an array with more than one element
         is when you do prompt editing: "a picture of a [cat:dog:0.4] eating ice cream"
         """
 

modules/sd_samplers_common.py

@@ -96,9 +96,12 @@ def samples_to_images_tensor(sample, approximation=None, model=None):
 def single_sample_to_image(sample, approximation=None):
     x_sample = samples_to_images_tensor(sample.unsqueeze(0), approximation)[0] * 0.5 + 0.5
 
-    x_sample = torch.clamp(x_sample, min=0.0, max=1.0)
-    x_sample = 255.0 * np.moveaxis(x_sample.cpu().numpy(), 0, 2)
-    x_sample = x_sample.astype(np.uint8)
+    x_sample = x_sample.cpu()
+    x_sample.mul_(255.0)
+    x_sample.round_()
+    x_sample.clamp_(0.0, 255.0)
+    x_sample = x_sample.to(torch.uint8)
+    x_sample = np.moveaxis(x_sample.numpy(), 0, 2)
 
     return Image.fromarray(x_sample)
 

modules/sd_samplers_kdiffusion.py

@@ -17,6 +17,7 @@ from modules_forge.forge_sampler import sampling_cleanup, sampling_prepare
 samplers_k_diffusion = [
     ("DPM++ 2M", "sample_dpmpp_2m", ["k_dpmpp_2m"], {"scheduler": "karras"}),
     ("DPM++ SDE", "sample_dpmpp_sde", ["k_dpmpp_sde"], {"scheduler": "karras", "second_order": True, "brownian_noise": True}),
+    ("DPM++ 2M SDE", "sample_dpmpp_2m_sde", ["k_dpmpp_2m_sde_ka"], {"brownian_noise": True}),
     ("DPM++ 3M SDE", "sample_dpmpp_3m_sde", ["k_dpmpp_3m_sde"], {"scheduler": "exponential", "discard_next_to_last_sigma": True, "brownian_noise": True}),
     ("Euler a", "sample_euler_ancestral", ["k_euler_a", "k_euler_ancestral"], {"uses_ensd": True}),
     ("Euler", "sample_euler", ["k_euler"], {}),
@@ -41,6 +42,7 @@ samplers_data_k_diffusion = [
 
 sampler_extra_params = {
     "sample_dpmpp_sde": ["eta", "s_noise", "r"],
+    "sample_dpmpp_2m_sde": ["eta", "s_noise"],
     "sample_dpmpp_3m_sde": ["eta", "s_noise"],
     "sample_euler_ancestral": ["eta", "s_noise"],
     "sample_euler": ["s_churn", "s_tmin", "s_tmax", "s_noise"],
@@ -56,11 +58,7 @@ class CFGDenoiserKDiffusion(sd_samplers_cfg_denoiser.CFGDenoiser):
     @property
     def inner_model(self):
         if self.model_wrap is None:
-            denoiser = (
-                k_diffusion.external.CompVisVDenoiser
-                if shared.sd_model.parameterization == "v"
-                else k_diffusion.external.CompVisDenoiser
-            )
+            denoiser = k_diffusion.external.CompVisVDenoiser if shared.sd_model.parameterization == "v" else k_diffusion.external.CompVisDenoiser
             self.model_wrap = denoiser(shared.sd_model, quantize=True)
 
         return self.model_wrap
@@ -208,7 +206,7 @@ class KDiffusionSampler(sd_samplers_common.Sampler):
             "cond": conditioning,
             "image_cond": image_conditioning,
             "uncond": unconditional_conditioning,
-            "cond_scale": p.cfg_scale,
+            "cond_scale": p.hr_cfg_scale if p.is_hr_pass else p.cfg_scale,
             "s_min_uncond": self.s_min_uncond,
         }
 
@@ -269,7 +267,7 @@ class KDiffusionSampler(sd_samplers_common.Sampler):
             "cond": conditioning,
             "image_cond": image_conditioning,
             "uncond": unconditional_conditioning,
-            "cond_scale": p.cfg_scale,
+            "cond_scale": p.hr_cfg_scale if p.is_hr_pass else p.cfg_scale,
             "s_min_uncond": self.s_min_uncond,
         }
 

modules/shared.py

@@ -95,3 +95,6 @@ reload_gradio_theme = shared_gradio_themes.reload_gradio_theme
 list_checkpoint_tiles = shared_items.list_checkpoint_tiles
 refresh_checkpoints = shared_items.refresh_checkpoints
 list_samplers = shared_items.list_samplers
+
+# ===== backward compatibility ===== #
+batch_cond_uncond = True

modules/shared_options.py

@@ -226,8 +226,10 @@ options_templates.update(
             "img2img_inpaint_sketch_default_brush_color": OptionInfo("#ff0000", "Initial Brush Color for Inpaint Sketch", ui_components.FormColorPicker, {}).needs_reload_ui(),
             "return_mask": OptionInfo(False, "For inpainting, append the greyscale mask to results"),
             "return_mask_composite": OptionInfo(False, "For inpainting, append the masked composite to results"),
-            "overlay_inpaint": OptionInfo(True, "For inpainting, overlay the original image over the areas that were untouched"),
+            "overlay_inpaint": OptionInfo(True, "For inpainting, overlay the resulting image back onto the original image").info('when using the "Only masked" option'),
             "img2img_batch_show_results_limit": OptionInfo(32, "Show the first N batch of img2img results in UI", gr.Slider, {"minimum": -1, "maximum": 256, "step": 1}).info("0 = disable; -1 = show all; too many images causes severe lag"),
+            "div_exp": OptionDiv(),
+            "img2img_inpaint_precise_mask": OptionInfo(False, 'For inpainting, process the "Mask blur" in fp32 instead of uint8 precision; improve blending result').info('<b>Experimental</b> ; may break functions that access the "overlay_images"'),
         },
     )
 )
@@ -353,8 +355,8 @@ options_templates.update(
             "compact_prompt_box": OptionInfo(False, "Compact Prompt Layout").info("put prompts inside the Generate tab, leaving more space for the gallery").needs_reload_ui(),
             "dimensions_and_batch_together": OptionInfo(True, "Show Width/Height and Batch sliders in same row").needs_reload_ui(),
             "sd_checkpoint_dropdown_use_short": OptionInfo(False, "Show filenames without folder in the Checkpoint dropdown").info("if disabled, models under subdirectories will be listed like sdxl/anime.safetensors"),
-            "hires_fix_show_prompts": OptionInfo(False, "[Hires. fix]: Show prompt and negative prompt").needs_reload_ui(),
-            "hires_fix_show_sampler": OptionInfo(False, "[Hires. fix]: Show checkpoint and sampler selection").needs_reload_ui(),
+            "hires_fix_show_sampler": OptionInfo(False, "[Hires. fix]: Show checkpoint, sampler, scheduler, and cfg options").needs_reload_ui(),
+            "hires_fix_show_prompts": OptionInfo(False, "[Hires. fix]: Show prompt and negative prompt textboxes").needs_reload_ui(),
             "txt2img_settings_accordion": OptionInfo(False, "Put txt2img parameters under Accordion").needs_reload_ui(),
             "img2img_settings_accordion": OptionInfo(False, "Put img2img parameters under Accordion").needs_reload_ui(),
             "interrupt_after_current": OptionInfo(False, "Don't Interrupt in the middle").info("when using the Interrupt button, if generating more than one image, stop after the current generation of an image has finished instead of immediately"),
@@ -493,6 +495,8 @@ options_templates.update(
             "disable_all_extensions": OptionInfo("none", "Disable all extensions (preserves the list of disabled extensions)", gr.Radio, {"choices": ("none", "extra", "all")}),
             "restore_config_state_file": OptionInfo("", 'Config state file to restore from, under "config-states/" folder'),
             "sd_checkpoint_hash": OptionInfo("", "SHA256 hash of the current checkpoint"),
+            "tile_size": OptionInfo(512, "Tile Size for Tiled VAE", gr.Number, {"precision": 0}),
+            "tile_overlap": OptionInfo(64, "Overlap for Tiled VAE", gr.Number, {"precision": 0}),
         },
     )
 )

modules/shared_state.py

@@ -2,10 +2,11 @@ import datetime
 import logging
 import threading
 import time
+from typing import Optional
+
 import torch
 
-from modules import errors, shared, devices
-from typing import Optional
+from modules import devices, errors, shared
 
 log = logging.getLogger(__name__)
 
@@ -143,10 +144,7 @@ class State:
         if not shared.parallel_processing_allowed:
             return
 
-        if (
-            (shared.opts.live_previews_enable and shared.opts.show_progress_every_n_steps != -1) and
-            ((self.sampling_step - self.current_image_sampling_step) >= shared.opts.show_progress_every_n_steps)
-        ):
+        if (shared.opts.live_previews_enable and shared.opts.show_progress_every_n_steps != -1) and ((self.sampling_step - self.current_image_sampling_step) >= shared.opts.show_progress_every_n_steps):
             self.do_set_current_image()
 
     @torch.inference_mode()
@@ -154,14 +152,13 @@ class State:
         if self.current_latent is None:
             return
 
-        import modules.sd_samplers
+        if shared.opts.show_progress_grid:
+            from modules.sd_samplers import samples_to_image_grid as sample
+        else:
+            from modules.sd_samplers import sample_to_image as sample
 
         try:
-            if shared.opts.show_progress_grid:
-                self.assign_current_image(modules.sd_samplers.samples_to_image_grid(self.current_latent))
-            else:
-                self.assign_current_image(modules.sd_samplers.sample_to_image(self.current_latent))
-
+            self.assign_current_image(sample(self.current_latent))
             self.current_image_sampling_step = self.sampling_step
             self.current_latent = None
 

modules/txt2img.py

@@ -33,8 +33,10 @@ def txt2img_create_processing(
     hr_checkpoint_name: str,
     hr_sampler_name: str,
     hr_scheduler: str,
+    hr_cfg_scale: float,
+    hr_rescale_cfg: float,
     hr_prompt: str,
-    hr_negative_prompt,
+    hr_negative_prompt: str,
     override_settings_texts,
     *args,
     force_enable_hr=False,
@@ -66,6 +68,8 @@ def txt2img_create_processing(
         hr_checkpoint_name=None if hr_checkpoint_name == "Use same checkpoint" else hr_checkpoint_name,
         hr_sampler_name=None if hr_sampler_name == "Use same sampler" else hr_sampler_name,
         hr_scheduler=None if hr_scheduler == "Use same scheduler" else hr_scheduler,
+        hr_cfg_scale=hr_cfg_scale if opts.hires_fix_show_sampler else cfg_scale,
+        hr_rescale_cfg=hr_rescale_cfg if opts.hires_fix_show_sampler else None,
         hr_prompt=hr_prompt,
         hr_negative_prompt=hr_negative_prompt,
         override_settings=override_settings,

modules/ui.py

@@ -21,7 +21,7 @@ from modules.paths import script_path
 from modules.sd_hijack import model_hijack
 from modules.shared import cmd_opts, opts
 from modules.ui_common import create_refresh_button
-from modules.ui_components import FormGroup, FormHTML, FormRow, InputAccordion, ResizeHandleRow, ToolButton
+from modules.ui_components import FormGroup, FormHTML, FormRow, FormColumn, InputAccordion, ResizeHandleRow, ToolButton
 from modules.ui_gradio_extensions import reload_javascript
 
 create_setting_component = ui_settings.create_setting_component
@@ -223,21 +223,21 @@ def create_ui():
                                 height = gr.Slider(minimum=64, maximum=2048, step=64, label="Height", value=512, elem_id="txt2img_height")
 
                             with gr.Column(elem_id="txt2img_dimensions_row", scale=1, elem_classes="dimensions-tools"):
-                                res_switch_btn = ToolButton(value=switch_values_symbol, elem_id="txt2img_res_switch_btn", tooltip="Switch width/height")
+                                res_switch_btn = ToolButton(value=switch_values_symbol, elem_id="txt2img_res_switch_btn", tooltip="Swap width/height")
 
                             if opts.dimensions_and_batch_together:
                                 with gr.Column(elem_id="txt2img_column_batch"):
-                                    batch_count = gr.Slider(minimum=1, step=1, label="Batch count", value=1, elem_id="txt2img_batch_count")
-                                    batch_size = gr.Slider(minimum=1, maximum=8, step=1, label="Batch size", value=1, elem_id="txt2img_batch_size")
+                                    batch_count = gr.Slider(minimum=1, maximum=128, step=1, label="Batch Count", value=1, elem_id="txt2img_batch_count")
+                                    batch_size = gr.Slider(minimum=1, maximum=16, step=1, label="Batch Size", value=1, elem_id="txt2img_batch_size")
 
                     elif category == "cfg":
                         with gr.Row():
-                            cfg_scale = gr.Slider(minimum=1.0, maximum=30.0, step=0.5, label="CFG Scale", value=7.0, elem_id="txt2img_cfg_scale", scale=4)
+                            cfg_scale = gr.Slider(minimum=1.0, maximum=24.0, step=0.5, label="CFG Scale", value=6.0, elem_id="txt2img_cfg_scale", scale=4)
                             scripts.scripts_txt2img.setup_ui_for_section(category)
 
-                    elif category == "checkboxes":
-                        with FormRow(elem_classes="checkboxes-row", variant="compact"):
-                            pass
+                    # elif category == "checkboxes":
+                    #     with FormRow(elem_classes="checkboxes-row", variant="compact"):
+                    #         pass
 
                     elif category == "accordions":
                         with gr.Row(elem_id="txt2img_accordions", elem_classes="accordions"):
@@ -247,37 +247,41 @@ def create_ui():
 
                                 with FormRow(elem_id="txt2img_hires_fix_row1", variant="compact"):
                                     hr_upscaler = gr.Dropdown(label="Upscaler", elem_id="txt2img_hr_upscaler", choices=[*shared.latent_upscale_modes, *[x.name for x in shared.sd_upscalers]], value=shared.latent_upscale_default_mode)
-                                    hr_second_pass_steps = gr.Slider(minimum=0, maximum=150, step=1, label="Hires steps", value=0, elem_id="txt2img_hires_steps")
-                                    denoising_strength = gr.Slider(minimum=0.0, maximum=1.0, step=0.01, label="Denoising strength", value=0.7, elem_id="txt2img_denoising_strength")
+                                    hr_second_pass_steps = gr.Slider(minimum=0, maximum=128, step=1, label="Hires steps", value=0, elem_id="txt2img_hires_steps")
+                                    denoising_strength = gr.Slider(minimum=0.0, maximum=1.0, step=0.05, label="Denoising strength", value=0.6, elem_id="txt2img_denoising_strength")
 
                                 with FormRow(elem_id="txt2img_hires_fix_row2", variant="compact"):
                                     hr_scale = gr.Slider(minimum=1.0, maximum=4.0, step=0.05, label="Upscale by", value=2.0, elem_id="txt2img_hr_scale")
                                     hr_resize_x = gr.Slider(minimum=0, maximum=2048, step=64, label="Resize width to", value=0, elem_id="txt2img_hr_resize_x")
                                     hr_resize_y = gr.Slider(minimum=0, maximum=2048, step=64, label="Resize height to", value=0, elem_id="txt2img_hr_resize_y")
 
-                                with FormRow(elem_id="txt2img_hires_fix_row3", variant="compact", visible=opts.hires_fix_show_sampler) as hr_sampler_container:
+                                with FormColumn(elem_id="txt2img_hires_fix_row3", variant="compact", visible=opts.hires_fix_show_sampler) as hr_sampler_container:
 
-                                    hr_checkpoint_name = gr.Dropdown(label="Hires checkpoint", elem_id="hr_checkpoint", choices=["Use same checkpoint"] + modules.sd_models.checkpoint_tiles(use_short=True), value="Use same checkpoint")
-                                    create_refresh_button(hr_checkpoint_name, modules.sd_models.list_models, lambda: {"choices": ["Use same checkpoint"] + modules.sd_models.checkpoint_tiles(use_short=True)}, "hr_checkpoint_refresh")
+                                    with gr.Row():
+                                        hr_checkpoint_name = gr.Dropdown(label="Hires checkpoint", elem_id="hr_checkpoint", choices=["Use same checkpoint"] + modules.sd_models.checkpoint_tiles(use_short=True), value="Use same checkpoint")
+                                        create_refresh_button(hr_checkpoint_name, modules.sd_models.list_models, lambda: {"choices": ["Use same checkpoint"] + modules.sd_models.checkpoint_tiles(use_short=True)}, "hr_checkpoint_refresh")
+                                        hr_sampler_name = gr.Dropdown(label="Hires sampling method", elem_id="hr_sampler", choices=["Use same sampler"] + sd_samplers.visible_sampler_names(), value="Use same sampler")
+                                        hr_scheduler = gr.Dropdown(label="Hires schedule type", elem_id="hr_scheduler", choices=["Use same scheduler"] + [x.label for x in sd_schedulers.schedulers], value="Use same scheduler")
 
-                                    hr_sampler_name = gr.Dropdown(label="Hires sampling method", elem_id="hr_sampler", choices=["Use same sampler"] + sd_samplers.visible_sampler_names(), value="Use same sampler")
-                                    hr_scheduler = gr.Dropdown(label="Hires schedule type", elem_id="hr_scheduler", choices=["Use same scheduler"] + [x.label for x in sd_schedulers.schedulers], value="Use same scheduler")
+                                    with gr.Row():
+                                        hr_cfg_scale = gr.Slider(minimum=1.0, maximum=24.0, step=0.5, label="Hires CFG Scale", value=6.0, elem_id="hr_cfg_scale")
+                                        hr_rescale_cfg = gr.Slider(value=0.0, minimum=0.0, maximum=1.0, step=0.05, label="Hires Rescale CFG", elem_id="hr_rescale_cfg_scale", visible=opts.show_rescale_cfg)
 
                                 with FormRow(elem_id="txt2img_hires_fix_row4", variant="compact", visible=opts.hires_fix_show_prompts) as hr_prompts_container:
                                     with gr.Column(scale=80):
                                         with gr.Row():
-                                            hr_prompt = gr.Textbox(label="Hires prompt", elem_id="hires_prompt", show_label=False, lines=3, placeholder="Prompt for hires fix pass.\nLeave empty to use the same prompt as in first pass.", elem_classes=["prompt"])
+                                            hr_prompt = gr.Textbox(label="Hires prompt", elem_id="hires_prompt", show_label=False, lines=3, placeholder="Prompt for Hires. fix\n(leave empty to use the same prompt as txt2img)", elem_classes=["prompt"])
                                     with gr.Column(scale=80):
                                         with gr.Row():
-                                            hr_negative_prompt = gr.Textbox(label="Hires negative prompt", elem_id="hires_neg_prompt", show_label=False, lines=3, placeholder="Negative prompt for hires fix pass.\nLeave empty to use the same negative prompt as in first pass.", elem_classes=["prompt"])
+                                            hr_negative_prompt = gr.Textbox(label="Hires negative prompt", elem_id="hires_neg_prompt", show_label=False, lines=3, placeholder="Negative Prompt for Hires. fix\n(leave empty to use the same negative prompt as txt2img)", elem_classes=["prompt"])
 
                             scripts.scripts_txt2img.setup_ui_for_section(category)
 
                     elif category == "batch":
                         if not opts.dimensions_and_batch_together:
                             with FormRow(elem_id="txt2img_column_batch"):
-                                batch_count = gr.Slider(minimum=1, step=1, label="Batch count", value=1, elem_id="txt2img_batch_count")
-                                batch_size = gr.Slider(minimum=1, maximum=8, step=1, label="Batch size", value=1, elem_id="txt2img_batch_size")
+                                batch_count = gr.Slider(minimum=1, maximum=128, step=1, label="Batch Count", value=1, elem_id="txt2img_batch_count")
+                                batch_size = gr.Slider(minimum=1, maximum=16, step=1, label="Batch Size", value=1, elem_id="txt2img_batch_size")
 
                     elif category == "override_settings":
                         with FormRow(elem_id="txt2img_override_settings_row") as row:
@@ -331,6 +335,8 @@ def create_ui():
                 hr_checkpoint_name,
                 hr_sampler_name,
                 hr_scheduler,
+                hr_cfg_scale,
+                hr_rescale_cfg,
                 hr_prompt,
                 hr_negative_prompt,
                 override_settings,
@@ -395,6 +401,8 @@ def create_ui():
                 PasteField(hr_checkpoint_name, "Hires checkpoint", api="hr_checkpoint_name"),
                 PasteField(hr_sampler_name, sd_samplers.get_hr_sampler_from_infotext, api="hr_sampler_name"),
                 PasteField(hr_scheduler, sd_samplers.get_hr_scheduler_from_infotext, api="hr_scheduler"),
+                PasteField(hr_cfg_scale, "Hires CFG Scale", api="hr_cfg_scale"),
+                PasteField(hr_rescale_cfg, "Hires Rescale CFG", api="hr_rescale_cfg"),
                 PasteField(hr_sampler_container, lambda d: gr.update(visible=True) if d.get("Hires sampler", "Use same sampler") != "Use same sampler" or d.get("Hires checkpoint", "Use same checkpoint") != "Use same checkpoint" or d.get("Hires schedule type", "Use same scheduler") != "Use same scheduler" else gr.update()),
                 PasteField(hr_prompt, "Hires prompt", api="hr_prompt"),
                 PasteField(hr_negative_prompt, "Hires negative prompt", api="hr_negative_prompt"),
@@ -558,11 +566,11 @@ def create_ui():
                                                 width = gr.Slider(minimum=64, maximum=2048, step=64, label="Width", value=512, elem_id="img2img_width")
                                                 height = gr.Slider(minimum=64, maximum=2048, step=64, label="Height", value=512, elem_id="img2img_height")
                                             with gr.Column(elem_id="img2img_dimensions_row", scale=1, elem_classes="dimensions-tools"):
-                                                res_switch_btn = ToolButton(value=switch_values_symbol, elem_id="img2img_res_switch_btn", tooltip="Switch width/height")
+                                                res_switch_btn = ToolButton(value=switch_values_symbol, elem_id="img2img_res_switch_btn", tooltip="Swap width/height")
                                                 detect_image_size_btn = ToolButton(value=detect_image_size_symbol, elem_id="img2img_detect_image_size_btn", tooltip="Auto detect size from img2img")
 
                                     with gr.Tab(label="Resize by", elem_id="img2img_tab_resize_by") as tab_scale_by:
-                                        scale_by = gr.Slider(minimum=0.05, maximum=4.0, step=0.05, label="Scale", value=1.0, elem_id="img2img_scale")
+                                        scale_by = gr.Slider(minimum=0.5, maximum=4.0, step=0.05, label="Scale", value=1.0, elem_id="img2img_scale")
 
                                         with FormRow():
                                             scale_by_html = FormHTML(resize_from_to_html(0, 0, 0.0), elem_id="img2img_scale_resolution_preview")
@@ -585,21 +593,21 @@ def create_ui():
 
                             if opts.dimensions_and_batch_together:
                                 with gr.Column(elem_id="img2img_column_batch"):
-                                    batch_count = gr.Slider(minimum=1, step=1, label="Batch count", value=1, elem_id="img2img_batch_count")
-                                    batch_size = gr.Slider(minimum=1, maximum=8, step=1, label="Batch size", value=1, elem_id="img2img_batch_size")
+                                    batch_count = gr.Slider(minimum=1, maximum=128, step=1, label="Batch Count", value=1, elem_id="img2img_batch_count")
+                                    batch_size = gr.Slider(minimum=1, maximum=16, step=1, label="Batch Size", value=1, elem_id="img2img_batch_size")
 
                     elif category == "denoising":
                         denoising_strength = gr.Slider(minimum=0.0, maximum=1.0, step=0.01, label="Denoising strength", value=0.75, elem_id="img2img_denoising_strength")
 
                     elif category == "cfg":
                         with gr.Row():
-                            cfg_scale = gr.Slider(minimum=1.0, maximum=30.0, step=0.5, label="CFG Scale", value=7.0, elem_id="img2img_cfg_scale", scale=4)
+                            cfg_scale = gr.Slider(minimum=1.0, maximum=24.0, step=0.5, label="CFG Scale", value=6.0, elem_id="img2img_cfg_scale", scale=4)
                             scripts.scripts_img2img.setup_ui_for_section(category)
                         image_cfg_scale = gr.Slider(minimum=0, maximum=3.0, step=0.05, label="Image CFG Scale", value=1.5, elem_id="img2img_image_cfg_scale", visible=False)
 
-                    elif category == "checkboxes":
-                        with FormRow(elem_classes="checkboxes-row", variant="compact"):
-                            pass
+                    # elif category == "checkboxes":
+                    #     with FormRow(elem_classes="checkboxes-row", variant="compact"):
+                    #         pass
 
                     elif category == "accordions":
                         with gr.Row(elem_id="img2img_accordions", elem_classes="accordions"):
@@ -608,8 +616,8 @@ def create_ui():
                     elif category == "batch":
                         if not opts.dimensions_and_batch_together:
                             with FormRow(elem_id="img2img_column_batch"):
-                                batch_count = gr.Slider(minimum=1, step=1, label="Batch count", value=1, elem_id="img2img_batch_count")
-                                batch_size = gr.Slider(minimum=1, maximum=8, step=1, label="Batch size", value=1, elem_id="img2img_batch_size")
+                                batch_count = gr.Slider(minimum=1, maximum=128, step=1, label="Batch Count", value=1, elem_id="img2img_batch_count")
+                                batch_size = gr.Slider(minimum=1, maximum=16, step=1, label="Batch Size", value=1, elem_id="img2img_batch_size")
 
                     elif category == "override_settings":
                         with FormRow(elem_id="img2img_override_settings_row") as row:

modules/ui_common.py

@@ -105,7 +105,7 @@ def save_files(js_data, images, do_make_zip, index):
     logfile_path = os.path.join(shared.opts.outdir_save, "log.csv")
 
     # NOTE: ensure csv integrity when fields are added by
-    # updating headers and padding with delimeters where needed
+    # updating headers and padding with delimiters where needed
     if os.path.exists(logfile_path):
         update_logfile(logfile_path, fields)
 

modules/ui_components.py

@@ -86,9 +86,9 @@ class DropdownEditable(FormComponent, gr.Dropdown):
 
 
 class InputAccordion(gr.Checkbox):
-    """A gr.Accordion that can be used as an input - returns True if open, False if closed.
-
-    Actaully just a hidden checkbox, but creates an accordion that follows and is followed by the state of the checkbox.
+    """
+    A gr.Accordion that can be used as an input - returns True if open, False if closed.
+    Actually just a hidden checkbox, but creates an accordion that follows and is followed by the state of the checkbox.
     """
 
     global_index = 0

modules/ui_prompt_styles.py

@@ -67,7 +67,7 @@ class UiPromptStyles:
             with gr.Row():
                 self.selection = gr.Dropdown(label="Styles", elem_id=f"{tabname}_styles_edit_select", choices=list(shared.prompt_styles.styles), value=[], allow_custom_value=True, info="Styles allow you to add custom text to prompt. Use the {prompt} token in style text, and it will be replaced with user's prompt when applying style. Otherwise, style's text will be added to the end of the prompt.")
                 ui_common.create_refresh_button([self.dropdown, self.selection], shared.prompt_styles.reload, lambda: {"choices": list(shared.prompt_styles.styles)}, f"refresh_{tabname}_styles")
-                self.materialize = ui_components.ToolButton(value=styles_materialize_symbol, elem_id=f"{tabname}_style_apply_dialog", tooltip="Apply all selected styles from the style selction dropdown in main UI to the prompt.")
+                self.materialize = ui_components.ToolButton(value=styles_materialize_symbol, elem_id=f"{tabname}_style_apply_dialog", tooltip="Apply all selected styles from the style selection dropdown in main UI to the prompt.")
                 self.copy = ui_components.ToolButton(value=styles_copy_symbol, elem_id=f"{tabname}_style_copy", tooltip="Copy main UI prompt to style.")
 
             with gr.Row():

modules/ui_toprow.py

@@ -77,11 +77,11 @@ class Toprow:
     def create_prompts(self):
         with gr.Column(elem_id=f"{self.id_part}_prompt_container", elem_classes=["prompt-container-compact"] if self.is_compact else [], scale=6):
             with gr.Row(elem_id=f"{self.id_part}_prompt_row", elem_classes=["prompt-row"]):
-                self.prompt = gr.Textbox(label="Prompt", elem_id=f"{self.id_part}_prompt", show_label=False, lines=3, placeholder="Prompt\n(Press Ctrl+Enter to generate, Alt+Enter to skip, Esc to interrupt)", elem_classes=["prompt"])
+                self.prompt = gr.Textbox(label="Prompt", elem_id=f"{self.id_part}_prompt", show_label=False, lines=3, placeholder="Prompt\n(Ctrl+Enter to Generate ; Alt+Enter to Skip ; Esc to Interrupt)", elem_classes=["prompt"])
                 self.prompt_img = gr.File(label="", elem_id=f"{self.id_part}_prompt_image", file_count="single", type="binary", visible=False)
 
             with gr.Row(elem_id=f"{self.id_part}_neg_prompt_row", elem_classes=["prompt-row"]):
-                self.negative_prompt = gr.Textbox(label="Negative prompt", elem_id=f"{self.id_part}_neg_prompt", show_label=False, lines=3, placeholder="Negative prompt\n(Press Ctrl+Enter to generate, Alt+Enter to skip, Esc to interrupt)", elem_classes=["prompt"])
+                self.negative_prompt = gr.Textbox(label="Negative Prompt", elem_id=f"{self.id_part}_neg_prompt", show_label=False, lines=3, placeholder="Negative Prompt\n(Ctrl+Enter to Generate ; Alt+Enter to Skip ; Esc to Interrupt)", elem_classes=["prompt"])
 
         self.prompt_img.change(
             fn=modules.images.image_data,
@@ -94,15 +94,15 @@ class Toprow:
         with gr.Row(elem_id=f"{self.id_part}_generate_box", elem_classes=["generate-box"] + (["generate-box-compact"] if self.is_compact else []), render=not self.is_compact) as submit_box:
             self.submit_box = submit_box
 
-            self.interrupt = gr.Button("Interrupt", elem_id=f"{self.id_part}_interrupt", elem_classes="generate-box-interrupt", tooltip="End generation immediately or after completing current batch")
-            self.skip = gr.Button("Skip", elem_id=f"{self.id_part}_skip", elem_classes="generate-box-skip", tooltip="Stop generation of current batch and continues onto next batch")
-            self.interrupting = gr.Button("Interrupting...", elem_id=f"{self.id_part}_interrupting", elem_classes="generate-box-interrupting", tooltip="Interrupting generation...")
-            self.submit = gr.Button("Generate", elem_id=f"{self.id_part}_generate", variant="primary", tooltip="Right click generate forever menu")
+            self.interrupt = gr.Button("Interrupt", elem_id=f"{self.id_part}_interrupt", elem_classes="generate-box-interrupt", tooltip="End batch after current generation finishes" if shared.opts.interrupt_after_current else "End current generation immediately")
+            self.skip = gr.Button("Skip", elem_id=f"{self.id_part}_skip", elem_classes="generate-box-skip", tooltip="Stop current batch and continue onto next batch")
+            self.interrupting = gr.Button("Interrupting...", elem_id=f"{self.id_part}_interrupting", elem_classes="generate-box-interrupting", tooltip="Interrupting...")
+            self.submit = gr.Button("Generate", elem_id=f"{self.id_part}_generate", variant="primary", tooltip='Right Click to open the "Generate Forever" menu')
 
             def interrupt_function():
                 if not shared.state.stopping_generation and shared.state.job_count > 1 and shared.opts.interrupt_after_current:
                     shared.state.stop_generating()
-                    gr.Info("Generation will stop after finishing this image, click again to stop immediately.")
+                    gr.Info("Generation will stop after finishing this image, click again to stop immediately")
                 else:
                     shared.state.interrupt()
 
@@ -114,10 +114,10 @@ class Toprow:
         with gr.Row(elem_id=f"{self.id_part}_tools"):
             from modules.ui import paste_symbol, clear_prompt_symbol, restore_progress_symbol
 
-            self.paste = ToolButton(value=paste_symbol, elem_id="paste", tooltip="Read generation parameters from prompt or last generation if prompt is empty into user interface.")
-            self.clear_prompt_button = ToolButton(value=clear_prompt_symbol, elem_id=f"{self.id_part}_clear_prompt", tooltip="Clear prompt")
-            self.apply_styles = ToolButton(value=ui_prompt_styles.styles_materialize_symbol, elem_id=f"{self.id_part}_style_apply", tooltip="Apply all selected styles to prompts.")
-            self.restore_progress_button = ToolButton(value=restore_progress_symbol, elem_id=f"{self.id_part}_restore_progress", visible=False, tooltip="Restore progress")
+            self.paste = ToolButton(value=paste_symbol, elem_id="paste", tooltip="Read generation parameters from prompts, or the last generation if prompt is empty, into user interface")
+            self.clear_prompt_button = ToolButton(value=clear_prompt_symbol, elem_id=f"{self.id_part}_clear_prompt", tooltip="Clear Prompt")
+            self.apply_styles = ToolButton(value=ui_prompt_styles.styles_materialize_symbol, elem_id=f"{self.id_part}_style_apply", tooltip="Apply selected Styles to Prompts")
+            self.restore_progress_button = ToolButton(value=restore_progress_symbol, elem_id=f"{self.id_part}_restore_progress", visible=False, tooltip="Restore Progress")
 
             self.token_counter = gr.HTML(value="<span>0/75</span>", elem_id=f"{self.id_part}_token_counter", elem_classes=["token-counter"], visible=False)
             self.token_button = gr.Button(visible=False, elem_id=f"{self.id_part}_token_button")
@@ -139,12 +139,13 @@ class Toprow:
     def hook_paste_guard(self):
         assert self.negative_prompt is not None and self.paste is not None
 
-        def auto(prompt: str) -> bool:
-            return gr.update(interactive=(not bool(prompt)))
+        def guard(prompt: str) -> bool:
+            return gr.update(interactive=(not bool(prompt.strip())))
 
         self.negative_prompt.change(
-            fn=auto,
+            fn=guard,
             inputs=[self.negative_prompt],
             outputs=[self.paste],
             show_progress="hidden",
+            queue=False,
         )

modules_forge/stream.py

@@ -1,7 +1,9 @@
 # https://github.com/AUTOMATIC1111/stable-diffusion-webui/pull/14855
 
 import torch
-from ldm_patched.modules import args_parser, model_management
+
+from ldm_patched.modules import model_management
+from ldm_patched.modules.args_parser import args
 
 
 def stream_context():
@@ -58,7 +60,7 @@ current_stream = None
 mover_stream = None
 using_stream = False
 
-if args_parser.args.cuda_stream:
+if args.cuda_stream:
     current_stream = get_current_stream()
     mover_stream = get_new_stream()
     using_stream = current_stream is not None and mover_stream is not None

modules_forge/unet_patcher.py

@@ -19,13 +19,13 @@ class UnetPatcher(ModelPatcher):
             self.offload_device,
             self.size,
             self.current_device,
-            weight_inplace_update=self.weight_inplace_update,
+            self.weight_inplace_update,
         )
 
-        n.patches = {}
         for k in self.patches:
             n.patches[k] = self.patches[k][:]
 
+        n.backup = self.backup
         n.object_patches = self.object_patches.copy()
         n.model_options = copy.deepcopy(self.model_options)
         n.model_keys = self.model_keys
@@ -33,6 +33,8 @@ class UnetPatcher(ModelPatcher):
         n.extra_preserved_memory_during_sampling = self.extra_preserved_memory_during_sampling
         n.extra_model_patchers_during_sampling = self.extra_model_patchers_during_sampling.copy()
         n.extra_concat_condition = self.extra_concat_condition
+        n.patch_status = self.patch_status
+
         return n
 
     def add_extra_preserved_memory_during_sampling(self, memory_in_bytes: int):