uptade forge classic

README.md

@@ -1,5 +1,9 @@
 <h1 align="center">Stable Diffusion WebUI Forge - Classic</h1>
 
+<p align="center"><sup>
+[ Classic | <a href="https://github.com/Haoming02/sd-webui-forge-classic/tree/neo#stable-diffusion-webui-forge---neo">Neo</a> ]
+</sup></p>
+
 <p align="center"><img src="html\ui.webp" width=512 alt="UI"></p>
 
 <blockquote><i>
@@ -18,7 +22,7 @@ The name "Forge" is inspired by "Minecraft Forge". This project aims to become t
 
 <br>
 
-## Features [Jul. 23]
+## Features [Aug. 13]
 > Most base features of the original [Automatic1111 Webui](https://github.com/AUTOMATIC1111/stable-diffusion-webui) should still function
 
 #### New Features
@@ -61,6 +65,9 @@ The name "Forge" is inspired by "Minecraft Forge". This project aims to become t
 - [X] Persistent LoRA Patching
     - speed up LoRA loading in subsequent generations
     - see [Commandline](#by-classic)
+- [X] Patch LoRA in-place
+    - reduce VRAM usage when loading LoRA
+    - enable in **Settings/Extra Networks**
 - [X] Implement new Samplers
     - *(ported from reForge Webui)*
 - [X] Implement Scheduler dropdown
@@ -177,6 +184,8 @@ The name "Forge" is inspired by "Minecraft Forge". This project aims to become t
 - [X] Run `text encoder` on CPU by default
 - [X] Fix `pydantic` Errors
 - [X] Fix `Soft Inpainting`
+- [X] Fix `Controllllite`
+- [X] Fix `MultiDiffusion`
 - [X] Lint & Format
 - [X] Update `Pillow`
     - faster image processing

extensions-builtin/Lora/networks.py

@@ -1,4 +1,3 @@
-import functools
 import os.path
 import re
 
@@ -9,7 +8,6 @@ from modules import errors, scripts, sd_models, shared
 import network
 
 
-@functools.lru_cache(maxsize=4, typed=False)
 def load_lora_state_dict(filename):
     return load_torch_file(filename, safe_load=True)
 
@@ -31,8 +29,6 @@ def get_networks_on_desk(names: list[str], *, tried: bool = True) -> list["netwo
 
 
 def load_networks(names, te_multipliers=None, unet_multipliers=None, dyn_dims=None):
-    global lora_state_dict_cache
-
     current_sd = sd_models.model_data.get_sd_model()
     if current_sd is None:
         return
@@ -53,16 +49,18 @@ def load_networks(names, te_multipliers=None, unet_multipliers=None, dyn_dims=No
 
     compiled_lora_targets = []
     for a, b, c in zip(networks_on_disk, unet_multipliers, te_multipliers):
-        compiled_lora_targets.append([a.filename, b, c])
-
-    compiled_lora_targets_hash = str(compiled_lora_targets)
+        compiled_lora_targets.append((a.filename, b, c))
 
-    if current_sd.current_lora_hash == compiled_lora_targets_hash:
+    if shared.cached_lora_hash == compiled_lora_targets:
         return
 
-    current_sd.current_lora_hash = compiled_lora_targets_hash
-    current_sd.forge_objects.unet = current_sd.forge_objects_original.unet
-    current_sd.forge_objects.clip = current_sd.forge_objects_original.clip
+    shared.cached_lora_hash = compiled_lora_targets
+    current_sd.current_lora_hash = str(compiled_lora_targets)
+
+    if not bool(shared.cached_lora_hash):
+        del current_sd.forge_objects_after_applying_lora
+        current_sd.forge_objects_after_applying_lora = None
+        return
 
     for filename, strength_model, strength_clip in compiled_lora_targets:
         lora_sd = load_lora_state_dict(filename)

extensions-builtin/sd_forge_controlllite/lib_controllllite/lib_controllllite.py

@@ -1,37 +1,24 @@
+# reference: https://github.com/kohya-ss/ControlNet-LLLite-ComfyUI/blob/main/node_control_net_lllite.py
+
 import math
 import torch
 
 
 def extra_options_to_module_prefix(extra_options):
-    # extra_options = {'transformer_index': 2, 'block_index': 8, 'original_shape': [2, 4, 128, 128], 'block': ('input', 7), 'n_heads': 20, 'dim_head': 64}
-
-    # block is: [('input', 4), ('input', 5), ('input', 7), ('input', 8), ('middle', 0),
-    #   ('output', 0), ('output', 1), ('output', 2), ('output', 3), ('output', 4), ('output', 5)]
-    # transformer_index is: [0, 1, 2, 3, 4, 5, 6, 7, 8], for each block
-    # block_index is: 0-1 or 0-9, depends on the block
-    # input 7 and 8, middle has 10 blocks
-
-    # make module name from extra_options
     block = extra_options["block"]
     block_index = extra_options["block_index"]
     if block[0] == "input":
-        module_pfx = (
-            f"lllite_unet_input_blocks_{block[1]}_1_transformer_blocks_{block_index}"
-        )
+        module_pfx = f"lllite_unet_input_blocks_{block[1]}_1_transformer_blocks_{block_index}"
     elif block[0] == "middle":
         module_pfx = f"lllite_unet_middle_block_1_transformer_blocks_{block_index}"
     elif block[0] == "output":
-        module_pfx = (
-            f"lllite_unet_output_blocks_{block[1]}_1_transformer_blocks_{block_index}"
-        )
+        module_pfx = f"lllite_unet_output_blocks_{block[1]}_1_transformer_blocks_{block_index}"
     else:
         raise Exception("invalid block name")
     return module_pfx
 
 
-def load_control_net_lllite_patch(
-    ctrl_sd, cond_image, multiplier, num_steps, start_percent, end_percent
-):
+def load_control_net_lllite_patch(ctrl_sd, cond_image, multiplier, num_steps, start_percent, end_percent):
     # calculate start and end step
     start_step = math.floor(num_steps * start_percent) if start_percent > 0 else 0
     end_step = math.floor(num_steps * end_percent) if end_percent > 0 else num_steps
@@ -70,16 +57,15 @@ def load_control_net_lllite_patch(
             start_step=start_step,
             end_step=end_step,
         )
-        info = module.load_state_dict(weights)
+        module.load_state_dict(weights)
         modules[module_name] = module
         if len(modules) == 1:
             module.is_first = True
 
-    print(f"{len(modules)} modules")
+    print(f"loaded {len(modules)} modules")
 
     # cond imageをセットする
-    cond_image = cond_image.permute(0, 3, 1, 2)  # b,h,w,3 -> b,3,h,w
-    cond_image = cond_image * 2.0 - 1.0  # 0-1 -> -1-+1
+    cond_image = cond_image * 2.0 - 1.0  # 0.0 - 1.0 -> -1.0 - 1.0
 
     for module in modules.values():
         module.set_cond_image(cond_image)
@@ -110,9 +96,9 @@ def load_control_net_lllite_patch(
 
             return q, k, v
 
-        def to(self, device):
+        def to(self, device=None, dtype=None):
             for d in self.modules.keys():
-                self.modules[d] = self.modules[d].to(device)
+                self.modules[d] = self.modules[d].to(device=device, dtype=dtype)
             return self
 
     return control_net_lllite_patch(modules)
@@ -142,41 +128,19 @@ class LLLiteModule(torch.nn.Module):
         self.is_first = False
 
         modules = []
-        modules.append(
-            torch.nn.Conv2d(3, cond_emb_dim // 2, kernel_size=4, stride=4, padding=0)
-        )  # to latent (from VAE) size*2
+        modules.append(torch.nn.Conv2d(3, cond_emb_dim // 2, kernel_size=4, stride=4, padding=0))  # to latent (from VAE) size*2
         if depth == 1:
             modules.append(torch.nn.ReLU(inplace=True))
-            modules.append(
-                torch.nn.Conv2d(
-                    cond_emb_dim // 2, cond_emb_dim, kernel_size=2, stride=2, padding=0
-                )
-            )
+            modules.append(torch.nn.Conv2d(cond_emb_dim // 2, cond_emb_dim, kernel_size=2, stride=2, padding=0))
         elif depth == 2:
             modules.append(torch.nn.ReLU(inplace=True))
-            modules.append(
-                torch.nn.Conv2d(
-                    cond_emb_dim // 2, cond_emb_dim, kernel_size=4, stride=4, padding=0
-                )
-            )
+            modules.append(torch.nn.Conv2d(cond_emb_dim // 2, cond_emb_dim, kernel_size=4, stride=4, padding=0))
         elif depth == 3:
             # kernel size 8は大きすぎるので、4にする / kernel size 8 is too large, so set it to 4
             modules.append(torch.nn.ReLU(inplace=True))
-            modules.append(
-                torch.nn.Conv2d(
-                    cond_emb_dim // 2,
-                    cond_emb_dim // 2,
-                    kernel_size=4,
-                    stride=4,
-                    padding=0,
-                )
-            )
+            modules.append(torch.nn.Conv2d(cond_emb_dim // 2, cond_emb_dim // 2, kernel_size=4, stride=4, padding=0))
             modules.append(torch.nn.ReLU(inplace=True))
-            modules.append(
-                torch.nn.Conv2d(
-                    cond_emb_dim // 2, cond_emb_dim, kernel_size=2, stride=2, padding=0
-                )
-            )
+            modules.append(torch.nn.Conv2d(cond_emb_dim // 2, cond_emb_dim, kernel_size=2, stride=2, padding=0))
 
         self.conditioning1 = torch.nn.Sequential(*modules)
 
@@ -186,9 +150,7 @@ class LLLiteModule(torch.nn.Module):
                 torch.nn.ReLU(inplace=True),
             )
             self.mid = torch.nn.Sequential(
-                torch.nn.Conv2d(
-                    mlp_dim + cond_emb_dim, mlp_dim, kernel_size=1, stride=1, padding=0
-                ),
+                torch.nn.Conv2d(mlp_dim + cond_emb_dim, mlp_dim, kernel_size=1, stride=1, padding=0),
                 torch.nn.ReLU(inplace=True),
             )
             self.up = torch.nn.Sequential(
@@ -265,47 +227,13 @@ class LLLiteModule(torch.nn.Module):
 
 
 class LLLiteLoader:
-    def __init__(self):
-        pass
-
-    @classmethod
-    def INPUT_TYPES(s):
-        return {
-            "required": {
-                "model": ("MODEL",),
-                "model_name": None,
-                "cond_image": ("IMAGE",),
-                "strength": (
-                    "FLOAT",
-                    {"default": 1.0, "min": 0.0, "max": 10.0, "step": 0.01},
-                ),
-                "steps": ("INT", {"default": 0, "min": 0, "max": 200, "step": 1}),
-                "start_percent": (
-                    "FLOAT",
-                    {"default": 0.0, "min": 0.0, "max": 100.0, "step": 0.1},
-                ),
-                "end_percent": (
-                    "FLOAT",
-                    {"default": 0.0, "min": 0.0, "max": 100.0, "step": 0.1},
-                ),
-            }
-        }
-
-    RETURN_TYPES = ("MODEL",)
-    FUNCTION = "load_lllite"
-    CATEGORY = "loaders"
-
-    def load_lllite(
-        self, model, state_dict, cond_image, strength, steps, start_percent, end_percent
-    ):
-        # cond_image is b,h,w,3, 0-1
 
+    @staticmethod
+    def load_lllite(model, state_dict, cond_image, strength, steps, start_percent, end_percent):
         model_lllite = model.clone()
-        patch = load_control_net_lllite_patch(
-            state_dict, cond_image, strength, steps, start_percent, end_percent
-        )
+        patch = load_control_net_lllite_patch(state_dict, cond_image, strength, steps, start_percent, end_percent)
         if patch is not None:
             model_lllite.set_model_attn1_patch(patch)
             model_lllite.set_model_attn2_patch(patch)
 
-        return (model_lllite,)
+        return model_lllite

extensions-builtin/sd_forge_controlllite/scripts/forge_controllllite.py

@@ -3,36 +3,31 @@ from modules_forge.supported_controlnet import ControlModelPatcher
 from lib_controllllite.lib_controllllite import LLLiteLoader
 
 
-opLLLiteLoader = LLLiteLoader().load_lllite
-
-
 class ControlLLLitePatcher(ControlModelPatcher):
+    def __init__(self, state_dict):
+        super().__init__()
+        self.state_dict = state_dict
+
     @staticmethod
     def try_build_from_state_dict(state_dict, ckpt_path):
         if not any("lllite" in k for k in state_dict.keys()):
             return None
         return ControlLLLitePatcher(state_dict)
 
-    def __init__(self, state_dict):
-        super().__init__()
-        self.state_dict = state_dict
-        return
-
-    def process_before_every_sampling(self, process, cond, mask, *args, **kwargs):
+    def process_before_every_sampling(self, process, cond, *args, **kwargs):
         unet = process.sd_model.forge_objects.unet
 
-        unet = opLLLiteLoader(
+        unet = LLLiteLoader.load_lllite(
             model=unet,
             state_dict=self.state_dict,
-            cond_image=cond.movedim(1, -1),
+            cond_image=cond,
             strength=self.strength,
             steps=process.steps,
             start_percent=self.start_percent,
             end_percent=self.end_percent,
-        )[0]
+        )
 
         process.sd_model.forge_objects.unet = unet
-        return
 
 
 add_supported_control_model(ControlLLLitePatcher)

extensions-builtin/sd_forge_controlnet/lib_controlnet/utils.py

@@ -42,62 +42,6 @@ def get_state_dict(d):
     return d.get("state_dict", d)
 
 
-def ndarray_lru_cache(max_size: int = 128, typed: bool = False):
-    """
-    Decorator to enable caching for functions with numpy array arguments.
-    Numpy arrays are mutable, and thus not directly usable as hash keys.
-
-    The idea here is to wrap the incoming arguments with type `np.ndarray`
-    as `HashableNpArray` so that `lru_cache` can correctly handles `np.ndarray`
-    arguments.
-
-    `HashableNpArray` functions exactly the same way as `np.ndarray` except
-    having `__hash__` and `__eq__` overridden.
-    """
-
-    def decorator(func: Callable):
-        """The actual decorator that accept function as input"""
-
-        class HashableNpArray(np.ndarray):
-            def __new__(cls, input_array):
-                # Input array is an instance of ndarray
-                # The view makes the input array and returned array share the same data
-                obj = np.asarray(input_array).view(cls)
-                return obj
-
-            def __eq__(self, other) -> bool:
-                return np.array_equal(self, other)
-
-            def __hash__(self):
-                # Hash the bytes representing the data of the array
-                return hash(self.tobytes())
-
-        @functools.lru_cache(maxsize=max_size, typed=typed)
-        def cached_func(*args, **kwargs):
-            """This function only accepts `HashableNpArray` as input params"""
-            return func(*args, **kwargs)
-
-        # Preserves original function.__name__ and __doc__
-        @functools.wraps(func)
-        def decorated_func(*args, **kwargs):
-            """The decorated function that delegates the original function"""
-
-            def convert_item(item):
-                if isinstance(item, np.ndarray):
-                    return HashableNpArray(item)
-                if isinstance(item, tuple):
-                    return tuple(convert_item(i) for i in item)
-                return item
-
-            args = [convert_item(arg) for arg in args]
-            kwargs = {k: convert_item(arg) for k, arg in kwargs.items()}
-            return cached_func(*args, **kwargs)
-
-        return decorated_func
-
-    return decorator
-
-
 def timer_decorator(func):
     """Time the decorated function and output the result to debug logger"""
     if logger.level != logging.DEBUG:
@@ -129,7 +73,7 @@ class TimeMeta(type):
         return super().__new__(cls, name, bases, attrs)
 
 
-@functools.lru_cache(1, False)
+@functools.lru_cache(maxsize=1, typed=False)
 def _blank_mask() -> str:
     with io.BytesIO() as buffer:
         black = Image.new("RGB", (4, 4))
@@ -143,9 +87,7 @@ def svg_preprocess(inputs: dict, preprocess: Callable):
         return None
 
     if svgSupport and inputs["image"].startswith("data:image/svg+xml;base64,"):
-        svg_data = base64.b64decode(
-            inputs["image"].replace("data:image/svg+xml;base64,", "")
-        )
+        svg_data = base64.b64decode(inputs["image"].replace("data:image/svg+xml;base64,", ""))
         drawing = svg2rlg(io.BytesIO(svg_data))
         png_data = renderPM.drawToString(drawing, fmt="PNG")
         encoded_string = base64.b64encode(png_data)
@@ -178,9 +120,7 @@ def align_dim_latent(x: int) -> int:
     return (x // 8) * 8
 
 
-def prepare_mask(
-    mask: Image.Image, p: processing.StableDiffusionProcessing
-) -> Image.Image:
+def prepare_mask(mask: Image.Image, p: processing.StableDiffusionProcessing) -> Image.Image:
     """
     Prepare an image mask for the inpainting process.
 
@@ -333,31 +273,21 @@ def crop_and_resize_image(detected_map, resize_mode, h, w, fill_border_with_255=
             ],
             axis=0,
         )
-        high_quality_border_color = np.median(borders, axis=0).astype(
-            detected_map.dtype
-        )
+        high_quality_border_color = np.median(borders, axis=0).astype(detected_map.dtype)
         if fill_border_with_255:
             high_quality_border_color = np.zeros_like(high_quality_border_color) + 255
-        high_quality_background = np.tile(
-            high_quality_border_color[None, None], [h, w, 1]
-        )
-        detected_map = high_quality_resize(
-            detected_map, (safeint(old_w * k), safeint(old_h * k))
-        )
+        high_quality_background = np.tile(high_quality_border_color[None, None], [h, w, 1])
+        detected_map = high_quality_resize(detected_map, (safeint(old_w * k), safeint(old_h * k)))
         new_h, new_w, _ = detected_map.shape
         pad_h = max(0, (h - new_h) // 2)
         pad_w = max(0, (w - new_w) // 2)
-        high_quality_background[pad_h : pad_h + new_h, pad_w : pad_w + new_w] = (
-            detected_map
-        )
+        high_quality_background[pad_h : pad_h + new_h, pad_w : pad_w + new_w] = detected_map
         detected_map = high_quality_background
         detected_map = safe_numpy(detected_map)
         return detected_map
     else:
         k = max(k0, k1)
-        detected_map = high_quality_resize(
-            detected_map, (safeint(old_w * k), safeint(old_h * k))
-        )
+        detected_map = high_quality_resize(detected_map, (safeint(old_w * k), safeint(old_h * k)))
         new_h, new_w, _ = detected_map.shape
         pad_h = max(0, (new_h - h) // 2)
         pad_w = max(0, (new_w - w) // 2)

extensions-builtin/sd_forge_controlnet/scripts/controlnet.py

@@ -27,7 +27,7 @@ from modules_forge.supported_controlnet import ControlModelPatcher
 global_state.update_controlnet_filenames()
 
 
-@functools.lru_cache(maxsize=shared.opts.data.get("control_net_model_cache_size", 5))
+@functools.lru_cache(maxsize=getattr(shared.opts, "control_net_model_cache_size", 1))
 def cached_controlnet_loader(filename):
     return try_load_supported_control_model(filename)
 
@@ -534,7 +534,7 @@ def on_ui_settings():
             3,
             "Number of Models to Cache in Memory",
             gr.Slider,
-            {"minimum": 1, "maximum": 10, "step": 1},
+            {"minimum": 0, "maximum": 10, "step": 1},
             section=section,
             category_id=category_id,
         ).needs_reload_ui(),

extensions-builtin/sd_forge_multidiffusion/lib_multidiffusion/tiled_diffusion.py

@@ -13,6 +13,7 @@ from numpy import exp, pi, sqrt
 from torch import Tensor
 
 from ldm_patched.modules.controlnet import ControlNet, T2IAdapter
+from ldm_patched.modules.latent_formats import SD15, SDXL
 from ldm_patched.modules.model_base import BaseModel
 from ldm_patched.modules.model_management import current_loaded_models, get_torch_device, load_models_gpu
 from ldm_patched.modules.model_patcher import ModelPatcher
@@ -251,7 +252,9 @@ class AbstractDiffusion:
                 self.control_tensor_batch[param_id][batch_id] = control_tile
 
     def process_controlnet(self, x_noisy, c_in: dict, cond_or_uncond: list, bboxes, batch_size: int, batch_id: int, shifts=None, shift_condition=None):
-        control: ControlNet = c_in["control"]
+        from modules.shared import sd_model
+
+        control: ControlNet = c_in["control_model"]
         param_id = -1
         tuple_key = tuple(cond_or_uncond) + tuple(x_noisy.shape)
         while control is not None:
@@ -271,11 +274,7 @@ class AbstractDiffusion:
                     del control.cond_hint
                 control.cond_hint = None
                 compression_ratio = control.compression_ratio
-                if control.vae is not None:
-                    compression_ratio *= control.vae.downscale_ratio
-                else:
-                    if control.latent_format is not None:
-                        raise ValueError("This Controlnet needs a VAE but none was provided, please use a ControlNetApply node with a VAE input and connect it.")
+                control.latent_format = SDXL() if sd_model.is_sdxl else SD15()
                 PH, PW = self.h * compression_ratio, self.w * compression_ratio
 
                 device = getattr(control, "device", x_noisy.device)
@@ -405,9 +404,9 @@ class MultiDiffusion(AbstractDiffusion):
                         v = repeat_to_batch_size(v, x_tile.shape[0])
                 c_tile[k] = v
 
-            if "control" in c_in:
+            if "control_model" in c_in:
                 self.process_controlnet(x_tile, c_in, cond_or_uncond, bboxes, N, batch_id)
-                c_tile["control"] = c_in["control"].get_control_orig(x_tile, t_tile, c_tile, len(cond_or_uncond))
+                c_tile["control"] = c_in["control_model"].get_control(x_tile, t_tile, c_tile, len(cond_or_uncond))
 
             x_tile_out = model_function(x_tile, t_tile, **c_tile)
 
@@ -496,9 +495,9 @@ class MixtureOfDiffusers(AbstractDiffusion):
                         v = repeat_to_batch_size(v, x_tile.shape[0])
                 c_tile[k] = v
 
-            if "control" in c_in:
+            if "control_model" in c_in:
                 self.process_controlnet(x_tile, c_in, cond_or_uncond, bboxes, N, batch_id)
-                c_tile["control"] = c_in["control"].get_control_orig(x_tile, t_tile, c_tile, len(cond_or_uncond))
+                c_tile["control"] = c_in["control_model"].get_control(x_tile, t_tile, c_tile, len(cond_or_uncond))
 
             x_tile_out = model_function(x_tile, t_tile, **c_tile)
 

javascript/hints.js

@@ -1,185 +1,69 @@
 // mouseover tooltips for various UI elements
 
-var titles = {
-    "Sampling steps": "How many times to improve the generated image iteratively; higher values take longer; very low values can produce bad results",
-    "Sampling method": "Which algorithm to use to produce the image",
-    "GFPGAN": "Restore low quality faces using GFPGAN neural network",
-    "Euler a": "Euler Ancestral - very creative, each can get a completely different picture depending on step count, setting steps higher than 30-40 does not help",
-    "DDIM": "Denoising Diffusion Implicit Models - best at inpainting",
-    "UniPC": "Unified Predictor-Corrector Framework for Fast Sampling of Diffusion Models",
-    "DPM adaptive": "Ignores step count - uses a number of steps determined by the CFG and resolution",
-
-    "\u{1F4D0}": "Auto detect size from img2img",
-    "Batch count": "How many batches of images to create (has no impact on generation performance or VRAM usage)",
-    "Batch size": "How many image to create in a single batch (increases generation performance at cost of higher VRAM usage)",
-    "CFG Scale": "Classifier Free Guidance Scale - how strongly the image should conform to prompt - lower values produce more creative results",
-    "Rescale CFG": "Reduce the high-contrast burnt color caused by high CFG; mainly for v-pred checkpoints",
-    "Seed": "A value that determines the output of random number generator - if you create an image with same parameters and seed as another image, you'll get the same result",
-    "\u{1f3b2}\ufe0f": "Set seed to -1, which will cause a new random number to be used every time",
-    "\u267b\ufe0f": "Reuse seed from last generation, mostly useful if it was randomized",
-    "\u2199\ufe0f": "Read generation parameters from prompt or last generation if prompt is empty into user interface.",
-    "\u{1f4c2}": "Open images output directory",
-    "\u{1f4be}": "Save style",
-    "\u{1f5d1}\ufe0f": "Clear prompt",
-    "\u{1f4cb}": "Apply selected styles to current prompt",
-    "\u{1f4d2}": "Paste available values into the field",
-    "\u{1f3b4}": "Show/hide extra networks",
-    "\u{1f300}": "Restore progress",
-
-    "Inpaint a part of image": "Draw a mask over an image, and the script will regenerate the masked area with content according to prompt",
-    "SD upscale": "Upscale image normally, split result into tiles, improve each tile using img2img, merge whole image back",
-
-    "Just resize": "Resize image to target resolution. Unless height and width match, you will get incorrect aspect ratio.",
-    "Crop and resize": "Resize the image so that entirety of target resolution is filled with the image. Crop parts that stick out.",
-    "Resize and fill": "Resize the image so that entirety of image is inside target resolution. Fill empty space with image's colors.",
-
-    "Mask blur": "How much to blur the mask before processing, in pixels.",
-    "Masked content": "What to put inside the masked area before processing it with Stable Diffusion.",
-    "fill": "fill it with colors of the image",
-    "original": "keep whatever was there originally",
-    "latent noise": "fill it with latent space noise",
-    "latent nothing": "fill it with latent space zeroes",
-    "Inpaint at full resolution": "Upscale masked region to target resolution, do inpainting, downscale back and paste into original image",
-
-    "Denoising strength": "Determines how little respect the algorithm should have for image's content. At 0, nothing will change, and at 1 you'll get an unrelated image. With values below 1.0, processing will take less steps than the Sampling Steps slider specifies.",
-
-    "Skip": "Stop processing current image and continue processing.",
-    "Interrupt": "Stop processing images and return any results accumulated so far.",
-    "Save": "Write image to a directory (default - log/images) and generation parameters into csv file.",
-
-    "X values": "Separate values for X axis using commas.",
-    "Y values": "Separate values for Y axis using commas.",
-
-    "None": "Do not do anything special",
-    "Prompt matrix": "Separate prompts into parts using vertical pipe character (|) and the script will create a picture for every combination of them (except for the first part, which will be present in all combinations)",
-    "X/Y/Z plot": "Create grid(s) where images will have different parameters. Use inputs below to specify which parameters will be shared by columns and rows",
-
-    "Prompt S/R": "Separate a list of words with commas, and the first word will be used as a keyword: script will search for this word in the prompt, and replace it with others",
-    "Prompt order": "Separate a list of words with commas, and the script will make a variation of prompt with those words for their every possible order",
-
-    "Tiling": "Produce an image that can be tiled.",
-    "Tile overlap": "For SD upscale, how much overlap in pixels should there be between tiles. Tiles overlap so that when they are merged back into one picture, there is no clearly visible seam.",
-
-    "Variation seed": "Seed of a different picture to be mixed into the generation.",
-    "Variation strength": "How strong of a variation to produce. At 0, there will be no effect. At 1, you will get the complete picture with variation seed (except for ancestral samplers, where you will just get something).",
-    "Resize seed from height": "Make an attempt to produce a picture similar to what would have been produced with same seed at specified resolution",
-    "Resize seed from width": "Make an attempt to produce a picture similar to what would have been produced with same seed at specified resolution",
-
-    "Images filename pattern": "Use tags like [seed] and [date] to define how filenames for images are chosen. Leave empty for default.",
-    "Directory name pattern": "Use tags like [seed] and [date] to define how subdirectories for images and grids are chosen. Leave empty for default.",
-    "Max prompt words": "Set the maximum number of words to be used in the [prompt_words] option; ATTENTION: If the words are too long, they may exceed the maximum length of the file path that the system can handle",
-
-    "Loopback": "Performs img2img processing multiple times. Output images are used as input for the next loop.",
-    "Loops": "How many times to process an image. Each output is used as the input of the next loop. If set to 1, behavior will be as if this script were not used.",
-    "Final denoising strength": "The denoising strength for the final loop of each image in the batch.",
-    "Denoising strength curve": "The denoising curve controls the rate of denoising strength change each loop. Aggressive: Most of the change will happen towards the start of the loops. Linear: Change will be constant through all loops. Lazy: Most of the change will happen towards the end of the loops.",
-
-    "Style 1": "Style to apply; styles have components for both positive and negative prompts and apply to both",
-    "Style 2": "Style to apply; styles have components for both positive and negative prompts and apply to both",
-    "Apply style": "Insert selected styles into prompt fields",
-    "Create style": "Save current prompts as a style. If you add the token {prompt} to the text, the style uses that as a placeholder for your prompt when you use the style in the future.",
-
-    "Checkpoint name": "Loads weights from checkpoint before making images. You can either use hash or a part of filename (as seen in settings) for checkpoint name. Recommended to use with Y axis for less switching.",
-    "Inpainting conditioning mask strength": "Only applies to inpainting models. Determines how strongly to mask off the original image for inpainting and img2img. 1.0 means fully masked, which is the default behaviour. 0.0 means a fully unmasked conditioning. Lower values will help preserve the overall composition of the image, but will struggle with large changes.",
-
-    "Eta noise seed delta": "If this values is non-zero, it will be added to seed and used to initialize RNG for noises when using samplers with Eta. You can use this to produce even more variation of images, or you can use this to match images of other software if you know what you are doing.",
-
-    "Filename word regex": "This regular expression will be used extract words from filename, and they will be joined using the option below into label text used for training. Leave empty to keep filename text as it is.",
-    "Filename join string": "This string will be used to join split words into a single line if the option above is enabled.",
-
-    "Quicksettings list": "List of setting names, separated by commas, for settings that should go to the quick access bar at the top, rather than the usual setting tab. See modules/shared.py for setting names. Requires restarting to apply.",
-
-    "Weighted sum": "Result = A * (1 - M) + B * M",
-    "Add difference": "Result = A + (B - C) * M",
-    "No interpolation": "Result = A",
-
-    "Initialization text": "If the number of tokens is more than the number of vectors, some may be skipped.\nLeave the textbox empty to start with zeroed out vectors",
-    "Learning rate": "How fast should training go. Low values will take longer to train, high values may fail to converge (not generate accurate results) and/or may break the embedding (This has happened if you see Loss: nan in the training info textbox. If this happens, you need to manually restore your embedding from an older not-broken backup).\n\nYou can set a single numeric value, or multiple learning rates using the syntax:\n\n   rate_1:max_steps_1, rate_2:max_steps_2, ...\n\nEG:   0.005:100, 1e-3:1000, 1e-5\n\nWill train with rate of 0.005 for first 100 steps, then 1e-3 until 1000 steps, then 1e-5 for all remaining steps.",
-
-    "Clip skip": "Early stopping parameter for CLIP model; 1 is stop at last layer as usual, 2 is stop at penultimate layer, etc.",
-
-    "Approx NN": "Cheap neural network approximation. Very fast compared to VAE, but produces pictures with 4 times smaller horizontal/vertical resolution and lower quality.",
-    "Approx cheap": "Very cheap approximation. Very fast compared to VAE, but produces pictures with 8 times smaller horizontal/vertical resolution and extremely low quality.",
-
-    "Hires. fix": "Use a two step process to partially create an image at smaller resolution, upscale, and then improve details in it without changing composition",
-    "Hires steps": "Number of sampling steps for upscaled picture. If 0, uses same as for original.",
-    "Upscale by": "Adjusts the size of the image by multiplying the original width and height by the selected value. Ignored if either Resize width to or Resize height to are non-zero.",
-    "Resize width to": "Resizes image to this width. If 0, width is inferred from either of two nearby sliders.",
-    "Resize height to": "Resizes image to this height. If 0, height is inferred from either of two nearby sliders.",
-    "Discard weights with matching name": "Regular expression; if weights's name matches it, the weights is not written to the resulting checkpoint. Use ^model_ema to discard EMA weights.",
-    "Extra networks tab order": "Comma-separated list of tab names; tabs listed here will appear in the extra networks UI first and in order listed.",
-    "Negative Guidance minimum sigma": "Skip negative prompt for steps where image is already mostly denoised; the higher this value, the more skips there will be; provides increased performance in exchange for minor quality reduction."
+const titles = {
+    "Sampling Method": "The algorithm used to refine each step of the image",
+    "Schedule Type": "The algorithm used to adjust the magnitude of refinement",
+    "Sampling Steps": "The number of times the image is iteratively refined",
+
+    "Batch Count": "How many batches of images to generate (in sequence)",
+    "Batch Size": "How many images to generate in a single batch (in parallel)",
+
+    "CFG Scale": "The strength used to calculate conditionings",
+    "Rescale CFG": "Reduce the high-contrast burnt-color effects (mainly for v-pred checkpoints)",
+    "MaHiRo": "An alternative algorithm used for CFG calculation",
+
+    "Seed": 'Given the same prompts and parameters, you "should" generate the same image if the Seed is also the same',
+
+    "Just resize": "Resize input image directly to target resolution",
+    "Crop and resize": "Resize the image while maintaining the aspect ratio; crop the excessive parts",
+    "Resize and fill": "Resize the image while maintaining the aspect ratio; fill the empty parts with neighboring colors",
+
+    "Mask blur": "How much feathering to apply to the mask (in pixels)",
+    "fill": "Fill the masked areas with neighboring colors",
+    "original": "Keep whatever was within the masked areas",
+    "latent noise": "Fill the masked areas with noise (requires high Denoising strength)",
+    "latent nothing": "Fill the masked areas with zero values (requires high Denoising strength)",
+
+    "Denoising strength": "How strong should the image be changed",
+
+    "Hires. fix": "Automatically perform an additional pass of img2img",
+    "Hires steps": "Sampling Steps for the img2img pass; use original if 0",
+    "Upscale by": "Multiply the txt2img dimension by this ratio, to serve as the target dimension",
+    "Resize width to": 'Resize image to this width; use "Upscale by" if 0',
+    "Resize height to": 'Resize image to this height; use "Upscale by" if 0',
 };
 
 function updateTooltip(element) {
-    if (element.title) return; // already has a title
+    if (element.title) return;
 
-    let text = element.textContent;
+    const text = element.textContent || element.value;
     let tooltip = localization[titles[text]] || titles[text];
 
-    if (!tooltip) {
-        let value = element.value;
-        if (value) tooltip = localization[titles[value]] || titles[value];
-    }
-
-    if (!tooltip) {
-        // Gradio dropdown options have `data-value`.
-        let dataValue = element.dataset.value;
-        if (dataValue) tooltip = localization[titles[dataValue]] || titles[dataValue];
-    }
+    if (!tooltip) return;
+    element.title = tooltip;
 
-    if (!tooltip) {
-        for (const c of element.classList) {
-            if (c in titles) {
-                tooltip = localization[titles[c]] || titles[c];
-                break;
-            }
-        }
-    }
-
-    if (tooltip) {
-        element.title = tooltip;
-    }
+    const field = element.parentNode.querySelector("input");
+    if (field != null) field.title = tooltip;
 }
 
-// Nodes to check for adding tooltips.
 const tooltipCheckNodes = new Set();
-// Timer for debouncing tooltip check.
 let tooltipCheckTimer = null;
 
 function processTooltipCheckNodes() {
-    for (const node of tooltipCheckNodes) {
+    for (const node of tooltipCheckNodes)
         updateTooltip(node);
-    }
     tooltipCheckNodes.clear();
 }
 
 onUiUpdate(function (mutationRecords) {
     for (const record of mutationRecords) {
-        if (record.type === "childList" && record.target.classList.contains("options")) {
-            // This smells like a Gradio dropdown menu having changed,
-            // so let's enqueue an update for the input element that shows the current value.
-            let wrap = record.target.parentNode;
-            let input = wrap?.querySelector("input");
-            if (input) {
-                input.title = ""; // So we'll even have a chance to update it.
-                tooltipCheckNodes.add(input);
-            }
-        }
         for (const node of record.addedNodes) {
             if (node.nodeType === Node.ELEMENT_NODE && !node.classList.contains("hide")) {
                 if (!node.title) {
-                    if (
-                        node.tagName === "SPAN" ||
-                        node.tagName === "BUTTON" ||
-                        node.tagName === "P" ||
-                        node.tagName === "INPUT" ||
-                        (node.tagName === "LI" && node.classList.contains("item")) // Gradio dropdown item
-                    ) {
+                    if (["SPAN", "BUTTON", "P"].includes(node.tagName))
                         tooltipCheckNodes.add(node);
-                    }
                 }
-                node.querySelectorAll('span, button, p').forEach(n => tooltipCheckNodes.add(n));
+                node.querySelectorAll('span, button, p').forEach((n) => tooltipCheckNodes.add(n));
             }
         }
     }
@@ -189,13 +73,11 @@ onUiUpdate(function (mutationRecords) {
     }
 });
 
-onUiLoaded(function () {
+onUiLoaded(() => {
     for (const comp of window.gradio_config.components) {
         if (comp.props.webui_tooltip && comp.props.elem_id) {
             const elem = gradioApp().getElementById(comp.props.elem_id);
-            if (elem) {
-                elem.title = comp.props.webui_tooltip;
-            }
+            if (elem) elem.title = comp.props.webui_tooltip;
         }
     }
 });

ldm_patched/ldm/modules/attention.py

@@ -243,27 +243,25 @@ def attention_sage(q, k, v, heads, mask=None):
     return out.reshape(b, -1, heads * dim_head)
 
 
-def attention_flash(q, k, v, heads, mask=None, attn_precision=None, skip_reshape=False, skip_output_reshape=False):
+def attention_flash(q, k, v, heads, mask=None):
     """
-    Reference: https://github.com/comfyanonymous/ComfyUI/blob/v0.3.30/comfy/ldm/modules/attention.py#L535
-    Edited by. Haoming02
+    Reference: https://github.com/comfyanonymous/ComfyUI/blob/v0.3.49/comfy/ldm/modules/attention.py#L538
+    Simplified by. Haoming02
     """
 
-    if skip_reshape:
-        b, _, _, dim_head = q.shape
-    else:
-        b, _, dim_head = q.shape
-        dim_head //= heads
-        q, k, v = map(
-            lambda t: t.view(b, -1, heads, dim_head).transpose(1, 2),
-            (q, k, v),
-        )
+    b, _, dim_head = q.shape
+    dim_head //= heads
 
-    if mask is not None:
-        if mask.ndim == 2:
-            mask = mask.unsqueeze(0)
-        if mask.ndim == 3:
-            mask = mask.unsqueeze(1)
+    if dim_head not in (64, 96, 128):
+        if model_management.xformers_enabled():
+            return attention_xformers(q, k, v, heads, mask)
+        else:
+            return attention_pytorch(q, k, v, heads, mask)
+
+    q, k, v = map(
+        lambda t: t.view(b, -1, heads, dim_head).transpose(1, 2),
+        (q, k, v),
+    )
 
     try:
         assert mask is None
@@ -278,9 +276,7 @@ def attention_flash(q, k, v, heads, mask=None, attn_precision=None, skip_reshape
         print(f"Error using FlashAttention, fallback to PyTorch sdp attention...\n{e}")
         out = torch.nn.functional.scaled_dot_product_attention(q, k, v, attn_mask=mask, dropout_p=0.0, is_causal=False)
 
-    if not skip_output_reshape:
-        out = out.transpose(1, 2).reshape(b, -1, heads * dim_head)
-    return out
+    return out.transpose(1, 2).reshape(b, -1, heads * dim_head)
 
 
 if model_management.sage_enabled():

ldm_patched/ldm/modules/diffusionmodules/model.py

@@ -223,6 +223,16 @@ def normal_attention(q, k, v):
     return h_
 
 
+def get_xformers_flash_attention_op(q, k, v):
+    try:
+        flash_attention_op = xformers.ops.MemoryEfficientAttentionFlashAttentionOp
+        fw, bw = flash_attention_op
+        if fw.supports(xformers.ops.fmha.Inputs(query=q, key=k, value=v, attn_bias=None)):
+            return flash_attention_op
+    except Exception:
+        return None
+
+
 def xformers_attention(q, k, v):
     # compute attention
     B, C, H, W = q.shape
@@ -232,7 +242,7 @@ def xformers_attention(q, k, v):
     )
 
     try:
-        out = xformers.ops.memory_efficient_attention(q, k, v, attn_bias=None)
+        out = xformers.ops.memory_efficient_attention(q, k, v, attn_bias=None, op=get_xformers_flash_attention_op(q, k, v))
         out = out.transpose(1, 2).reshape(B, C, H, W)
     except NotImplementedError:
         out = slice_attention(

ldm_patched/modules/controlnet.py

@@ -135,8 +135,12 @@ class ControlBase:
         self.cond_hint = None
         self.strength = 1.0
         self.timestep_percent_range = (0.0, 1.0)
+        self.latent_format = None
+        self.vae = None
         self.global_average_pooling = False
         self.timestep_range = None
+        self.compression_ratio = 8
+        self.upscale_algorithm = 'nearest-exact'
         self.transformer_options = {}
 
         if device is None:

ldm_patched/modules/model_patcher.py

@@ -9,6 +9,7 @@ https://github.com/comfyanonymous/ComfyUI
 import copy
 import inspect
 import logging
+import time
 
 import torch
 
@@ -28,39 +29,37 @@ if 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
+        self.t_apply: float = 0
+        """the last `time` a Patch was actually **applied**"""
+        self.t_added: float = 0
+        """the last `time` a new Patch was **added**"""
+        self.l_cache: list[tuple[str, float, float]] = None
+        """the Patches that are **currently** applied"""
 
     def require_patch(self) -> bool:
-        if not PERSISTENT_PATCHES:
-            return True
-
-        return self.current == 0
+        """whether a new Patch was added after the last application"""
+        return self.t_apply < self.t_added
 
     def require_unpatch(self) -> bool:
-        if not PERSISTENT_PATCHES:
-            return True
-
-        if not PatchStatus.has_lora():
-            return True
+        """whether the current Patches do not match the target Patches"""
+        from modules.shared import cached_lora_hash
 
-        return self.current != self.updated
+        return self.l_cache != cached_lora_hash
 
     def patch(self):
-        if self.updated > 0:
-            self.current = self.updated
+        """update the time when Patches are applied"""
+        self.t_apply = time.time()
+        self.sync()
 
-    def unpatch(self):
-        self.current = 0
+    def sync(self):
+        """update the current Patches to match the system Patches"""
+        from modules.shared import cached_lora_hash
 
-    def update(self):
-        self.updated += 1
+        self.l_cache = cached_lora_hash
 
-    @staticmethod
-    def has_lora() -> bool:
-        from modules.shared import sd_model
-
-        return sd_model.current_lora_hash != str([])
+    def on_add_patches(self):
+        """signal that a new Patch was added"""
+        self.t_added = time.time()
 
 
 class ModelPatcher:
@@ -219,7 +218,7 @@ class ModelPatcher:
                 current_patches.append((strength_patch, patches[k], strength_model))
                 self.patches[k] = current_patches
 
-        self.patch_status.update()
+        self.patch_status.on_add_patches()
         return list(p)
 
     def get_key_patches(self, filter_prefix=None):
@@ -255,7 +254,10 @@ class ModelPatcher:
         if not patch_weights:
             return self.model
 
-        if self.patches and self.patch_status.require_patch():
+        if PERSISTENT_PATCHES and self.patch_status.require_unpatch():
+            self.unpatch_model(move=True)
+
+        if self.patches and ((not PERSISTENT_PATCHES) or self.patch_status.require_patch()):
             model_sd = self.model_state_dict()
             for key in self.patches:
                 if key not in model_sd:
@@ -281,6 +283,7 @@ class ModelPatcher:
                 del temp_weight
 
             self.patch_status.patch()
+            logger.debug("Patch Model")
 
         if device_to is not None:
             self.model.to(device_to)
@@ -463,8 +466,8 @@ class ModelPatcher:
 
         return weight
 
-    def unpatch_model(self, device_to=None):
-        if self.backup and self.patch_status.require_unpatch():
+    def unpatch_model(self, device_to=None, *, move: bool = (not PERSISTENT_PATCHES)):
+        if self.backup and move:
             keys = list(self.backup.keys())
 
             if self.weight_inplace_update:
@@ -475,7 +478,8 @@ class ModelPatcher:
                     ldm_patched.modules.utils.set_attr(self.model, k, self.backup[k])
 
             self.backup.clear()
-            self.patch_status.unpatch()
+            self.patch_status.sync()
+            logger.debug("Unpatch Model")
 
         if device_to is not None:
             self.model.to(device_to)

ldm_patched/modules/sd.py

@@ -90,6 +90,7 @@ class CLIP:
             self.cond_stage_model,
             load_device=load_device,
             offload_device=offload_device,
+            weight_inplace_update=opts.extra_networks_patch_inplace,
         )
         self.layer_idx = None
 

modules/esrgan_model.py

@@ -59,7 +59,7 @@ class UpscalerESRGAN(Upscaler):
             tile_overlap=opts.ESRGAN_tile_overlap,
         )
 
-    @lru_cache(maxsize=3, typed=False)
+    @lru_cache(maxsize=4, typed=False)
     def load_model(self, path: str):
         if not path.startswith("http"):
             filename = path

modules/images.py

@@ -346,7 +346,7 @@ def sanitize_filename_part(text, replace_spaces=True):
     return text
 
 
-@functools.lru_cache(maxsize=10, typed=False)
+@functools.lru_cache(maxsize=4, typed=False)
 def get_scheduler_str(sampler_name: str, scheduler_name: str):
     """Returns {Scheduler} if the scheduler is applicable to the sampler"""
     if scheduler_name == "Automatic":
@@ -355,7 +355,7 @@ def get_scheduler_str(sampler_name: str, scheduler_name: str):
     return scheduler_name.capitalize()
 
 
-@functools.lru_cache(maxsize=10, typed=False)
+@functools.lru_cache(maxsize=4, typed=False)
 def get_sampler_scheduler_str(sampler_name: str, scheduler_name: str):
     """Returns the '{Sampler} {Scheduler}' if the scheduler is applicable to the sampler"""
     return f"{sampler_name} {get_scheduler_str(sampler_name, scheduler_name)}"

modules/processing.py

@@ -882,6 +882,7 @@ def process_images_inner(p: StableDiffusionProcessing) -> Processed:
 
             sd_models.reload_model_weights()  # model can be changed for example by refiner
 
+            del p.sd_model.forge_objects
             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]
@@ -901,7 +902,8 @@ def process_images_inner(p: StableDiffusionProcessing) -> Processed:
             if not p.disable_extra_networks:
                 extra_networks.activate(p, p.extra_network_data)
 
-            p.sd_model.forge_objects = p.sd_model.forge_objects_after_applying_lora.shallow_copy()
+            if bool(shared.cached_lora_hash):
+                p.sd_model.forge_objects = p.sd_model.forge_objects_after_applying_lora.shallow_copy()
 
             if p.scripts is not None:
                 p.scripts.process_batch(p, batch_number=n, prompts=p.prompts, seeds=p.seeds, subseeds=p.subseeds)
@@ -1287,7 +1289,8 @@ class StableDiffusionProcessingTxt2Img(StableDiffusionProcessing):
 
             x = self.rng.next()
 
-            self.sd_model.forge_objects = self.sd_model.forge_objects_after_applying_lora.shallow_copy()
+            if bool(shared.cached_lora_hash):
+                self.sd_model.forge_objects = self.sd_model.forge_objects_after_applying_lora.shallow_copy()
             apply_token_merging(self.sd_model, self.get_token_merging_ratio())
 
             if self.scripts is not None:
@@ -1399,7 +1402,8 @@ class StableDiffusionProcessingTxt2Img(StableDiffusionProcessing):
         if self.scripts is not None:
             self.scripts.before_hr(self)
 
-        self.sd_model.forge_objects = self.sd_model.forge_objects_after_applying_lora.shallow_copy()
+        if bool(shared.cached_lora_hash):
+            self.sd_model.forge_objects = self.sd_model.forge_objects_after_applying_lora.shallow_copy()
         apply_token_merging(self.sd_model, self.get_token_merging_ratio(for_hr=True))
 
         if self.scripts is not None:
@@ -1717,7 +1721,8 @@ class StableDiffusionProcessingImg2Img(StableDiffusionProcessing):
             self.extra_generation_params["Noise multiplier"] = self.initial_noise_multiplier
             x *= self.initial_noise_multiplier
 
-        self.sd_model.forge_objects = self.sd_model.forge_objects_after_applying_lora.shallow_copy()
+        if bool(shared.cached_lora_hash):
+            self.sd_model.forge_objects = self.sd_model.forge_objects_after_applying_lora.shallow_copy()
         apply_token_merging(self.sd_model, self.get_token_merging_ratio())
 
         if self.scripts is not None:

modules/sd_models.py

@@ -446,6 +446,7 @@ def load_model(checkpoint_info=None, already_loaded_state_dict=None):
 
     model_data.set_sd_model(sd_model)
     model_data.was_loaded_at_least_once = True
+    shared.cached_lora_hash.clear()
 
     # Reload embeddings after model load as they may or may not fit the model
     sd_hijack.model_hijack.embedding_db.load_textual_inversion_embeddings(force_reload=True)

modules/sd_models_types.py

@@ -32,5 +32,11 @@ class WebuiSdModel:
     is_sdxl: bool
     """True if the model's architecture is SD XL"""
 
+    forge_objects_original: "ForgeObjects"
+    """The model patchers freshly created in `forge_loader`"""
+
     forge_objects: "ForgeObjects"
-    """The model patchers used by Forge"""
+    """The model patchers actively used during generation"""
+
+    forge_objects_after_applying_lora: "ForgeObjects"
+    """The model patchers after LoRA is applied; `None` if not using LoRA"""

modules/sd_samplers.py

@@ -116,7 +116,7 @@ def get_hr_scheduler_from_infotext(d: dict):
     return get_hr_sampler_and_scheduler(d)[1]
 
 
-@functools.lru_cache(maxsize=10, typed=False)
+@functools.lru_cache(maxsize=4, typed=False)
 def get_sampler_and_scheduler(sampler_name: str, scheduler_name: str, *, status: bool = False):
     default_sampler = samplers[0]
     found_scheduler = sd_schedulers.schedulers_map.get(scheduler_name, sd_schedulers.schedulers[0])

modules/sd_samplers_common.py

@@ -52,7 +52,7 @@ approximation_indexes = {
 }
 
 
-@lru_cache(maxsize=(shared.opts.sd_vae_checkpoint_cache), typed=False)
+@lru_cache(maxsize=getattr(shared.opts, "sd_vae_checkpoint_cache", 1), typed=False)
 def get_decoder(approximation: int) -> Callable:
     match approximation:
         case 1:

modules/shared.py

@@ -52,6 +52,7 @@ opts = None
 restricted_opts = None
 
 sd_model: sd_models_types.WebuiSdModel = None
+cached_lora_hash: list[tuple[str, float, float]] = []  # persistent patches
 
 settings_components = None
 """assigned from ui.py, a mapping on setting names to gradio components repsponsible for those settings"""

modules/shared_options.py

@@ -317,6 +317,7 @@ However, the resulting UI is quite... sluggish.
             "extra_networks_add_text_separator": OptionInfo(" ", "Extra Networks Separator").info("additional text to insert before the Extra Networks syntax"),
             "ui_extra_networks_tab_reorder": OptionInfo("", "Extra Networks Tab Order").info('tab names separated by "," character; empty = default').needs_reload_ui(),
             "textual_inversion_add_hashes_to_infotext": OptionInfo(True, "Append Textual Inversion hashes to infotext"),
+            "extra_networks_patch_inplace": OptionInfo(False, "Patch the LoRAs in-place").info("reduce peak memory usage").needs_restart(),
         },
     )
 )

modules/ui_extra_networks.py

@@ -3,7 +3,6 @@ import json
 import os.path
 import urllib.parse
 from dataclasses import dataclass
-from functools import lru_cache
 from pathlib import Path
 from typing import Optional
 
@@ -23,7 +22,6 @@ extra_pages = []
 allowed_dirs = set()
 
 
-@lru_cache(maxsize=1, typed=False)
 def allowed_preview_extensions():
     return ("jpg", "jpeg", "png", "webp")
 

modules_forge/diffusion_engine/sgm/models/diffusion.py

@@ -4,10 +4,8 @@ from ldm_patched.modules.model_management import unet_dtype, text_encoder_dtype,
 from lightning_fabric.utilities.device_dtype_mixin import _DeviceDtypeModuleMixin
 from omegaconf import OmegaConf
 from modules.shared import opts
-from functools import lru_cache
 
 
-@lru_cache(maxsize=1, typed=False)
 def _alpha():
     from ldm_patched.ldm.modules.diffusionmodules.util import make_beta_schedule
     import numpy as np

modules_forge/forge_loader.py

@@ -35,6 +35,12 @@ class ForgeObjects:
         self.vae: VAE = vae
         self.clipvision: ModelPatcher = clipvision
 
+    def __del__(self):
+        del self.unet
+        del self.clip
+        del self.vae
+        del self.clipvision
+
     def shallow_copy(self):
         return ForgeObjects(self.unet, self.clip, self.vae, self.clipvision)
 
@@ -96,6 +102,7 @@ def load_checkpoint_guess_config(sd, output_vae=True, output_clip=True, output_c
             load_device=load_device,
             offload_device=model_management.unet_offload_device(),
             current_device=initial_load_device,
+            weight_inplace_update=shared.opts.extra_networks_patch_inplace,
         )
         if initial_load_device != torch.device("cpu"):
             print("loaded straight to GPU")
@@ -132,9 +139,9 @@ def load_model_for_a1111(timer, checkpoint_info=None, state_dict=None) -> WebuiS
         output_model=True,
     )
 
-    sd_model.forge_objects = forge_objects
-    sd_model.forge_objects_original = forge_objects.shallow_copy()
-    sd_model.forge_objects_after_applying_lora = forge_objects.shallow_copy()
+    sd_model.forge_objects_original = forge_objects
+    sd_model.forge_objects = sd_model.forge_objects_original.shallow_copy()
+    sd_model.forge_objects_after_applying_lora = None
 
     del state_dict
     timer.record("forge load real models")
@@ -195,8 +202,6 @@ def load_model_for_a1111(timer, checkpoint_info=None, state_dict=None) -> WebuiS
     sd_model.sd_model_checkpoint = checkpoint_info.filename
     sd_model.sd_checkpoint_info = checkpoint_info
 
-    apply_alpha_schedule_override(sd_model)
-
     @torch.inference_mode()
     def patched_decode_first_stage(x):
         sample = sd_model.forge_objects.unet.model.model_config.latent_format.process_out(x)
@@ -240,6 +245,27 @@ def rescale_zero_terminal_snr_abar(alphas_cumprod):
     return alphas_bar
 
 
+def rescale_zero_terminal_snr_sigmas(sigmas):
+    """https://github.com/comfyanonymous/ComfyUI/blob/v0.3.48/comfy/model_sampling.py#L5"""
+    alphas_cumprod = 1 / ((sigmas * sigmas) + 1)
+    alphas_bar_sqrt = alphas_cumprod.sqrt()
+
+    # Store old values.
+    alphas_bar_sqrt_0 = alphas_bar_sqrt[0].clone()
+    alphas_bar_sqrt_T = alphas_bar_sqrt[-1].clone()
+
+    # Shift so the last timestep is zero.
+    alphas_bar_sqrt -= alphas_bar_sqrt_T
+
+    # Scale so the first timestep is back to the old value.
+    alphas_bar_sqrt *= alphas_bar_sqrt_0 / (alphas_bar_sqrt_0 - alphas_bar_sqrt_T)
+
+    # Convert alphas_bar_sqrt to betas
+    alphas_bar = alphas_bar_sqrt**2  # Revert sqrt
+    alphas_bar[-1] = 4.8973451890853435e-08
+    return ((1 - alphas_bar) / alphas_bar) ** 0.5
+
+
 def apply_alpha_schedule_override(sd_model, p=None):
     """
     Applies an override to the alpha schedule of the model according to settings.
@@ -261,6 +287,7 @@ def apply_alpha_schedule_override(sd_model, p=None):
         if p is not None:
             p.extra_generation_params["Noise Schedule"] = "Zero Terminal SNR"
         sd_model.alphas_cumprod = rescale_zero_terminal_snr_abar(sd_model.alphas_cumprod).to(shared.device)
+        sd_model.forge_objects.unet.model.model_sampling.set_sigmas(rescale_zero_terminal_snr_sigmas(sd_model.forge_objects.unet.model.model_sampling.sigmas).to(shared.device))
 
 
 ForgeSD = ForgeObjects