Upload 868 files

uptade forge classic v1.6

README.md

@@ -18,24 +18,23 @@ The name "Forge" is inspired by "Minecraft Forge". This project aims to become t
 
 <br>
 
-## Features [Apr. 30]
+## Features [May. 21]
 > Most base features of the original [Automatic1111 Webui](https://github.com/AUTOMATIC1111/stable-diffusion-webui) should still function
 
 #### New Features
 
-- [X] Support `v-pred` **SDXL** checkpoints *(**eg.** [NoobAI](https://civitai.com/models/833294?modelVersionId=1190596))*
 - [X] Support [uv](https://github.com/astral-sh/uv) package manager
-    - requires **uv**
+    - requires **manually** installing [uv](https://github.com/astral-sh/uv/releases)
     - drastically speed up installation
     - see [Commandline](#by-classic)
 - [X] Support [SageAttention](https://github.com/thu-ml/SageAttention)
-    - requires **manually** installing the [triton](https://github.com/triton-lang/triton) package
+    - requires **manually** installing [triton](https://github.com/triton-lang/triton)
         - [how to install](#install-triton)
     - requires RTX **30** +
-    - ~10% speed up
+    - ~10% speed up for SDXL
     - see [Commandline](#by-classic)
 - [X] Support [FlashAttention](https://arxiv.org/abs/2205.14135)
-    - requires **manually** installing the [flash-attn](https://github.com/Dao-AILab/flash-attention) package
+    - requires **manually** installing [flash-attn](https://github.com/Dao-AILab/flash-attention)
         - [how to install](#install-flash-attn)
     - ~10% speed up
 - [X] Support fast `fp16_accumulation`
@@ -43,37 +42,46 @@ The name "Forge" is inspired by "Minecraft Forge". This project aims to become t
     - ~25% speed up
     - see [Commandline](#by-classic)
 - [X] Support fast `cublas` operation *(`CublasLinear`)*
-    - requires **manually** installing the [cublas_ops](https://github.com/aredden/torch-cublas-hgemm) package
+    - requires **manually** installing [cublas_ops](https://github.com/aredden/torch-cublas-hgemm)
         - [how to install](#install-cublas)
     - ~25% speed up
-    - enable in **Settings**
+    - enable in **Settings/Optimizations**
 - [X] Support fast `fp8` operation *(`torch._scaled_mm`)*
     - requires RTX **40** +
     - ~10% speed up; reduce quality
-    - enable in **Settings**
+    - enable in **Settings/Optimizations**
 
 > [!Note]
-> - The `fp16_accumulation` and `cublas` operation achieve the same speed up; if you already install/update to `torch==2.7.0`, you do not need to go for `cublas_ops`
-> - The `fp16_accumulation` and `cublas` operation require `fp16` precision, thus is not compatible with the `fp8` operation
+> - 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] Implement new Samplers
+    - *(ported from reForge Webui)*
+- [X] Implement Scheduler Dropdown
+    - *(backported from Automatic1111 Webui upstream)*
+    - enable in **Settings/UI alternatives**
 - [X] Implement RescaleCFG
     - reduce burnt colors; mainly for `v-pred` checkpoints
+    - enable in **Settings/UI alternatives**
 - [X] Implement MaHiRo
-    - alternative CFG calculation
-    - [graph](https://www.desmos.com/calculator/wcztf0ktiq)
-- [X] Implement `diskcache`
+    - alternative CFG calculation; improve prompt adherence
+    - enable in **Settings/UI alternatives**
+- [X] Implement `diskcache` for hashes
     - *(backported from Automatic1111 Webui upstream)*
 - [X] Implement `skip_early_cond`
     - *(backported from Automatic1111 Webui upstream)*
+    - enable in **Settings/Optimizations**
+- [X] Support `v-pred` **SDXL** checkpoints *(**eg.** [NoobAI](https://civitai.com/models/833294?modelVersionId=1190596))*
+- [X] Support new LoRA architectures
 - [X] Update `spandrel`
-    - support most modern Upscaler architecture
+    - support new Upscaler architectures
 - [X] Add `pillow-heif` package
-    - support `.avif` and `.heif` formats
-- [X] Automatic row split for `X/Y/Z Plot`
-- [X] Add an option to disable **Refiner**
-- [X] Add an option to disable ExtraNetworks **Tree View**
+    - support `.avif` and `.heif` images
+- [X] Automatically determine the optimal row count for `X/Y/Z Plot`
+- [X] `DepthAnything v2` Preprocessor
+- [X] Support [NoobAI Inpaint](https://civitai.com/models/1376234/noobai-inpainting-controlnet) ControlNet
 - [X] Support [Union](https://huggingface.co/xinsir/controlnet-union-sdxl-1.0) / [ProMax](https://huggingface.co/brad-twinkl/controlnet-union-sdxl-1.0-promax) ControlNet
-    - I just made them always show up in the dropdown
+    - they simply always show up in the dropdown
 
 #### Removed Features
 
@@ -88,9 +96,12 @@ The name "Forge" is inspired by "Minecraft Forge". This project aims to become t
 - [X] Textual Inversion Training
 - [X] Checkpoint Merging
 - [X] LDSR
-- [X] Most **built-in** Extensions
-- [X] Some **built-in** Scripts
-- [X] The `test` scripts
+- [X] Most built-in Extensions
+- [X] Some built-in Scripts
+- [X] Some Samplers
+- [X] Sampler in RadioGroup
+- [X] `test` scripts
+- [X] Some Preprocessors *(ControlNet)*
 - [X] `Photopea` and `openpose_editor` *(ControlNet)*
 - [X] Unix `.sh` launch scripts
     - You can still use this WebUI by copying a launch script from another working WebUI; I just don't want to maintain them...
@@ -103,17 +114,19 @@ The name "Forge" is inspired by "Minecraft Forge". This project aims to become t
 - [X] Fix memory leak when switching checkpoints
 - [X] Clean up the `ldm_patched` *(**ie.** `comfy`)* folder
 - [X] Remove unused `cmd_args`
-- [X] Remove unused `shared_options`
 - [X] Remove unused `args_parser`
+- [X] Remove unused `shared_options`
 - [X] Remove legacy codes
 - [X] Remove duplicated upscaler codes
     - put every upscaler inside the `ESRGAN` folder
+    - optimize upscaler logics
 - [X] Improve color correction
-- [X] Improve code logics
 - [X] Improve hash caching
 - [X] Improve error logs
-    - no longer prints `TypeError: 'NoneType' object is not iterable`
-- [X] Improve setting descriptions
+    - no longer just print `TypeError: 'NoneType' object is not iterable`
+- [X] Revamp settings
+    - improve formatting
+    - update descriptions
 - [X] Check for Extension updates in parallel
 - [X] Moved `embeddings` folder into `models` folder
 - [X] ControlNet Rewrite
@@ -121,19 +134,27 @@ The name "Forge" is inspired by "Minecraft Forge". This project aims to become t
     - remove multi-inputs, as they are "[misleading](https://github.com/lllyasviel/stable-diffusion-webui-forge/discussions/932)"
     - 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**
+- [X] Disable Tree View by default
+    - enable again in **Settings/Extra Networks**
 - [X] Run `text encoder` on CPU by default
 - [X] Fix `pydantic` Errors
 - [X] Fix `Soft Inpainting`
-- [X] Lint & Format most of the Python and JavaScript codes
-- [X] Update to Pillow 11
+- [X] Lint & Format
+- [X] Update `Pillow`
     - faster image processing
 - [X] Update `protobuf`
     - faster `insightface` loading
 - [X] Update to latest PyTorch
     - `torch==2.7.0+cu128`
     - `xformers==0.0.30`
+
+> [!Tip]
+> 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
-- [X] Update certain packages to newer versions
+- [X] Update some packages to newer versions
 - [X] Update recommended Python to `3.11.9`
 - [X] many more... :tm:
 
@@ -181,6 +202,12 @@ The name "Forge" is inspired by "Minecraft Forge". This project aims to become t
 > [!Important]
 > Using `symlink` means it will directly access the packages from the cache folders; refrain from clearing the cache when setting this option
 
+- `--model-ref`: Points to a central `models` folder that contains all your models
+    - said folder should contain subfolders like `Stable-diffusion`, `Lora`, `VAE`, `ESRGAN`, etc.
+
+> [!Important]
+> This simply **replaces** the `models` folder, rather than adding on top of it
+
 - `--fast-fp16`: Enable the `allow_fp16_accumulation` option
     - requires PyTorch **2.7.0** +
 - `--sage`: Install the `sageattention` package to speed up generation
@@ -188,14 +215,21 @@ The name "Forge" is inspired by "Minecraft Forge". This project aims to become t
     - requires RTX **30** +
     - only affects **SDXL**
 
-> [!Tip]
-> `--xformers` is still recommended even if you already have `--sage`, as `sageattention` does not speed up **VAE** while `xformers` does
+> [!Note]
+> For RTX **50** users, you may need to manually [install](#install-sageattention-2) `sageattention 2` instead
 
-- `--model-ref`: Points to a central `models` folder that contains all your models
-    - said folder should contain subfolders like `Stable-diffusion`, `Lora`, `VAE`, `ESRGAN`, etc.
+<details>
+<summary>with SageAttention 2</summary>
 
-> [!Important]
-> This simply **replaces** the `models` folder, rather than adding on top of it
+- `--sageattn2-api`: Select the function used by **SageAttention 2**
+    - **options:**
+        - `auto` (default)
+        - `triton-fp16`
+        - `cuda-fp16`
+        - `cuda-fp8`
+    - try the `fp16` options if you get `NaN` *(black images)* on `auto`
+
+</details>
 
 <br>
 
@@ -212,7 +246,7 @@ The name "Forge" is inspired by "Minecraft Forge". This project aims to become t
 <details>
 <summary>Recommended Method</summary>
 
-- Install **[uv](https://github.com/astral-sh/uv)**
+- Install **[uv](https://github.com/astral-sh/uv#installation)**
 - Set up **venv**
     ```bash
     cd sd-webui-forge-classic
@@ -329,7 +363,6 @@ The name "Forge" is inspired by "Minecraft Forge". This project aims to become t
 </details>
 
 ### Install sageattention 2
-> If you only use **SDXL**, then `1.x` is already enough; `2.x` simply has partial support for **SD1** checkpoints
 
 <details>
 <summary>Expand</summary>
@@ -363,10 +396,7 @@ The name "Forge" is inspired by "Minecraft Forge". This project aims to become t
 
 </details>
 
-<br>
-
 ### Install older PyTorch
-> Read this if your GPU does not support the latest PyTorch
 
 <details>
 <summary>Expand</summary>
@@ -385,7 +415,7 @@ set TORCH_COMMAND=pip install torch==2.1.2 torchvision==0.16.2 --extra-index-url
 ## Attention
 
 > [!Important]
-> The `--xformers` and `--sage` args are only responsible for installing the packages, **not** whether its respective attention is used; This also means you can remove them once they are successfully installed
+> The `--xformers` and `--sage` args are only responsible for installing the packages, **not** whether its respective attention is used *(this also means you can remove them once the packages are successfully installed)*
 
 **Forge Classic** tries to import the packages and automatically choose the first available attention function in the following order:
 
@@ -395,8 +425,11 @@ set TORCH_COMMAND=pip install torch==2.1.2 torchvision==0.16.2 --extra-index-url
 4. `PyTorch`
 5. `Basic`
 
+> [!Tip]
+> To skip a specific attention, add the respective disable arg such as `--disable-sage`
+
 > [!Note]
-> The VAE only checks for `xformers`
+> The **VAE** only checks for `xformers`, so `--xformers` is still recommended even if you already have `--sage`
 
 In my experience, the speed of each attention function for SDXL is ranked in the following order:
 
@@ -405,6 +438,8 @@ In my experience, the speed of each attention function for SDXL is ranked in the
 > [!Note]
 > `SageAttention` is based on quantization, so its quality might be slightly worse than others
 
+<br>
+
 ## Issues & Requests
 
 - **Issues** about removed features will simply be ignored

extensions-builtin/Lora/extra_networks_lora.py

@@ -26,17 +26,19 @@ class ExtraNetworkLora(extra_networks.ExtraNetwork):
         for params in params_list:
             assert params.items
 
-            names.append(params.positional[0])
-
             te_multiplier = float(params.positional[1]) if len(params.positional) > 1 else 1.0
             te_multiplier = float(params.named.get("te", te_multiplier))
 
             unet_multiplier = float(params.positional[2]) if len(params.positional) > 2 else te_multiplier
             unet_multiplier = float(params.named.get("unet", unet_multiplier))
 
+            if te_multiplier == 0.0 and unet_multiplier == 0.0:
+                continue
+
             dyn_dim = int(params.positional[3]) if len(params.positional) > 3 else None
             dyn_dim = int(params.named["dyn"]) if "dyn" in params.named else dyn_dim
 
+            names.append(params.positional[0])
             te_multipliers.append(te_multiplier)
             unet_multipliers.append(unet_multiplier)
             dyn_dims.append(dyn_dim)

extensions-builtin/Lora/network.py

@@ -21,16 +21,15 @@ metadata_tags_order = {
 class SDVersion(enum.Enum):
     Unknown = -1
     SD1 = 1
-    SD2 = 2
     SDXL = 3
 
 
 class NetworkOnDisk:
-    def __init__(self, name, filename):
-        self.name = name
-        self.filename = filename
-        self.metadata = {}
-        self.is_safetensors = filename.lower().endswith(".safetensors")
+    def __init__(self, name: str, filename: str):
+        self.name: str = name
+        self.filename: str = filename
+        self.metadata: dict[str, str] = {}
+        self.is_safetensors: bool = filename.lower().endswith(".safetensors")
 
         def read_metadata():
             metadata = sd_models.read_metadata_from_safetensors(filename)
@@ -50,19 +49,17 @@ class NetworkOnDisk:
 
             self.metadata = m
 
-        self.alias = self.metadata.get("ss_output_name", self.name)
+        self.alias: str = self.metadata.get("ss_output_name", self.name)
 
-        self.hash = None
-        self.shorthash = None
+        self.hash: str = None
+        self.shorthash: str = None
         self.set_hash(self.metadata.get("sshs_model_hash") or hashes.sha256_from_cache(self.filename, "/".join(["lora", self.name]), use_addnet_hash=self.is_safetensors) or "")
 
-        self.sd_version = self.detect_version()
+        self.sd_version: "SDVersion" = self.detect_version()
 
     def detect_version(self):
         if str(self.metadata.get("ss_base_model_version", "")).startswith("sdxl_"):
             return SDVersion.SDXL
-        elif str(self.metadata.get("ss_v2", "")) == "True":
-            return SDVersion.SD2
         elif len(self.metadata):
             return SDVersion.SD1
 

extensions-builtin/Lora/networks.py

@@ -20,6 +20,16 @@ def load_network(name, network_on_disk):
     return net
 
 
+def get_networks_on_desk(names: list[str], *, tried: bool = True) -> list["network.NetworkOnDisk"]:
+    networks_on_disk = [(available_networks.get(name, None) if name.lower() in forbidden_network_aliases else available_network_aliases.get(name, None)) for name in names]
+
+    if tried or all(x is not None for x in networks_on_disk):
+        return networks_on_disk
+
+    list_available_networks()
+    return get_networks_on_desk(names, tried=True)
+
+
 def load_networks(names, te_multipliers=None, unet_multipliers=None, dyn_dims=None):
     global lora_state_dict_cache
 
@@ -29,8 +39,7 @@ def load_networks(names, te_multipliers=None, unet_multipliers=None, dyn_dims=No
 
     loaded_networks.clear()
 
-    networks_on_disk = [(available_networks.get(name, None) if name.lower() in forbidden_network_aliases else available_network_aliases.get(name, None)) for name in names]
-    assert not any(x is None for x in networks_on_disk)
+    networks_on_disk = get_networks_on_desk(names, tried=False)
 
     for network_on_disk, name in zip(networks_on_disk, names):
         try:

extensions-builtin/Lora/scripts/lora_script.py

@@ -14,11 +14,10 @@ shared.options_templates.update(
     shared.options_section(
         ("extra_networks", "Extra Networks"),
         {
-            "sd_lora": shared.OptionInfo("None", "Add network to prompt", gr.Dropdown, lambda: {"choices": ["None", *networks.available_networks]}, refresh=networks.list_available_networks),
-            "lora_preferred_name": shared.OptionInfo("Alias from file", "When adding to prompt, refer to Lora by", gr.Radio, {"choices": ["Alias from file", "Filename"]}),
-            "lora_add_hashes_to_infotext": shared.OptionInfo(True, "Add Lora hashes to infotext"),
-            "lora_show_all": shared.OptionInfo(False, "Always show all networks on the Lora page").info("otherwise, those detected as for incompatible version of Stable Diffusion will be hidden"),
-            "lora_hide_unknown_for_versions": shared.OptionInfo([], "Hide networks of unknown versions for model versions", gr.CheckboxGroup, {"choices": ["SD1", "SD2", "SDXL"]}),
+            "sd_lora": shared.OptionInfo("None", "Append LoRA to prompt", gr.Dropdown, lambda: {"choices": ["None", *networks.available_networks]}, refresh=networks.list_available_networks),
+            "lora_preferred_name": shared.OptionInfo("Alias", "When adding syntax to prompt, refer to LoRA by", gr.Radio, {"choices": ("Alias", "Filename")}),
+            "lora_add_hashes_to_infotext": shared.OptionInfo(True, "Append LoRA hashes to infotext"),
+            "lora_show_all": shared.OptionInfo(False, "Always show all LoRA cards").info("otherwise, those detected as for incompatible version of Stable Diffusion will be hidden"),
         },
     )
 )

extensions-builtin/Lora/ui_edit_user_metadata.py

@@ -68,6 +68,7 @@ class LoraUserMetadataEditor(UserMetadataEditor):
         user_metadata["notes"] = notes
 
         self.write_user_metadata(name, user_metadata)
+        self.page.refresh()
 
     def get_metadata_table(self, name):
         table = super().get_metadata_table(name)
@@ -146,7 +147,7 @@ class LoraUserMetadataEditor(UserMetadataEditor):
 
     def create_extra_default_items_in_left_column(self):
         self.select_sd_version = gr.Dropdown(
-            choices=("SD1", "SD2", "SDXL", "Unknown"),
+            choices=("SD1", "SDXL", "Unknown"),
             value="Unknown",
             label="Stable Diffusion Version",
             interactive=True,

extensions-builtin/Lora/ui_extra_networks_lora.py

@@ -53,13 +53,7 @@ class ExtraNetworksPageLora(ExtraNetworksPage):
             sd_version = lora_on_disk.sd_version
 
         if enable_filter and not shared.opts.lora_show_all:
-            if sd_version is network.SDVersion.Unknown:
-                model_version = network.SDVersion.SDXL if shared.sd_model.is_sdxl else network.SDVersion.SD1
-                if model_version.name in shared.opts.lora_hide_unknown_for_versions:
-                    return None
-            elif shared.sd_model.is_sdxl and sd_version != network.SDVersion.SDXL:
-                return None
-            elif shared.sd_model.is_sd2 and sd_version != network.SDVersion.SD2:
+            if shared.sd_model.is_sdxl and sd_version != network.SDVersion.SDXL:
                 return None
             elif shared.sd_model.is_sd1 and sd_version != network.SDVersion.SD1:
                 return None

extensions-builtin/forge_legacy_preprocessors/annotator/depth_anything.py

@@ -1,15 +1,15 @@
 import os
-import torch
+
 import cv2
 import numpy as np
+import torch
 import torch.nn.functional as F
+from depth_anything.dpt import DPT_DINOv2
+from depth_anything.util.transform import NormalizeImage, PrepareForNet, Resize
 from torchvision.transforms import Compose
 
-from depth_anything.dpt import DPT_DINOv2
-from depth_anything.util.transform import Resize, NormalizeImage, PrepareForNet
-from .util import load_model
 from .annotator_path import models_path
-
+from .util import load_model
 
 transform = Compose(
     [
@@ -49,9 +49,7 @@ class DepthAnythingDetector:
             "CONTROLNET_DEPTH_ANYTHING_MODEL_URL",
             "https://huggingface.co/spaces/LiheYoung/Depth-Anything/resolve/main/checkpoints/depth_anything_vitl14.pth",
         )
-        model_path = load_model(
-            "depth_anything_vitl14.pth", remote_url=remote_url, model_dir=self.model_dir
-        )
+        model_path = load_model("depth_anything_vitl14.pth", remote_url=remote_url, model_dir=self.model_dir)
         self.model.load_state_dict(torch.load(model_path))
 
     def __call__(self, image: np.ndarray, colored: bool = True) -> np.ndarray:
@@ -67,9 +65,7 @@ class DepthAnythingDetector:
             return model(image)
 
         depth = predict_depth(self.model, image)
-        depth = F.interpolate(
-            depth[None], (h, w), mode="bilinear", align_corners=False
-        )[0, 0]
+        depth = F.interpolate(depth[None], (h, w), mode="bilinear", align_corners=False)[0, 0]
         depth = (depth - depth.min()) / (depth.max() - depth.min()) * 255.0
         depth = depth.cpu().numpy().astype(np.uint8)
         if colored:

extensions-builtin/forge_legacy_preprocessors/annotator/depth_anything_v2.py

@@ -0,0 +1,78 @@
+import os
+
+import cv2
+import numpy as np
+import torch
+import torch.nn.functional as F
+from depth_anything_v2.dpt import DepthAnythingV2
+from depth_anything_v2.util.transform import NormalizeImage, PrepareForNet, Resize
+from safetensors.torch import load_file
+from torchvision.transforms import Compose
+
+from .annotator_path import models_path
+from .util import load_model
+
+transform = Compose(
+    [
+        Resize(
+            width=518,
+            height=518,
+            resize_target=False,
+            keep_aspect_ratio=True,
+            ensure_multiple_of=14,
+            resize_method="lower_bound",
+            image_interpolation_method=cv2.INTER_CUBIC,
+        ),
+        NormalizeImage(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]),
+        PrepareForNet(),
+    ]
+)
+
+
+class DepthAnythingV2Detector:
+    """https://github.com/MackinationsAi/Upgraded-Depth-Anything-V2"""
+
+    model_dir = os.path.join(models_path, "depth_anything_v2")
+
+    def __init__(self, device: torch.device):
+        self.device = device
+        self.model = (
+            DepthAnythingV2(
+                encoder="vitl",
+                features=256,
+                out_channels=[256, 512, 1024, 1024],
+            )
+            .to(device)
+            .eval()
+        )
+        remote_url = os.environ.get(
+            "CONTROLNET_DEPTH_ANYTHING_V2_MODEL_URL",
+            "https://huggingface.co/MackinationsAi/Depth-Anything-V2_Safetensors/resolve/main/depth_anything_v2_vitl.safetensors",
+        )
+        model_path = load_model("depth_anything_v2_vitl.safetensors", remote_url=remote_url, model_dir=self.model_dir)
+        self.model.load_state_dict(load_file(model_path))
+
+    def __call__(self, image: np.ndarray, colored: bool = True) -> np.ndarray:
+        self.model.to(self.device)
+        h, w = image.shape[:2]
+
+        image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB) / 255.0
+        image = transform({"image": image})["image"]
+        image = torch.from_numpy(image).unsqueeze(0).to(self.device)
+
+        @torch.no_grad()
+        def predict_depth(model, image):
+            return model(image)
+
+        depth = predict_depth(self.model, image)
+        depth = F.interpolate(depth[None], (h, w), mode="bilinear", align_corners=False)[0, 0]
+        depth = (depth - depth.min()) / (depth.max() - depth.min()) * 255.0
+        depth = depth.cpu().numpy().astype(np.uint8)
+        if colored:
+            depth_color = cv2.applyColorMap(depth, cv2.COLORMAP_INFERNO)[:, :, ::-1]
+            return depth_color
+        else:
+            return depth
+
+    def unload_model(self):
+        self.model.to("cpu")

extensions-builtin/forge_legacy_preprocessors/annotator/pidinet/model.py

@@ -11,7 +11,7 @@ import torch
 import torch.nn as nn
 import torch.nn.functional as F
 from modules import devices
-from basicsr.utils import img2tensor
+
 
 nets = {
     "baseline": {
@@ -739,17 +739,3 @@ def pidinet():
     pdcs = config_model("carv4")
     dil = 24  # if args.dil else None
     return PiDiNet(60, pdcs, dil=dil, sa=True)
-
-
-if __name__ == "__main__":
-    model = pidinet()
-    ckp = torch.load("table5_pidinet.pth")["state_dict"]
-    model.load_state_dict({k.replace("module.", ""): v for k, v in ckp.items()})
-    im = cv2.imread("examples/test_my/cat_v4.png")
-    im = img2tensor(im).unsqueeze(0) / 255.0
-    res = model(im)[-1]
-    res = res > 0.5
-    res = res.float()
-    res = (res[0, 0].cpu().data.numpy() * 255.0).astype(np.uint8)
-    print(res.shape)
-    cv2.imwrite("edge.png", res)

extensions-builtin/forge_legacy_preprocessors/install.py

@@ -1,8 +1,6 @@
 import os
 from pathlib import Path
-from typing import Optional, Tuple
-
-import pkg_resources
+from modules.errors import display
 
 import launch
 
@@ -10,72 +8,37 @@ repo_root = Path(__file__).parent
 main_req_file = repo_root / "requirements.txt"
 
 
-def comparable_version(version: str) -> Tuple:
-    return tuple(version.split("."))
-
-
-def get_installed_version(package: str) -> Optional[str]:
-    try:
-        return pkg_resources.get_distribution(package).version
-    except Exception:
-        return None
-
-
-def extract_base_package(package_string: str) -> str:
-    base_package = package_string.split("@git")[0]
-    return base_package
-
-
 def install_requirements(req_file):
-    with open(req_file) as file:
-        for package in file:
+    with open(req_file, "r") as file:
+        for package in file.readlines():
             try:
                 package = package.strip()
-                if "==" in package:
-                    package_name, package_version = package.split("==")
-                    installed_version = get_installed_version(package_name)
-                    if installed_version != package_version:
-                        launch.run_pip(
-                            f"install -U {package}",
-                            f"forge_legacy_preprocessor requirement: {package_name}=={package_version}",
-                        )
-                elif ">=" in package:
-                    package_name, package_version = package.split(">=")
-                    installed_version = get_installed_version(package_name)
-                    if not installed_version or comparable_version(installed_version) < comparable_version(package_version):
-                        launch.run_pip(
-                            f"install -U {package}",
-                            f"forge_legacy_preprocessor requirement: {package_name}=={package_version}",
-                        )
-                elif not launch.is_installed(extract_base_package(package)):
+                if not launch.is_installed(package):
                     launch.run_pip(
                         f"install {package}",
-                        f"forge_legacy_preprocessor requirement: {package}",
+                        f"Legacy Preprocessor Requirement: {package}",
                     )
             except Exception as e:
-                print(e)
-                print(f"Warning: Failed to install {package}, some preprocessors may not work.")
+                display(e, "cnet req")
+                print(f"Failed to install {package}, some Preprocessors may not work...")
 
 
-def try_install_from_wheel(pkg_name: str, wheel_url: str, version: Optional[str] = None):
-    current_version = get_installed_version(pkg_name)
-    if current_version is not None:
-        if version is None:
-            return
-        if comparable_version(current_version) >= comparable_version(version):
-            return
+install_requirements(main_req_file)
+
+
+def try_install_from_wheel(pkg_name: str, wheel_url: str):
+    if launch.is_installed(pkg_name):
+        return
 
     try:
         launch.run_pip(
             f"install -U {wheel_url}",
-            f"forge_legacy_preprocessor requirement: {pkg_name}",
+            f"Legacy Preprocessor Requirement: {pkg_name}",
         )
     except Exception as e:
-        print(e)
-        print(f"Warning: Failed to install {pkg_name}. Some processors will not work.")
-
+        display(e, "cnet req")
+        print(f"Failed to install {pkg_name}, some Preprocessors may not work...")
 
-install_requirements(main_req_file)
 
 try_install_from_wheel(
     "handrefinerportable",
@@ -83,8 +46,8 @@ try_install_from_wheel(
         "HANDREFINER_WHEEL",
         "https://github.com/huchenlei/HandRefinerPortable/releases/download/v1.0.1/handrefinerportable-2024.2.12.0-py2.py3-none-any.whl",
     ),
-    version="2024.2.12.0",
 )
+
 try_install_from_wheel(
     "depth_anything",
     wheel_url=os.environ.get(
@@ -92,3 +55,11 @@ try_install_from_wheel(
         "https://github.com/huchenlei/Depth-Anything/releases/download/v1.0.0/depth_anything-2024.1.22.0-py2.py3-none-any.whl",
     ),
 )
+
+try_install_from_wheel(
+    "depth_anything_v2",
+    wheel_url=os.environ.get(
+        "DEPTH_ANYTHING_V2_WHEEL",
+        "https://github.com/MackinationsAi/UDAV2-ControlNet/releases/download/v1.0.0/depth_anything_v2-2024.7.1.0-py2.py3-none-any.whl",
+    ),
+)

extensions-builtin/forge_legacy_preprocessors/legacy_preprocessors/preprocessor.py

@@ -168,9 +168,7 @@ def mediapipe_face(img, res=512, thr_a: int = 10, thr_b: float = 0.5, **kwargs):
         from annotator.mediapipe_face import apply_mediapipe_face
 
         model_mediapipe_face = apply_mediapipe_face
-    result = model_mediapipe_face(
-        img, max_faces=max_faces, min_confidence=min_confidence
-    )
+    result = model_mediapipe_face(img, max_faces=max_faces, min_confidence=min_confidence)
     return remove_pad(result), True
 
 
@@ -217,6 +215,26 @@ def unload_depth_anything():
         model_depth_anything.unload_model()
 
 
+model_depth_anything_v2 = None
+
+
+def depth_anything_v2(img, res: int = 512, colored: bool = True, **kwargs):
+    img, remove_pad = resize_image_with_pad(img, res)
+    global model_depth_anything_v2
+    if model_depth_anything_v2 is None:
+        with Extra(torch_handler):
+            from annotator.depth_anything_v2 import DepthAnythingV2Detector
+
+            device = devices.get_device_for("controlnet")
+            model_depth_anything_v2 = DepthAnythingV2Detector(device)
+    return remove_pad(model_depth_anything_v2(img, colored=colored)), True
+
+
+def unload_depth_anything_v2():
+    if model_depth_anything_v2 is not None:
+        model_depth_anything_v2.unload_model()
+
+
 model_midas = None
 
 
@@ -305,17 +323,20 @@ class OpenposeModel(object):
 
             self.model_openpose = OpenposeDetector()
 
-        return remove_pad(
-            self.model_openpose(
-                img,
-                include_body=include_body,
-                include_hand=include_hand,
-                include_face=include_face,
-                use_dw_pose=use_dw_pose,
-                use_animal_pose=use_animal_pose,
-                json_pose_callback=json_pose_callback,
-            )
-        ), True
+        return (
+            remove_pad(
+                self.model_openpose(
+                    img,
+                    include_body=include_body,
+                    include_hand=include_hand,
+                    include_face=include_face,
+                    use_dw_pose=use_dw_pose,
+                    use_animal_pose=use_animal_pose,
+                    json_pose_callback=json_pose_callback,
+                )
+            ),
+            True,
+        )
 
     def unload(self):
         if self.model_openpose is not None:
@@ -566,9 +587,7 @@ def lama_inpaint(img, res=512, **kwargs):
     prd_color = cv2.resize(prd_color, (W, H))
 
     alpha = raw_mask.astype(np.float32) / 255.0
-    fin_color = prd_color.astype(np.float32) * alpha + raw_color.astype(np.float32) * (
-        1 - alpha
-    )
+    fin_color = prd_color.astype(np.float32) * alpha + raw_color.astype(np.float32) * (1 - alpha)
     fin_color = fin_color.clip(0, 255).astype(np.uint8)
 
     result = np.concatenate([fin_color, raw_mask], axis=2)
@@ -613,46 +632,6 @@ def unload_normal_bae():
     pass
 
 
-model_oneformer_coco = None
-
-
-def oneformer_coco(img, res=512, **kwargs):
-    img, remove_pad = resize_image_with_pad(img, res)
-    global model_oneformer_coco
-    if model_oneformer_coco is None:
-        from annotator.oneformer import OneformerDetector
-
-        model_oneformer_coco = OneformerDetector(OneformerDetector.configs["coco"])
-    result = model_oneformer_coco(img)
-    return remove_pad(result), True
-
-
-def unload_oneformer_coco():
-    global model_oneformer_coco
-    if model_oneformer_coco is not None:
-        model_oneformer_coco.unload_model()
-
-
-model_oneformer_ade20k = None
-
-
-def oneformer_ade20k(img, res=512, **kwargs):
-    img, remove_pad = resize_image_with_pad(img, res)
-    global model_oneformer_ade20k
-    if model_oneformer_ade20k is None:
-        from annotator.oneformer import OneformerDetector
-
-        model_oneformer_ade20k = OneformerDetector(OneformerDetector.configs["ade20k"])
-    result = model_oneformer_ade20k(img)
-    return remove_pad(result), True
-
-
-def unload_oneformer_ade20k():
-    global model_oneformer_ade20k
-    if model_oneformer_ade20k is not None:
-        model_oneformer_ade20k.unload_model()
-
-
 model_shuffle = None
 
 
@@ -808,15 +787,10 @@ class InsightFaceModel:
         if not faces:
             raise Exception(f"Insightface: No face found in image {i}.")
         if len(faces) > 1:
-            print(
-                "Insightface: More than one face is detected in the image. "
-                f"Only the first one will be used {i}."
-            )
+            print("Insightface: More than one face is detected in the image. " f"Only the first one will be used {i}.")
         return torch.from_numpy(faces[0].normed_embedding).unsqueeze(0), False
 
-    def run_model_instant_id(
-        self, img: np.ndarray, res: int = 512, return_keypoints: bool = False, **kwargs
-    ) -> Tuple[Union[np.ndarray, torch.Tensor], bool]:
+    def run_model_instant_id(self, img: np.ndarray, res: int = 512, return_keypoints: bool = False, **kwargs) -> Tuple[Union[np.ndarray, torch.Tensor], bool]:
         """Run the insightface model for instant_id.
         Arguments:
             - img: Input image in any size.
@@ -877,10 +851,7 @@ class InsightFaceModel:
         if not face_info:
             raise Exception(f"Insightface: No face found in image.")
         if len(face_info) > 1:
-            print(
-                "Insightface: More than one face is detected in the image. "
-                f"Only the biggest one will be used."
-            )
+            print("Insightface: More than one face is detected in the image. " f"Only the biggest one will be used.")
         # only use the maximum face
         face_info = sorted(
             face_info,
@@ -893,9 +864,7 @@ class InsightFaceModel:
 
 
 g_insight_face_model = InsightFaceModel()
-g_insight_face_instant_id_model = InsightFaceModel(
-    face_analysis_model_name="antelopev2"
-)
+g_insight_face_instant_id_model = InsightFaceModel(face_analysis_model_name="antelopev2")
 
 
 @dataclass

extensions-builtin/forge_legacy_preprocessors/legacy_preprocessors/preprocessor_compiled.py

@@ -115,6 +115,19 @@ legacy_preprocessors = {
         "priority": 0,
         "tags": ["Depth"],
     },
+    "depth_anything_v2": {
+        "label": "depth_anything_v2",
+        "call_function": functools.partial(depth_anything_v2, colored=False),
+        "unload_function": unload_depth_anything_v2,
+        "managed_model": "model_depth_anything_v2",
+        "model_free": False,
+        "no_control_mode": False,
+        "resolution": None,
+        "slider_1": None,
+        "slider_2": None,
+        "priority": 0,
+        "tags": ["Depth"],
+    },
     "depth_hand_refiner": {
         "label": "depth_hand_refiner",
         "call_function": g_hand_refiner_model.run_model,
@@ -250,9 +263,7 @@ legacy_preprocessors = {
     },
     "instant_id_face_keypoints": {
         "label": "instant_id_face_keypoints",
-        "call_function": functools.partial(
-            g_insight_face_instant_id_model.run_model_instant_id, return_keypoints=True
-        ),
+        "call_function": functools.partial(g_insight_face_instant_id_model.run_model_instant_id, return_keypoints=True),
         "unload_function": None,
         "managed_model": "unknown",
         "model_free": False,
@@ -594,32 +605,6 @@ legacy_preprocessors = {
         "priority": 0,
         "tags": ["Segmentation"],
     },
-    "seg_ofade20k": {
-        "label": "seg_ofade20k",
-        "call_function": oneformer_ade20k,
-        "unload_function": unload_oneformer_ade20k,
-        "managed_model": "model_oneformer_ade20k",
-        "model_free": False,
-        "no_control_mode": False,
-        "resolution": None,
-        "slider_1": None,
-        "slider_2": None,
-        "priority": 100,
-        "tags": ["Segmentation"],
-    },
-    "seg_ofcoco": {
-        "label": "seg_ofcoco",
-        "call_function": oneformer_coco,
-        "unload_function": unload_oneformer_coco,
-        "managed_model": "model_oneformer_coco",
-        "model_free": False,
-        "no_control_mode": False,
-        "resolution": None,
-        "slider_1": None,
-        "slider_2": None,
-        "priority": 0,
-        "tags": ["Segmentation"],
-    },
     "seg_ufade20k": {
         "label": "seg_ufade20k",
         "call_function": uniformer,

extensions-builtin/forge_legacy_preprocessors/requirements.txt

@@ -1,5 +1,8 @@
+addict
 fvcore
 mediapipe
+onnx
 onnxruntime
-opencv-python>=4.8.0
+opencv-python
 svglib
+yapf

extensions-builtin/sd_forge_controlnet/lib_controlnet/controlnet_ui/controlnet_ui_group.py

@@ -14,7 +14,7 @@ from lib_controlnet.controlnet_ui.tool_button import ToolButton
 from lib_controlnet.controlnet_ui.openpose_editor import OpenposeEditor
 from lib_controlnet.controlnet_ui.preset import ControlNetPresetUI, NEW_PRESET
 from lib_controlnet.utils import svg_preprocess, judge_image_type
-from lib_controlnet.enums import InputMode, HiResFixOption
+from lib_controlnet.enums import HiResFixOption
 from lib_controlnet.external_code import UiControlNetUnit
 from lib_controlnet import global_state, external_code
 
@@ -187,7 +187,6 @@ class ControlNetUiGroup:
         self.upload_independent_img_in_img2img = None
         self.image_upload_panel = None
         self.save_detected_map = None
-        self.input_mode = gr.State(InputMode.SIMPLE)
         self.hr_option = None
 
         self.dummy_update_trigger = None
@@ -504,7 +503,6 @@ class ControlNetUiGroup:
         self.preset_panel = ControlNetPresetUI(f"{elem_id_tabname}_{tabname}_")
 
         unit_args = [
-            self.input_mode,
             self.use_preview_as_input,
             self.generated_image,
             self.mask_image,

extensions-builtin/sd_forge_controlnet/lib_controlnet/enums.py

@@ -26,60 +26,3 @@ class HiResFixOption(Enum):
     @property
     def high_res_enabled(self) -> bool:
         return self in (HiResFixOption.BOTH, HiResFixOption.HIGH_RES_ONLY)
-
-
-class StableDiffusionVersion(Enum):
-    """The version family of stable diffusion model."""
-
-    UNKNOWN = 0
-    SD1x = 1
-    SD2x = 2
-    SDXL = 3
-
-    @staticmethod
-    def detect_from_model_name(model_name: str) -> "StableDiffusionVersion":
-        """
-        Based on the model name provided, guess what stable diffusion version it is.
-        This might not be accurate without actually inspect the file content.
-        """
-        if any(f"sd{v}" in model_name.lower() for v in ("14", "15", "16")):
-            return StableDiffusionVersion.SD1x
-
-        if "sd21" in model_name or "2.1" in model_name:
-            return StableDiffusionVersion.SD2x
-
-        if "xl" in model_name.lower():
-            return StableDiffusionVersion.SDXL
-
-        return StableDiffusionVersion.UNKNOWN
-
-    def encoder_block_num(self) -> int:
-        if self in (
-            StableDiffusionVersion.SD1x,
-            StableDiffusionVersion.SD2x,
-            StableDiffusionVersion.UNKNOWN,
-        ):
-            return 12
-        else:
-            return 9  # SDXL
-
-    def controlnet_layer_num(self) -> int:
-        return self.encoder_block_num() + 1
-
-    def is_compatible_with(self, other: "StableDiffusionVersion") -> bool:
-        """Incompatible only when one of version is SDXL and other is not"""
-        return (
-            any(v == StableDiffusionVersion.UNKNOWN for v in [self, other])
-            or sum(v == StableDiffusionVersion.SDXL for v in [self, other]) != 1
-        )
-
-
-class InputMode(Enum):
-    # Single image to a single ControlNet unit.
-    SIMPLE = "simple"
-    # Input is a directory. N generations. Each generation takes 1 input image
-    # from the directory.
-    BATCH = "batch"
-    # Input is a directory. 1 generation. Each generation takes N input image
-    # from the directory.
-    MERGE = "merge"

extensions-builtin/sd_forge_controlnet/lib_controlnet/external_code.py

@@ -6,7 +6,7 @@ from enum import Enum
 import numpy as np
 
 from lib_controlnet.logging import logger
-from lib_controlnet.enums import InputMode, HiResFixOption
+from lib_controlnet.enums import HiResFixOption
 
 
 class ControlMode(Enum):
@@ -159,8 +159,6 @@ class ControlNetUnit:
     """
 
     # ====== UI-only Fields ======
-    # Specifies the input mode for the unit, defaulting to a simple mode.
-    input_mode: InputMode = InputMode.SIMPLE
     # Determines whether to use the preview image as input; defaults to False.
     use_preview_as_input: bool = False
     # Holds the preview image as a NumPy array; defaults to None.

extensions-builtin/sd_forge_controlnet/lib_controlnet/global_state.py

@@ -2,6 +2,7 @@ from modules_forge.shared import controlnet_dir, supported_preprocessors
 from modules import shared
 
 from collections import OrderedDict
+from functools import lru_cache
 import glob
 import os
 
@@ -44,17 +45,13 @@ def update_controlnet_filenames():
         shared.opts.data.get("control_net_models_path", None),
         getattr(shared.cmd_opts, "controlnet_dir", None),
     )
-    extra_paths = (
-        extra_path
-        for extra_path in ext_dirs
-        if extra_path is not None and os.path.exists(extra_path)
-    )
+    extra_paths = (extra_path for extra_path in ext_dirs if extra_path is not None and os.path.exists(extra_path))
 
     for path in [controlnet_dir, *extra_paths]:
         found = get_all_models(path, "name")
         controlnet_filename_dict.update(found)
 
-    controlnet_names = list(controlnet_filename_dict.keys())
+    controlnet_names = sorted(controlnet_filename_dict.keys(), key=lambda mdl: mdl)
 
 
 def get_all_controlnet_names() -> list[str]:
@@ -72,11 +69,7 @@ def get_filtered_controlnet_names(tag: str) -> list[str]:
     for p in filtered_preprocessors.values():
         filename_filters.extend(p.model_filename_filters)
 
-    return [
-        cnet
-        for cnet in controlnet_names
-        if cnet == "None" or any(f.lower() in cnet.lower() for f in filename_filters)
-    ]
+    return [cnet for cnet in controlnet_names if cnet == "None" or any(f.lower() in cnet.lower() for f in filename_filters)]
 
 
 def get_all_preprocessor_tags() -> list[str]:
@@ -91,10 +84,11 @@ def get_preprocessor(name: str):
     return supported_preprocessors[name]
 
 
+@lru_cache(maxsize=1, typed=False)
 def get_sorted_preprocessors() -> dict:
     results = OrderedDict({"None": supported_preprocessors["None"]})
     preprocessors = [p for (k, p) in supported_preprocessors.items() if k != "None"]
-    preprocessors = sorted(preprocessors, key=lambda x: x.name, reverse=True)
+    preprocessors = sorted(preprocessors, key=lambda mdl: mdl.name)
     for p in preprocessors:
         results[p.name] = p
     return results
@@ -111,8 +105,4 @@ def get_filtered_preprocessor_names(tag: str) -> list[str]:
 def get_filtered_preprocessors(tag: str) -> dict:
     if tag == "All":
         return supported_preprocessors
-    return {
-        k: v
-        for (k, v) in get_sorted_preprocessors().items()
-        if tag in v.tags or k == "None"
-    }
+    return {k: v for (k, v) in get_sorted_preprocessors().items() if tag in v.tags or k == "None"}

extensions-builtin/sd_forge_controlnet/preload.py

@@ -2,12 +2,6 @@ def preload(parser):
     parser.add_argument(
         "--controlnet-loglevel",
         default="INFO",
-        choices=["DEBUG", "INFO", "WARNING", "ERROR", "CRITICAL"],
+        choices=("DEBUG", "INFO", "WARNING", "ERROR", "CRITICAL"),
         help="Set the log level (DEBUG, INFO, WARNING, ERROR, CRITICAL)",
     )
-    parser.add_argument(
-        "--controlnet-tracemalloc",
-        default=None,
-        action="store_true",
-        help="Enable memory tracing.",
-    )

extensions-builtin/sd_forge_controlnet/scripts/controlnet.py

@@ -151,11 +151,9 @@ class ControlNetForForgeOfficial(scripts.Script):
         return input_image
 
     def get_input_data(self, p, unit, preprocessor, h, w):
-        logger.info(f"ControlNet Input Mode: {unit.input_mode}")
         resize_mode = external_code.resize_mode_from_value(unit.resize_mode)
         image_list = []
 
-        assert unit.input_mode == external_code.InputMode.SIMPLE
         assert unit.use_preview_as_input is False
 
         a1111_i2i_image = getattr(p, "init_images", [None])[0]

extensions-builtin/xyz/lib_xyz/builtins.py

@@ -1,4 +1,4 @@
-from modules import sd_models, sd_samplers, sd_samplers_kdiffusion, sd_vae, shared
+from modules import sd_models, sd_samplers, sd_schedulers, sd_vae, shared
 
 from .axis_application import (
     apply_checkpoint,
@@ -38,49 +38,16 @@ builtin_options = [
     AxisOptionImg2Img("Image CFG Scale", float, apply_field("image_cfg_scale")),
     AxisOption("Prompt S/R", str, apply_prompt, format_value=format_value),
     AxisOption("Prompt order", str_permutations, apply_order, format_value=format_value_join_list),
-    AxisOptionTxt2Img(
-        "Sampler",
-        str,
-        apply_field("sampler_name"),
-        format_value=format_value,
-        confirm=confirm_samplers,
-        choices=sd_samplers.visible_sampler_names,
-    ),
-    AxisOptionTxt2Img(
-        "Hires sampler",
-        str,
-        apply_field("hr_sampler_name"),
-        confirm=confirm_samplers,
-        choices=sd_samplers.visible_sampler_names,
-    ),
-    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),
-    ),
+    AxisOptionTxt2Img("Sampler", str, apply_field("sampler_name"), format_value=format_value, confirm=confirm_samplers, choices=sd_samplers.visible_sampler_names),
+    AxisOptionTxt2Img("Hires sampler", str, apply_field("hr_sampler_name"), confirm=confirm_samplers, choices=sd_samplers.visible_sampler_names),
+    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("Sigma Churn", float, apply_field("s_churn")),
     AxisOption("Sigma min", float, apply_field("s_tmin")),
     AxisOption("Sigma max", float, apply_field("s_tmax")),
     AxisOption("Sigma noise", float, apply_field("s_noise")),
-    AxisOption(
-        "Schedule type",
-        str,
-        apply_override("k_sched_type"),
-        choices=lambda: list(sd_samplers_kdiffusion.k_diffusion_scheduler),
-    ),
+    AxisOption("Schedule type", str, apply_field("scheduler"), choices=lambda: [x.label for x in sd_schedulers.schedulers]),
     AxisOption("Schedule min sigma", float, apply_override("sigma_min")),
     AxisOption("Schedule max sigma", float, apply_override("sigma_max")),
     AxisOption("Schedule rho", float, apply_override("rho")),
@@ -89,15 +56,7 @@ builtin_options = [
     AxisOption("Denoising", float, apply_field("denoising_strength")),
     AxisOption("Initial noise multiplier", float, apply_field("initial_noise_multiplier")),
     AxisOption("Extra noise", float, apply_override("img2img_extra_noise")),
-    AxisOptionTxt2Img(
-        "Hires upscaler",
-        str,
-        apply_field("hr_upscaler"),
-        choices=lambda: [
-            *shared.latent_upscale_modes,
-            *[x.name for x in shared.sd_upscalers],
-        ],
-    ),
+    AxisOptionTxt2Img("Hires upscaler", str, apply_field("hr_upscaler"), choices=lambda: [*shared.latent_upscale_modes, *[x.name for x in shared.sd_upscalers]]),
     AxisOptionImg2Img("Cond. Image Mask Weight", float, apply_field("inpainting_mask_weight")),
     AxisOption("VAE", str, apply_vae, cost=0.7, choices=lambda: ["None"] + list(sd_vae.vae_dict)),
     AxisOption("Styles", str, apply_styles, choices=lambda: list(shared.prompt_styles.styles)),
@@ -105,32 +64,9 @@ builtin_options = [
     AxisOption("Face restore", str, apply_face_restore, format_value=format_value),
     AxisOption("Token merging ratio", float, apply_override("token_merging_ratio")),
     AxisOption("Token merging ratio high-res", float, apply_override("token_merging_ratio_hr")),
-    AxisOption(
-        "Always discard next-to-last sigma",
-        str,
-        apply_override("always_discard_next_to_last_sigma", boolean=True),
-        choices=boolean_choice(reverse=True),
-    ),
-    AxisOption(
-        "SGM noise multiplier",
-        str,
-        apply_override("sgm_noise_multiplier", boolean=True),
-        choices=boolean_choice(reverse=True),
-    ),
-    AxisOption(
-        "Refiner checkpoint",
-        str,
-        apply_field("refiner_checkpoint"),
-        format_value=format_remove_path,
-        confirm=confirm_checkpoints_or_none,
-        cost=1.0,
-        choices=lambda: ["None"] + sorted(sd_models.checkpoints_list, key=str.casefold),
-    ),
+    AxisOption("Always discard next-to-last sigma", str, apply_override("always_discard_next_to_last_sigma", boolean=True), choices=boolean_choice(reverse=True)),
+    AxisOption("SGM noise multiplier", str, apply_override("sgm_noise_multiplier", boolean=True), choices=boolean_choice(reverse=True)),
+    AxisOption("Refiner checkpoint", str, apply_field("refiner_checkpoint"), format_value=format_remove_path, confirm=confirm_checkpoints_or_none, cost=1.0, choices=lambda: ["None"] + sorted(sd_models.checkpoints_list, key=str.casefold)),
     AxisOption("Refiner switch at", float, apply_field("refiner_switch_at")),
-    AxisOption(
-        "RNG source",
-        str,
-        apply_override("randn_source"),
-        choices=lambda: ["GPU", "CPU", "NV"],
-    ),
+    AxisOption("RNG source", str, apply_override("randn_source"), choices=lambda: ["GPU", "CPU", "NV"]),
 ]

extensions-builtin/xyz/scripts/xyz_grid.py

@@ -540,15 +540,11 @@ class XYZ(scripts.Script):
         # this could be moved to common code, but unlikely to be ever triggered anywhere else
         Image.MAX_IMAGE_PIXELS = None  # disable check in Pillow and rely on check below to allow large custom image sizes
         grid_mp = round(len(xs) * len(ys) * len(zs) * p.width * p.height / 1000000)
-        assert (
-            grid_mp < opts.img_max_size_mp
-        ), f"Error: Resulting grid would be too large ({grid_mp} MPixels) (max configured size is {opts.img_max_size_mp} MPixels)"
+        assert grid_mp < opts.img_max_size_mp, f"Error: Resulting grid would be too large ({grid_mp} MPixels) (max configured size is {opts.img_max_size_mp} MPixels)"
 
         def fix_axis_seeds(axis_opt, axis_list):
             if axis_opt.label in ["Seed", "Var. seed"]:
-                return [
-                    (int(random.randrange(4294967294)) if val is None or val == "" or val == -1 else val) for val in axis_list
-                ]
+                return [(int(random.randrange(4294967294)) if val is None or val == "" or val == -1 else val) for val in axis_list]
             else:
                 return axis_list
 

html/footer.html

@@ -1,11 +1,7 @@
 <div>
         <a href="{api_docs}">API</a>
          • 
-        <a href="https://github.com/AUTOMATIC1111/stable-diffusion-webui">Github</a>
-         • 
-        <a href="https://gradio.app">Gradio</a>
-         • 
-        <a href="#" onclick="showProfile('./internal/profile-startup'); return false;">Startup profile</a>
+        <a href="#" onclick="showProfile('./internal/profile-startup'); return false;">Startup Profile</a>
          • 
         <a href="/" onclick="javascript:gradioApp().getElementById('settings_restart_gradio').click(); return false">Reload UI</a>
 </div>

javascript/ui.js

@@ -329,7 +329,7 @@ onOptionsChanged(function () {
     if (elem && elem.textContent != shorthash) {
         elem.textContent = shorthash;
         elem.title = sd_checkpoint_hash;
-        elem.href = "https://google.com/search?q=" + sd_checkpoint_hash;
+        elem.href = "https://civitai.com/search/models?query=" + sd_checkpoint_hash;
     }
 });
 

ldm_patched/k_diffusion/sampling.py

@@ -6,7 +6,7 @@ import torch
 import torchsde
 from scipy import integrate
 from torch import nn
-from tqdm.auto import tqdm, trange
+from tqdm.auto import trange
 
 from . import utils
 
@@ -26,12 +26,7 @@ def get_sigmas_karras(n, sigma_min, sigma_max, rho=7.0, device="cpu"):
 
 def get_sigmas_exponential(n, sigma_min, sigma_max, device="cpu"):
     """Constructs an exponential noise schedule"""
-    sigmas = torch.linspace(
-        math.log(sigma_max),
-        math.log(sigma_min),
-        n,
-        device=device,
-    ).exp()
+    sigmas = torch.linspace(math.log(sigma_max), math.log(sigma_min), n, device=device).exp()
     return append_zero(sigmas)
 
 
@@ -42,32 +37,24 @@ def get_sigmas_polyexponential(n, sigma_min, sigma_max, rho=1.0, device="cpu"):
     return append_zero(sigmas)
 
 
-def get_sigmas_vp(n, beta_d=19.9, beta_min=0.1, eps_s=1e-3, device="cpu"):
-    """Constructs a continuous VP noise schedule"""
-    t = torch.linspace(1, eps_s, n, device=device)
-    sigmas = torch.sqrt((beta_d * t**2 / 2 + beta_min * t).expm1())
-    return append_zero(sigmas)
-
-
 def to_d(x, sigma, denoised):
     """Converts a denoiser output to a Karras ODE derivative"""
     return (x - denoised) / utils.append_dims(sigma, x.ndim)
 
 
 def get_ancestral_step(sigma_from, sigma_to, eta=1.0):
-    """Calculates the noise level (sigma_down) to step down to and the amount
-    of noise to add (sigma_up) when doing an ancestral sampling step"""
+    """
+    Calculates the noise level (sigma_down) to step down to and the
+    amount of noise to add (sigma_up) when doing an ancestral sampling step
+    """
     if not eta:
         return sigma_to, 0.0
-    sigma_up = min(
-        sigma_to,
-        eta * (sigma_to**2 * (sigma_from**2 - sigma_to**2) / sigma_from**2) ** 0.5,
-    )
+    sigma_up = min(eta * (sigma_to**2 * (sigma_from**2 - sigma_to**2) / sigma_from**2) ** 0.5, sigma_to)
     sigma_down = (sigma_to**2 - sigma_up**2) ** 0.5
     return sigma_down, sigma_up
 
 
-def default_noise_sampler(x):
+def default_noise_sampler(x, seed=None):
     return lambda sigma, sigma_next: torch.randn_like(x)
 
 
@@ -140,18 +127,7 @@ class BrownianTreeNoiseSampler:
 
 
 @torch.no_grad()
-def sample_euler(
-    model,
-    x,
-    sigmas,
-    extra_args=None,
-    callback=None,
-    disable=None,
-    s_churn=0.0,
-    s_tmin=0.0,
-    s_tmax=float("inf"),
-    s_noise=1.0,
-):
+def sample_euler(model, x, sigmas, extra_args=None, callback=None, disable=None, s_churn=0.0, s_tmin=0.0, s_tmax=float("inf"), s_noise=1.0):
     """Implements Algorithm 2 (Euler steps) from Karras et al. (2022)"""
     extra_args = {} if extra_args is None else extra_args
     s_in = x.new_ones([x.shape[0]])
@@ -164,33 +140,14 @@ def sample_euler(
         denoised = model(x, sigma_hat * s_in, **extra_args)
         d = to_d(x, sigma_hat, denoised)
         if callback is not None:
-            callback(
-                {
-                    "x": x,
-                    "i": i,
-                    "sigma": sigmas[i],
-                    "sigma_hat": sigma_hat,
-                    "denoised": denoised,
-                }
-            )
+            callback({"x": x, "i": i, "sigma": sigmas[i], "sigma_hat": sigma_hat, "denoised": denoised})
         dt = sigmas[i + 1] - sigma_hat
-        # Euler method
         x = x + d * dt
     return x
 
 
 @torch.no_grad()
-def sample_euler_ancestral(
-    model,
-    x,
-    sigmas,
-    extra_args=None,
-    callback=None,
-    disable=None,
-    eta=1.0,
-    s_noise=1.0,
-    noise_sampler=None,
-):
+def sample_euler_ancestral(model, x, sigmas, extra_args=None, callback=None, disable=None, eta=1.0, s_noise=1.0, noise_sampler=None):
     """Ancestral sampling with Euler method steps"""
     extra_args = {} if extra_args is None else extra_args
     noise_sampler = default_noise_sampler(x) if noise_sampler is None else noise_sampler
@@ -199,17 +156,8 @@ def sample_euler_ancestral(
         denoised = model(x, sigmas[i] * s_in, **extra_args)
         sigma_down, sigma_up = get_ancestral_step(sigmas[i], sigmas[i + 1], eta=eta)
         if callback is not None:
-            callback(
-                {
-                    "x": x,
-                    "i": i,
-                    "sigma": sigmas[i],
-                    "sigma_hat": sigmas[i],
-                    "denoised": denoised,
-                }
-            )
+            callback({"x": x, "i": i, "sigma": sigmas[i], "sigma_hat": sigmas[i], "denoised": denoised})
         d = to_d(x, sigmas[i], denoised)
-        # Euler method
         dt = sigma_down - sigmas[i]
         x = x + d * dt
         if sigmas[i + 1] > 0:
@@ -218,18 +166,7 @@ def sample_euler_ancestral(
 
 
 @torch.no_grad()
-def sample_heun(
-    model,
-    x,
-    sigmas,
-    extra_args=None,
-    callback=None,
-    disable=None,
-    s_churn=0.0,
-    s_tmin=0.0,
-    s_tmax=float("inf"),
-    s_noise=1.0,
-):
+def sample_heun(model, x, sigmas, extra_args=None, callback=None, disable=None, s_churn=0.0, s_tmin=0.0, s_tmax=float("inf"), s_noise=1.0):
     """Implements Algorithm 2 (Heun steps) from Karras et al. (2022)"""
     extra_args = {} if extra_args is None else extra_args
     s_in = x.new_ones([x.shape[0]])
@@ -242,21 +179,11 @@ def sample_heun(
         denoised = model(x, sigma_hat * s_in, **extra_args)
         d = to_d(x, sigma_hat, denoised)
         if callback is not None:
-            callback(
-                {
-                    "x": x,
-                    "i": i,
-                    "sigma": sigmas[i],
-                    "sigma_hat": sigma_hat,
-                    "denoised": denoised,
-                }
-            )
+            callback({"x": x, "i": i, "sigma": sigmas[i], "sigma_hat": sigma_hat, "denoised": denoised})
         dt = sigmas[i + 1] - sigma_hat
         if sigmas[i + 1] == 0:
-            # Euler method
             x = x + d * dt
         else:
-            # Heun's method
             x_2 = x + d * dt
             denoised_2 = model(x_2, sigmas[i + 1] * s_in, **extra_args)
             d_2 = to_d(x_2, sigmas[i + 1], denoised_2)
@@ -266,18 +193,7 @@ def sample_heun(
 
 
 @torch.no_grad()
-def sample_dpm_2(
-    model,
-    x,
-    sigmas,
-    extra_args=None,
-    callback=None,
-    disable=None,
-    s_churn=0.0,
-    s_tmin=0.0,
-    s_tmax=float("inf"),
-    s_noise=1.0,
-):
+def sample_dpm_2(model, x, sigmas, extra_args=None, callback=None, disable=None, s_churn=0.0, s_tmin=0.0, s_tmax=float("inf"), s_noise=1.0):
     """A sampler inspired by DPM-Solver-2 and Algorithm 2 from Karras et al. (2022)"""
     extra_args = {} if extra_args is None else extra_args
     s_in = x.new_ones([x.shape[0]])
@@ -290,21 +206,11 @@ def sample_dpm_2(
         denoised = model(x, sigma_hat * s_in, **extra_args)
         d = to_d(x, sigma_hat, denoised)
         if callback is not None:
-            callback(
-                {
-                    "x": x,
-                    "i": i,
-                    "sigma": sigmas[i],
-                    "sigma_hat": sigma_hat,
-                    "denoised": denoised,
-                }
-            )
+            callback({"x": x, "i": i, "sigma": sigmas[i], "sigma_hat": sigma_hat, "denoised": denoised})
         if sigmas[i + 1] == 0:
-            # Euler method
             dt = sigmas[i + 1] - sigma_hat
             x = x + d * dt
         else:
-            # DPM-Solver-2
             sigma_mid = sigma_hat.log().lerp(sigmas[i + 1].log(), 0.5).exp()
             dt_1 = sigma_mid - sigma_hat
             dt_2 = sigmas[i + 1] - sigma_hat
@@ -315,54 +221,7 @@ def sample_dpm_2(
     return x
 
 
-@torch.no_grad()
-def sample_dpm_2_ancestral(
-    model,
-    x,
-    sigmas,
-    extra_args=None,
-    callback=None,
-    disable=None,
-    eta=1.0,
-    s_noise=1.0,
-    noise_sampler=None,
-):
-    """Ancestral sampling with DPM-Solver second-order steps"""
-    extra_args = {} if extra_args is None else extra_args
-    noise_sampler = default_noise_sampler(x) if noise_sampler is None else noise_sampler
-    s_in = x.new_ones([x.shape[0]])
-    for i in trange(len(sigmas) - 1, disable=disable):
-        denoised = model(x, sigmas[i] * s_in, **extra_args)
-        sigma_down, sigma_up = get_ancestral_step(sigmas[i], sigmas[i + 1], eta=eta)
-        if callback is not None:
-            callback(
-                {
-                    "x": x,
-                    "i": i,
-                    "sigma": sigmas[i],
-                    "sigma_hat": sigmas[i],
-                    "denoised": denoised,
-                }
-            )
-        d = to_d(x, sigmas[i], denoised)
-        if sigma_down == 0:
-            # Euler method
-            dt = sigma_down - sigmas[i]
-            x = x + d * dt
-        else:
-            # DPM-Solver-2
-            sigma_mid = sigmas[i].log().lerp(sigma_down.log(), 0.5).exp()
-            dt_1 = sigma_mid - sigmas[i]
-            dt_2 = sigma_down - sigmas[i]
-            x_2 = x + d * dt_1
-            denoised_2 = model(x_2, sigma_mid * s_in, **extra_args)
-            d_2 = to_d(x_2, sigma_mid, denoised_2)
-            x = x + d_2 * dt_2
-            x = x + noise_sampler(sigmas[i], sigmas[i + 1]) * s_noise * sigma_up
-    return x
-
-
-def linear_multistep_coeff(order, t, i, j):
+def _linear_multistep_coeff(order, t, i, j):
     if order - 1 > i:
         raise ValueError(f"Order {order} too high for step {i}")
 
@@ -390,17 +249,9 @@ def sample_lms(model, x, sigmas, extra_args=None, callback=None, disable=None, o
         if len(ds) > order:
             ds.pop(0)
         if callback is not None:
-            callback(
-                {
-                    "x": x,
-                    "i": i,
-                    "sigma": sigmas[i],
-                    "sigma_hat": sigmas[i],
-                    "denoised": denoised,
-                }
-            )
+            callback({"x": x, "i": i, "sigma": sigmas[i], "sigma_hat": sigmas[i], "denoised": denoised})
         cur_order = min(i + 1, order)
-        coeffs = [linear_multistep_coeff(cur_order, sigmas_cpu, i, j) for j in range(cur_order)]
+        coeffs = [_linear_multistep_coeff(cur_order, sigmas_cpu, i, j) for j in range(cur_order)]
         x = x + sum(coeff * d for coeff, d in zip(coeffs, reversed(ds)))
     return x
 
@@ -490,285 +341,9 @@ class DPMSolver(nn.Module):
         x_3 = x - self.sigma(t_next) * h.expm1() * eps - self.sigma(t_next) / r2 * (h.expm1() / h - 1) * (eps_r2 - eps)
         return x_3, eps_cache
 
-    def dpm_solver_fast(self, x, t_start, t_end, nfe, eta=0.0, s_noise=1.0, noise_sampler=None):
-        noise_sampler = default_noise_sampler(x) if noise_sampler is None else noise_sampler
-        if not t_end > t_start and eta:
-            raise ValueError("eta must be 0 for reverse sampling")
-
-        m = math.floor(nfe / 3) + 1
-        ts = torch.linspace(t_start, t_end, m + 1, device=x.device)
-
-        if nfe % 3 == 0:
-            orders = [3] * (m - 2) + [2, 1]
-        else:
-            orders = [3] * (m - 1) + [nfe % 3]
-
-        for i in range(len(orders)):
-            eps_cache = {}
-            t, t_next = ts[i], ts[i + 1]
-            if eta:
-                sd, su = get_ancestral_step(self.sigma(t), self.sigma(t_next), eta)
-                t_next_ = torch.minimum(t_end, self.t(sd))
-                su = (self.sigma(t_next) ** 2 - self.sigma(t_next_) ** 2) ** 0.5
-            else:
-                t_next_, su = t_next, 0.0
-
-            eps, eps_cache = self.eps(eps_cache, "eps", x, t)
-            denoised = x - self.sigma(t) * eps
-            if self.info_callback is not None:
-                self.info_callback({"x": x, "i": i, "t": ts[i], "t_up": t, "denoised": denoised})
-
-            if orders[i] == 1:
-                x, eps_cache = self.dpm_solver_1_step(x, t, t_next_, eps_cache=eps_cache)
-            elif orders[i] == 2:
-                x, eps_cache = self.dpm_solver_2_step(x, t, t_next_, eps_cache=eps_cache)
-            else:
-                x, eps_cache = self.dpm_solver_3_step(x, t, t_next_, eps_cache=eps_cache)
-
-            x = x + su * s_noise * noise_sampler(self.sigma(t), self.sigma(t_next))
-
-        return x
-
-    def dpm_solver_adaptive(
-        self,
-        x,
-        t_start,
-        t_end,
-        order=3,
-        rtol=0.05,
-        atol=0.0078,
-        h_init=0.05,
-        pcoeff=0.0,
-        icoeff=1.0,
-        dcoeff=0.0,
-        accept_safety=0.81,
-        eta=0.0,
-        s_noise=1.0,
-        noise_sampler=None,
-    ):
-        noise_sampler = default_noise_sampler(x) if noise_sampler is None else noise_sampler
-        if order not in {2, 3}:
-            raise ValueError("order should be 2 or 3")
-        forward = t_end > t_start
-        if not forward and eta:
-            raise ValueError("eta must be 0 for reverse sampling")
-        h_init = abs(h_init) * (1 if forward else -1)
-        atol = torch.tensor(atol)
-        rtol = torch.tensor(rtol)
-        s = t_start
-        x_prev = x
-        accept = True
-        pid = PIDStepSizeController(h_init, pcoeff, icoeff, dcoeff, 1.5 if eta else order, accept_safety)
-        info = {"steps": 0, "nfe": 0, "n_accept": 0, "n_reject": 0}
-
-        while s < t_end - 1e-5 if forward else s > t_end + 1e-5:
-            eps_cache = {}
-            t = torch.minimum(t_end, s + pid.h) if forward else torch.maximum(t_end, s + pid.h)
-            if eta:
-                sd, su = get_ancestral_step(self.sigma(s), self.sigma(t), eta)
-                t_ = torch.minimum(t_end, self.t(sd))
-                su = (self.sigma(t) ** 2 - self.sigma(t_) ** 2) ** 0.5
-            else:
-                t_, su = t, 0.0
-
-            eps, eps_cache = self.eps(eps_cache, "eps", x, s)
-            denoised = x - self.sigma(s) * eps
-
-            if order == 2:
-                x_low, eps_cache = self.dpm_solver_1_step(x, s, t_, eps_cache=eps_cache)
-                x_high, eps_cache = self.dpm_solver_2_step(x, s, t_, eps_cache=eps_cache)
-            else:
-                x_low, eps_cache = self.dpm_solver_2_step(x, s, t_, r1=1 / 3, eps_cache=eps_cache)
-                x_high, eps_cache = self.dpm_solver_3_step(x, s, t_, eps_cache=eps_cache)
-            delta = torch.maximum(atol, rtol * torch.maximum(x_low.abs(), x_prev.abs()))
-            error = torch.linalg.norm((x_low - x_high) / delta) / x.numel() ** 0.5
-            accept = pid.propose_step(error)
-            if accept:
-                x_prev = x_low
-                x = x_high + su * s_noise * noise_sampler(self.sigma(s), self.sigma(t))
-                s = t
-                info["n_accept"] += 1
-            else:
-                info["n_reject"] += 1
-            info["nfe"] += order
-            info["steps"] += 1
-
-            if self.info_callback is not None:
-                self.info_callback(
-                    {
-                        "x": x,
-                        "i": info["steps"] - 1,
-                        "t": s,
-                        "t_up": s,
-                        "denoised": denoised,
-                        "error": error,
-                        "h": pid.h,
-                        **info,
-                    }
-                )
-
-        return x, info
-
-
-@torch.no_grad()
-def sample_dpm_fast(
-    model,
-    x,
-    sigma_min,
-    sigma_max,
-    n,
-    extra_args=None,
-    callback=None,
-    disable=None,
-    eta=0.0,
-    s_noise=1.0,
-    noise_sampler=None,
-):
-    """DPM-Solver-Fast (fixed step size). See https://arxiv.org/abs/2206.00927"""
-    if sigma_min <= 0 or sigma_max <= 0:
-        raise ValueError("sigma_min and sigma_max must not be 0")
-    with tqdm(total=n, disable=disable) as pbar:
-        dpm_solver = DPMSolver(model, extra_args, eps_callback=pbar.update)
-        if callback is not None:
-            dpm_solver.info_callback = lambda info: callback(
-                {
-                    "sigma": dpm_solver.sigma(info["t"]),
-                    "sigma_hat": dpm_solver.sigma(info["t_up"]),
-                    **info,
-                }
-            )
-        return dpm_solver.dpm_solver_fast(
-            x,
-            dpm_solver.t(torch.tensor(sigma_max)),
-            dpm_solver.t(torch.tensor(sigma_min)),
-            n,
-            eta,
-            s_noise,
-            noise_sampler,
-        )
-
-
-@torch.no_grad()
-def sample_dpm_adaptive(
-    model,
-    x,
-    sigma_min,
-    sigma_max,
-    extra_args=None,
-    callback=None,
-    disable=None,
-    order=3,
-    rtol=0.05,
-    atol=0.0078,
-    h_init=0.05,
-    pcoeff=0.0,
-    icoeff=1.0,
-    dcoeff=0.0,
-    accept_safety=0.81,
-    eta=0.0,
-    s_noise=1.0,
-    noise_sampler=None,
-    return_info=False,
-):
-    """DPM-Solver-12 and 23 (adaptive step size). See https://arxiv.org/abs/2206.00927"""
-    if sigma_min <= 0 or sigma_max <= 0:
-        raise ValueError("sigma_min and sigma_max must not be 0")
-    with tqdm(disable=disable) as pbar:
-        dpm_solver = DPMSolver(model, extra_args, eps_callback=pbar.update)
-        if callback is not None:
-            dpm_solver.info_callback = lambda info: callback(
-                {
-                    "sigma": dpm_solver.sigma(info["t"]),
-                    "sigma_hat": dpm_solver.sigma(info["t_up"]),
-                    **info,
-                }
-            )
-        x, info = dpm_solver.dpm_solver_adaptive(
-            x,
-            dpm_solver.t(torch.tensor(sigma_max)),
-            dpm_solver.t(torch.tensor(sigma_min)),
-            order,
-            rtol,
-            atol,
-            h_init,
-            pcoeff,
-            icoeff,
-            dcoeff,
-            accept_safety,
-            eta,
-            s_noise,
-            noise_sampler,
-        )
-    if return_info:
-        return x, info
-    return x
-
-
-@torch.no_grad()
-def sample_dpmpp_2s_ancestral(
-    model,
-    x,
-    sigmas,
-    extra_args=None,
-    callback=None,
-    disable=None,
-    eta=1.0,
-    s_noise=1.0,
-    noise_sampler=None,
-):
-    """Ancestral sampling with DPM-Solver++(2S) second-order steps"""
-    extra_args = {} if extra_args is None else extra_args
-    noise_sampler = default_noise_sampler(x) if noise_sampler is None else noise_sampler
-    s_in = x.new_ones([x.shape[0]])
-    sigma_fn = lambda t: t.neg().exp()
-    t_fn = lambda sigma: sigma.log().neg()
-
-    for i in trange(len(sigmas) - 1, disable=disable):
-        denoised = model(x, sigmas[i] * s_in, **extra_args)
-        sigma_down, sigma_up = get_ancestral_step(sigmas[i], sigmas[i + 1], eta=eta)
-        if callback is not None:
-            callback(
-                {
-                    "x": x,
-                    "i": i,
-                    "sigma": sigmas[i],
-                    "sigma_hat": sigmas[i],
-                    "denoised": denoised,
-                }
-            )
-        if sigma_down == 0:
-            # Euler method
-            d = to_d(x, sigmas[i], denoised)
-            dt = sigma_down - sigmas[i]
-            x = x + d * dt
-        else:
-            # DPM-Solver++(2S)
-            t, t_next = t_fn(sigmas[i]), t_fn(sigma_down)
-            r = 1 / 2
-            h = t_next - t
-            s = t + r * h
-            x_2 = (sigma_fn(s) / sigma_fn(t)) * x - (-h * r).expm1() * denoised
-            denoised_2 = model(x_2, sigma_fn(s) * s_in, **extra_args)
-            x = (sigma_fn(t_next) / sigma_fn(t)) * x - (-h).expm1() * denoised_2
-        # Noise addition
-        if sigmas[i + 1] > 0:
-            x = x + noise_sampler(sigmas[i], sigmas[i + 1]) * s_noise * sigma_up
-    return x
-
 
 @torch.no_grad()
-def sample_dpmpp_sde(
-    model,
-    x,
-    sigmas,
-    extra_args=None,
-    callback=None,
-    disable=None,
-    eta=1.0,
-    s_noise=1.0,
-    noise_sampler=None,
-    r=1 / 2,
-):
+def sample_dpmpp_sde(model, x, sigmas, extra_args=None, callback=None, disable=None, eta=1.0, s_noise=1.0, noise_sampler=None, r=0.5):
     """DPM-Solver++ (stochastic)"""
     sigma_min, sigma_max = sigmas[sigmas > 0].min(), sigmas.max()
     seed = extra_args.get("seed", None)
@@ -781,35 +356,23 @@ def sample_dpmpp_sde(
     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,
-                }
-            )
+            callback({"x": x, "i": i, "sigma": sigmas[i], "sigma_hat": sigmas[i], "denoised": denoised})
         if sigmas[i + 1] == 0:
-            # Euler method
             d = to_d(x, sigmas[i], denoised)
             dt = sigmas[i + 1] - sigmas[i]
             x = x + d * dt
         else:
-            # DPM-Solver++
             t, t_next = t_fn(sigmas[i]), t_fn(sigmas[i + 1])
             h = t_next - t
             s = t + h * r
             fac = 1 / (2 * r)
 
-            # Step 1
             sd, su = get_ancestral_step(sigma_fn(t), sigma_fn(s), eta)
             s_ = t_fn(sd)
             x_2 = (sigma_fn(s_) / sigma_fn(t)) * x - (t - s_).expm1() * denoised
             x_2 = x_2 + noise_sampler(sigma_fn(t), sigma_fn(s)) * s_noise * su
             denoised_2 = model(x_2, sigma_fn(s) * s_in, **extra_args)
 
-            # Step 2
             sd, su = get_ancestral_step(sigma_fn(t), sigma_fn(t_next), eta)
             t_next_ = t_fn(sd)
             denoised_d = (1 - fac) * denoised + fac * denoised_2
@@ -830,15 +393,7 @@ def sample_dpmpp_2m(model, x, sigmas, extra_args=None, callback=None, disable=No
     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,
-                }
-            )
+            callback({"x": x, "i": i, "sigma": sigmas[i], "sigma_hat": sigmas[i], "denoised": denoised})
         t, t_next = t_fn(sigmas[i]), t_fn(sigmas[i + 1])
         h = t_next - t
         if old_denoised is None or sigmas[i + 1] == 0:
@@ -853,83 +408,7 @@ def sample_dpmpp_2m(model, x, sigmas, extra_args=None, callback=None, disable=No
 
 
 @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:
-            # Denoising step
-            x = denoised
-        else:
-            # DPM-Solver++(2M) SDE
-            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,
-):
+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"""
 
     seed = extra_args.get("seed", None)
@@ -944,17 +423,8 @@ def sample_dpmpp_3m_sde(
     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,
-                }
-            )
+            callback({"x": x, "i": i, "sigma": sigmas[i], "sigma_hat": sigmas[i], "denoised": denoised})
         if sigmas[i + 1] == 0:
-            # Denoising step
             x = denoised
         else:
             t, s = -sigmas[i].log(), -sigmas[i + 1].log()
@@ -988,17 +458,7 @@ def sample_dpmpp_3m_sde(
 
 
 @torch.no_grad()
-def sample_dpmpp_3m_sde_gpu(
-    model,
-    x,
-    sigmas,
-    extra_args=None,
-    callback=None,
-    disable=None,
-    eta=1.0,
-    s_noise=1.0,
-    noise_sampler=None,
-):
+def sample_dpmpp_3m_sde_gpu(model, x, sigmas, extra_args=None, callback=None, disable=None, eta=1.0, s_noise=1.0, noise_sampler=None):
     sigma_min, sigma_max = sigmas[sigmas > 0].min(), sigmas.max()
     noise_sampler = BrownianTreeNoiseSampler(x, sigma_min, sigma_max, seed=extra_args.get("seed", None), cpu=False) if noise_sampler is None else noise_sampler
     return sample_dpmpp_3m_sde(
@@ -1015,47 +475,7 @@ def sample_dpmpp_3m_sde_gpu(
 
 
 @torch.no_grad()
-def sample_dpmpp_2m_sde_gpu(
-    model,
-    x,
-    sigmas,
-    extra_args=None,
-    callback=None,
-    disable=None,
-    eta=1.0,
-    s_noise=1.0,
-    noise_sampler=None,
-    solver_type="midpoint",
-):
-    sigma_min, sigma_max = sigmas[sigmas > 0].min(), sigmas.max()
-    noise_sampler = BrownianTreeNoiseSampler(x, sigma_min, sigma_max, seed=extra_args.get("seed", None), cpu=False) if noise_sampler is None else noise_sampler
-    return sample_dpmpp_2m_sde(
-        model,
-        x,
-        sigmas,
-        extra_args=extra_args,
-        callback=callback,
-        disable=disable,
-        eta=eta,
-        s_noise=s_noise,
-        noise_sampler=noise_sampler,
-        solver_type=solver_type,
-    )
-
-
-@torch.no_grad()
-def sample_dpmpp_sde_gpu(
-    model,
-    x,
-    sigmas,
-    extra_args=None,
-    callback=None,
-    disable=None,
-    eta=1.0,
-    s_noise=1.0,
-    noise_sampler=None,
-    r=1 / 2,
-):
+def sample_dpmpp_sde_gpu(model, x, sigmas, extra_args=None, callback=None, disable=None, eta=1.0, s_noise=1.0, noise_sampler=None, r=0.5):
     sigma_min, sigma_max = sigmas[sigmas > 0].min(), sigmas.max()
     noise_sampler = BrownianTreeNoiseSampler(x, sigma_min, sigma_max, seed=extra_args.get("seed", None), cpu=False) if noise_sampler is None else noise_sampler
     return sample_dpmpp_sde(
@@ -1083,16 +503,7 @@ def DDPMSampler_step(x, sigma, sigma_prev, noise, noise_sampler):
     return mu
 
 
-def generic_step_sampler(
-    model,
-    x,
-    sigmas,
-    extra_args=None,
-    callback=None,
-    disable=None,
-    noise_sampler=None,
-    step_function=None,
-):
+def generic_step_sampler(model, x, sigmas, extra_args=None, callback=None, disable=None, noise_sampler=None, step_function=None):
     extra_args = {} if extra_args is None else extra_args
     noise_sampler = default_noise_sampler(x) if noise_sampler is None else noise_sampler
     s_in = x.new_ones([x.shape[0]])
@@ -1100,15 +511,7 @@ def generic_step_sampler(
     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,
-                }
-            )
+            callback({"x": x, "i": i, "sigma": sigmas[i], "sigma_hat": sigmas[i], "denoised": denoised})
         x = step_function(
             x / torch.sqrt(1.0 + sigmas[i] ** 2.0),
             sigmas[i],
@@ -1124,101 +527,3 @@ def generic_step_sampler(
 @torch.no_grad()
 def sample_ddpm(model, x, sigmas, extra_args=None, callback=None, disable=None, noise_sampler=None):
     return generic_step_sampler(model, x, sigmas, extra_args, callback, disable, noise_sampler, DDPMSampler_step)
-
-
-@torch.no_grad()
-def sample_lcm(model, x, sigmas, extra_args=None, callback=None, disable=None, noise_sampler=None):
-    extra_args = {} if extra_args is None else extra_args
-    noise_sampler = default_noise_sampler(x) if noise_sampler is None else noise_sampler
-    s_in = x.new_ones([x.shape[0]])
-    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,
-                }
-            )
-
-        x = denoised
-        if sigmas[i + 1] > 0:
-            x += sigmas[i + 1] * noise_sampler(sigmas[i], sigmas[i + 1])
-    return x
-
-
-@torch.no_grad()
-def sample_heunpp2(
-    model,
-    x,
-    sigmas,
-    extra_args=None,
-    callback=None,
-    disable=None,
-    s_churn=0.0,
-    s_tmin=0.0,
-    s_tmax=float("inf"),
-    s_noise=1.0,
-):
-    # From MIT licensed: https://github.com/Carzit/sd-webui-samplers-scheduler/
-    extra_args = {} if extra_args is None else extra_args
-    s_in = x.new_ones([x.shape[0]])
-    s_end = sigmas[-1]
-    for i in trange(len(sigmas) - 1, disable=disable):
-        gamma = min(s_churn / (len(sigmas) - 1), 2**0.5 - 1) if s_tmin <= sigmas[i] <= s_tmax else 0.0
-        eps = torch.randn_like(x) * s_noise
-        sigma_hat = sigmas[i] * (gamma + 1)
-        if gamma > 0:
-            x = x + eps * (sigma_hat**2 - sigmas[i] ** 2) ** 0.5
-        denoised = model(x, sigma_hat * s_in, **extra_args)
-        d = to_d(x, sigma_hat, denoised)
-        if callback is not None:
-            callback(
-                {
-                    "x": x,
-                    "i": i,
-                    "sigma": sigmas[i],
-                    "sigma_hat": sigma_hat,
-                    "denoised": denoised,
-                }
-            )
-        dt = sigmas[i + 1] - sigma_hat
-        if sigmas[i + 1] == s_end:
-            # Euler method
-            x = x + d * dt
-        elif sigmas[i + 2] == s_end:
-            # Heun's method
-            x_2 = x + d * dt
-            denoised_2 = model(x_2, sigmas[i + 1] * s_in, **extra_args)
-            d_2 = to_d(x_2, sigmas[i + 1], denoised_2)
-
-            w = 2 * sigmas[0]
-            w2 = sigmas[i + 1] / w
-            w1 = 1 - w2
-
-            d_prime = d * w1 + d_2 * w2
-
-            x = x + d_prime * dt
-
-        else:
-            # Heun++
-            x_2 = x + d * dt
-            denoised_2 = model(x_2, sigmas[i + 1] * s_in, **extra_args)
-            d_2 = to_d(x_2, sigmas[i + 1], denoised_2)
-            dt_2 = sigmas[i + 2] - sigmas[i + 1]
-
-            x_3 = x_2 + d_2 * dt_2
-            denoised_3 = model(x_3, sigmas[i + 2] * s_in, **extra_args)
-            d_3 = to_d(x_3, sigmas[i + 2], denoised_3)
-
-            w = 3 * sigmas[0]
-            w2 = sigmas[i + 1] / w
-            w3 = sigmas[i + 2] / w
-            w1 = 1 - w2 - w3
-
-            d_prime = w1 * d + w2 * d_2 + w3 * d_3
-            x = x + d_prime * dt
-    return x

ldm_patched/ldm/modules/attention.py

@@ -16,6 +16,7 @@ from torch import einsum, nn
 
 from .diffusionmodules.util import AlphaBlender, checkpoint, timestep_embedding
 
+isSage2 = False
 if model_management.sage_enabled():
     import importlib.metadata
     from sageattention import sageattn
@@ -30,9 +31,7 @@ if model_management.flash_enabled():
     from flash_attn import flash_attn_func
 
     @torch.library.custom_op("flash_attention::flash_attn", mutates_args=())
-    def flash_attn_wrapper(
-        q: torch.Tensor, k: torch.Tensor, v: torch.Tensor, dropout_p: float = 0.0, causal: bool = False
-    ) -> torch.Tensor:
+    def flash_attn_wrapper(q: torch.Tensor, k: torch.Tensor, v: torch.Tensor, dropout_p: float = 0.0, causal: bool = False) -> torch.Tensor:
         return flash_attn_func(q, k, v, dropout_p=dropout_p, causal=causal)
 
     @flash_attn_wrapper.register_fake
@@ -41,7 +40,7 @@ if model_management.flash_enabled():
 
 
 import ldm_patched.modules.ops
-from ldm_patched.modules.args_parser import args
+from ldm_patched.modules.args_parser import args, SageAttentionAPIs
 
 ops = ldm_patched.modules.ops.disable_weight_init
 
@@ -104,11 +103,7 @@ class FeedForward(nn.Module):
         super().__init__()
         inner_dim = int(dim * mult)
         dim_out = default(dim_out, dim)
-        project_in = (
-            nn.Sequential(operations.Linear(dim, inner_dim, dtype=dtype, device=device), nn.GELU())
-            if not glu
-            else GEGLU(dim, inner_dim, dtype=dtype, device=device, operations=operations)
-        )
+        project_in = nn.Sequential(operations.Linear(dim, inner_dim, dtype=dtype, device=device), nn.GELU()) if not glu else GEGLU(dim, inner_dim, dtype=dtype, device=device, operations=operations)
 
         self.net = nn.Sequential(
             project_in,
@@ -138,11 +133,7 @@ def attention_basic(q, k, v, heads, mask=None):
 
     h = heads
     q, k, v = map(
-        lambda t: t.unsqueeze(3)
-        .reshape(b, -1, heads, dim_head)
-        .permute(0, 2, 1, 3)
-        .reshape(b * heads, -1, dim_head)
-        .contiguous(),
+        lambda t: t.unsqueeze(3).reshape(b, -1, heads, dim_head).permute(0, 2, 1, 3).reshape(b * heads, -1, dim_head).contiguous(),
         (q, k, v),
     )
 
@@ -214,6 +205,18 @@ def attention_xformers(q, k, v, heads, mask=None):
     return out.unsqueeze(0).reshape(b, heads, -1, dim_head).transpose(1, 2).reshape(b, -1, heads * dim_head)
 
 
+if isSage2 and args.sageattn2_api is not SageAttentionAPIs.Automatic:
+    from functools import partial
+    from sageattention import sageattn_qk_int8_pv_fp16_triton, sageattn_qk_int8_pv_fp16_cuda, sageattn_qk_int8_pv_fp8_cuda
+
+    if args.sageattn2_api is SageAttentionAPIs.Triton16:
+        sageattn = sageattn_qk_int8_pv_fp16_triton
+    if args.sageattn2_api is SageAttentionAPIs.CUDA16:
+        sageattn = partial(sageattn_qk_int8_pv_fp16_cuda, qk_quant_gran="per_warp", pv_accum_dtype="fp16+fp32")
+    if args.sageattn2_api is SageAttentionAPIs.CUDA8:
+        sageattn = partial(sageattn_qk_int8_pv_fp8_cuda, qk_quant_gran="per_warp", pv_accum_dtype="fp16+fp32")
+
+
 def attention_sage(q, k, v, heads, mask=None):
     """
     Reference: https://github.com/comfyanonymous/ComfyUI/blob/v0.3.13/comfy/ldm/modules/attention.py#L472
@@ -234,13 +237,9 @@ def attention_sage(q, k, v, heads, mask=None):
         (q, k, v),
     )
 
-    if mask is not None:
-        if mask.ndim == 2:
-            mask = mask.unsqueeze(0)
-        if mask.ndim == 3:
-            mask = mask.unsqueeze(1)
+    assert mask is None
 
-    out = sageattn(q, k, v, attn_mask=mask, is_causal=False, tensor_layout="NHD")
+    out = sageattn(q, k, v, is_causal=False, tensor_layout="NHD")
     return out.reshape(b, -1, heads * dim_head)
 
 
@@ -285,7 +284,16 @@ def attention_flash(q, k, v, heads, mask=None, attn_precision=None, skip_reshape
 
 
 if model_management.sage_enabled():
-    print("Using sage attention")
+    match args.sageattn2_api:
+        case SageAttentionAPIs.Automatic:
+            print("Using sage attention")
+        case SageAttentionAPIs.Triton16:
+            print("Using sage attention (Triton fp16)")
+        case SageAttentionAPIs.CUDA16:
+            print("Using sage attention (CUDA fp16)")
+        case SageAttentionAPIs.CUDA8:
+            print("Using sage attention (CUDA fp8)")
+
     optimized_attention = attention_sage
 elif model_management.flash_enabled():
     print("Using flash attention")

ldm_patched/modules/args_parser.py

@@ -2,6 +2,26 @@
 
 
 import argparse
+import enum
+
+
+class EnumAction(argparse.Action):
+    """Argparse `action` for handling Enum"""
+
+    def __init__(self, **kwargs):
+        enum_type = kwargs.pop("type", None)
+        assert issubclass(enum_type, enum.Enum)
+
+        choices = tuple(e.value for e in enum_type)
+        kwargs.setdefault("choices", choices)
+        kwargs.setdefault("metavar", f"[{','.join(list(choices))}]")
+
+        super(EnumAction, self).__init__(**kwargs)
+        self._enum = enum_type
+
+    def __call__(self, parser, namespace, values, option_string=None):
+        value = self._enum(values)
+        setattr(namespace, self.dest, value)
 
 
 parser = argparse.ArgumentParser()
@@ -58,4 +78,15 @@ parser.add_argument("--pin-shared-memory", action="store_true")
 
 parser.add_argument("--fast-fp16", action="store_true")
 
+
+class SageAttentionAPIs(enum.Enum):
+    Automatic = "auto"
+    Triton16 = "triton-fp16"
+    CUDA16 = "cuda-fp16"
+    CUDA8 = "cuda-fp8"
+
+
+parser.add_argument("--sageattn2-api", type=SageAttentionAPIs, default=SageAttentionAPIs.Automatic, action=EnumAction)
+
+
 args = parser.parse_args([])

modules/api/api.py

@@ -34,6 +34,7 @@ from modules import (
     sd_hijack,
     sd_models,
     sd_samplers,
+    sd_schedulers,
     shared_items,
     ui,
 )
@@ -246,6 +247,7 @@ class Api:
         self.add_api_route("/sdapi/v1/options", self.set_config, methods=["POST"])
         self.add_api_route("/sdapi/v1/cmd-flags", self.get_cmd_flags, methods=["GET"], response_model=models.FlagsModel)
         self.add_api_route("/sdapi/v1/samplers", self.get_samplers, methods=["GET"], response_model=list[models.SamplerItem])
+        self.add_api_route("/sdapi/v1/schedulers", self.get_schedulers, methods=["GET"], response_model=list[models.SchedulerItem])
         self.add_api_route("/sdapi/v1/upscalers", self.get_upscalers, methods=["GET"], response_model=list[models.UpscalerItem])
         self.add_api_route("/sdapi/v1/latent-upscale-modes", self.get_latent_upscale_modes, methods=["GET"], response_model=list[models.LatentUpscalerModeItem])
         self.add_api_route("/sdapi/v1/sd-models", self.get_sd_models, methods=["GET"], response_model=list[models.SDModelItem])
@@ -684,6 +686,18 @@ class Api:
     def get_samplers(self):
         return [{"name": sampler[0], "aliases": sampler[2], "options": sampler[3]} for sampler in sd_samplers.all_samplers]
 
+    def get_schedulers(self):
+        return [
+            {
+                "name": scheduler.name,
+                "label": scheduler.label,
+                "aliases": scheduler.aliases,
+                "default_rho": scheduler.default_rho,
+                "need_inner_model": scheduler.need_inner_model,
+            }
+            for scheduler in sd_schedulers.schedulers
+        ]
+
     def get_upscalers(self):
         return [
             {

modules/api/models.py

@@ -290,6 +290,14 @@ class SamplerItem(BaseModel):
     options: dict[str, str] = Field(title="Options")
 
 
+class SchedulerItem(BaseModel):
+    name: str = Field(title="Name")
+    label: str = Field(title="Label")
+    aliases: Optional[list[str]] = Field(title="Aliases")
+    default_rho: Optional[float] = Field(title="Default Rho")
+    need_inner_model: Optional[bool] = Field(title="Needs Inner Model")
+
+
 class UpscalerItem(BaseModel):
     name: str = Field(title="Name")
     model_name: Optional[str] = Field(title="Model Name")

modules/cmd_args.py

@@ -95,6 +95,7 @@ parser.add_argument("--disable-extra-extensions", action="store_true", help="pre
 parser.add_argument("--forge-ref-a1111-home", type=Path, help="Look for models in an existing A1111 checkout's path", default=None)
 parser.add_argument("--controlnet-dir", type=Path, help="Path to directory with ControlNet models", default=None)
 parser.add_argument("--controlnet-preprocessor-models-dir", type=Path, help="Path to directory with annotator model directories", default=None)
+parser.add_argument("--adv-samplers", action="store_true", help='show the "sampler parameters" advanced settings')
 parser.add_argument("--fps", type=int, default=30, help="refresh rate for threads")
 
 pkm = parser.add_mutually_exclusive_group()

modules/esrgan_model.py

@@ -1,38 +1,46 @@
-from modules import modelloader, devices, errors
+import re
+from functools import lru_cache
+
+from PIL import Image
+
+from modules import devices, errors, modelloader
 from modules.shared import opts
 from modules.upscaler import Upscaler, UpscalerData
 from modules.upscaler_utils import upscale_with_model
 from modules_forge.forge_util import prepare_free_memory
-from functools import lru_cache
-
-
-URL = "https://github.com/cszn/KAIR/releases/download/v1.0/ESRGAN.pth"
 
 
 class UpscalerESRGAN(Upscaler):
-
     def __init__(self, dirname: str):
+        self.user_path = dirname
+        self.model_path = dirname
+        super().__init__(True)
+
         self.name = "ESRGAN"
-        self.model_url = URL
+        self.model_url = "https://github.com/cszn/KAIR/releases/download/v1.0/ESRGAN.pth"
         self.model_name = "ESRGAN"
         self.scalers = []
-        self.user_path = dirname
-        super().__init__()
+
         model_paths = self.find_models(ext_filter=[".pt", ".pth", ".safetensors"])
-        scalers = []
         if len(model_paths) == 0:
             scaler_data = UpscalerData(self.model_name, self.model_url, self, 4)
-            scalers.append(scaler_data)
+            self.scalers.append(scaler_data)
+
         for file in model_paths:
             if file.startswith("http"):
                 name = self.model_name
             else:
                 name = modelloader.friendly_name(file)
 
-            scaler_data = UpscalerData(name, file, self, 4)
+            if match := re.search(r"(\d)[xX]|[xX](\d)", name):
+                scale = int(match.group(1) or match.group(2))
+            else:
+                scale = 4
+
+            scaler_data = UpscalerData(name, file, self, scale)
             self.scalers.append(scaler_data)
 
-    def do_upscale(self, img, selected_model):
+    def do_upscale(self, img: Image.Image, selected_model: str):
         prepare_free_memory()
         try:
             model = self.load_model(selected_model)
@@ -40,8 +48,8 @@ class UpscalerESRGAN(Upscaler):
             errors.report(f"Unable to load {selected_model}", exc_info=True)
             return img
         return upscale_with_model(
-            model,
-            img,
+            model=model,
+            img=img,
             tile_size=opts.ESRGAN_tile,
             tile_overlap=opts.ESRGAN_tile_overlap,
         )
@@ -57,10 +65,6 @@ class UpscalerESRGAN(Upscaler):
                 file_name=path.rsplit("/", 1)[-1],
             )
 
-        model = modelloader.load_spandrel_model(
-            filename,
-            device=("cpu" if devices.device_esrgan.type == "mps" else None),
-            expected_architecture="ESRGAN",
-        )
+        model = modelloader.load_spandrel_model(filename, device="cpu")
         model.to(devices.device_esrgan)
         return model

modules/images.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 
 import datetime
+import functools
 
 import pytz
 import io
@@ -22,14 +23,12 @@ from modules import sd_samplers, shared, script_callbacks, errors
 from modules.paths_internal import roboto_ttf_file
 from modules.shared import opts
 
-LANCZOS = getattr(Image, "LANCZOS", Image.Resampling.LANCZOS)
+LANCZOS = Image.LANCZOS if hasattr(Image, "LANCZOS") else Image.Resampling.LANCZOS
+NEAREST = Image.LANCZOS if hasattr(Image, "NEAREST") else Image.Resampling.NEAREST
 
 
 def get_font(fontsize: int):
-    try:
-        return ImageFont.truetype(opts.font or roboto_ttf_file, fontsize)
-    except Exception:
-        return ImageFont.truetype(roboto_ttf_file, fontsize)
+    return ImageFont.truetype(roboto_ttf_file, fontsize)
 
 
 def image_grid(imgs, batch_size=1, rows=None):
@@ -347,6 +346,32 @@ def sanitize_filename_part(text, replace_spaces=True):
     return text
 
 
+@functools.lru_cache(maxsize=10, 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":
+        config = sd_samplers.find_sampler_config(sampler_name)
+        scheduler_name = config.options.get("scheduler", "Automatic")
+    return scheduler_name.capitalize()
+
+
+@functools.lru_cache(maxsize=10, 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)}"
+
+
+def get_sampler_scheduler(p, sampler: str):
+    """Returns '{Sampler} {Scheduler}' / '{Scheduler}' / 'NOTHING_AND_SKIP_PREVIOUS_TEXT'"""
+    if hasattr(p, "scheduler") and hasattr(p, "sampler_name"):
+        if sampler:
+            sampler_scheduler = get_sampler_scheduler_str(p.sampler_name, p.scheduler)
+        else:
+            sampler_scheduler = get_scheduler_str(p.sampler_name, p.scheduler)
+        return sanitize_filename_part(sampler_scheduler, replace_spaces=False)
+    return NOTHING_AND_SKIP_PREVIOUS_TEXT
+
+
 class FilenameGenerator:
     replacements = {
         "seed": lambda self: self.seed if self.seed is not None else "",
@@ -358,6 +383,8 @@ class FilenameGenerator:
         "height": lambda self: self.image.height,
         "styles": lambda self: self.p and sanitize_filename_part(", ".join([style for style in self.p.styles if not style == "None"]) or "None", replace_spaces=False),
         "sampler": lambda self: self.p and sanitize_filename_part(self.p.sampler_name, replace_spaces=False),
+        "sampler_scheduler": lambda self: self.p and get_sampler_scheduler(self.p, True),
+        "scheduler": lambda self: self.p and get_sampler_scheduler(self.p, False),
         "model_hash": lambda self: getattr(self.p, "sd_model_hash", shared.sd_model.sd_model_hash),
         "model_name": lambda self: sanitize_filename_part(shared.sd_model.sd_checkpoint_info.name_for_extra, replace_spaces=False),
         "date": lambda self: datetime.datetime.now().strftime("%Y-%m-%d"),

modules/img2img.py

@@ -160,8 +160,6 @@ def img2img_function(
     inpaint_color_sketch_orig,
     init_img_inpaint,
     init_mask_inpaint,
-    steps: int,
-    sampler_name: str,
     mask_blur: int,
     mask_alpha: float,
     inpainting_fill: int,
@@ -235,10 +233,8 @@ def img2img_function(
         prompt=prompt,
         negative_prompt=negative_prompt,
         styles=prompt_styles,
-        sampler_name=sampler_name,
         batch_size=batch_size,
         n_iter=n_iter,
-        steps=steps,
         cfg_scale=cfg_scale,
         width=width,
         height=height,
@@ -300,8 +296,6 @@ def img2img(
     inpaint_color_sketch_orig,
     init_img_inpaint,
     init_mask_inpaint,
-    steps: int,
-    sampler_name: str,
     mask_blur: int,
     mask_alpha: float,
     inpainting_fill: int,
@@ -342,8 +336,6 @@ def img2img(
         inpaint_color_sketch_orig,
         init_img_inpaint,
         init_mask_inpaint,
-        steps,
-        sampler_name,
         mask_blur,
         mask_alpha,
         inpainting_fill,

modules/infotext_utils.py

@@ -299,6 +299,9 @@ Steps: 20, Sampler: Euler a, CFG scale: 7, Seed: 965400086, Size: 512x512, Model
     if "Hires sampler" not in res:
         res["Hires sampler"] = "Use same sampler"
 
+    if "Hires schedule type" not in res:
+        res["Hires schedule type"] = "Use same scheduler"
+
     if "Hires checkpoint" not in res:
         res["Hires checkpoint"] = "Use same checkpoint"
 

modules/launch_utils.py

@@ -336,12 +336,10 @@ def prepare_environment():
         startup_timer.record("install requirements")
 
     if not is_installed("insightface"):
-        run(
-            f'"{python}" -m pip install {insightface_package} --no-deps',
-            desc="Installing insightface",
-            errdesc="Failed to install insightface; please manually install C++ build tools first",
-            live=False,
-        )
+        try:
+            run_pip(f"install --no-deps {insightface_package}", "insightface")
+        except RuntimeError:
+            print("Failed to install insightface; please manually install C++ build tools first")
 
     if not args.skip_install:
         run_extensions_installers(settings_file=args.ui_settings_file)

modules/modelloader.py

@@ -1,29 +1,23 @@
 from __future__ import annotations
 
-import importlib
 import logging
 import os
+import os.path
 from urllib.parse import urlparse
 
-import torch
 import spandrel
 import spandrel_extra_arches
+import torch
 
 from modules import shared
-from modules.upscaler import Upscaler, UpscalerLanczos, UpscalerNearest, UpscalerNone
-
+from modules.errors import display
+from modules.upscaler import UpscalerLanczos, UpscalerNearest, UpscalerNone
 
 spandrel_extra_arches.install()
 logger = logging.getLogger(__name__)
 
 
-def load_file_from_url(
-    url: str,
-    *,
-    model_dir: str,
-    progress: bool = True,
-    file_name: str | None = None,
-) -> str:
+def load_file_from_url(url: str, *, model_dir: str, progress: bool = True, file_name: str | None = None) -> str:
     """
     Download a file from `url` into `model_dir`, using the file present if possible.
     Returns the path to the downloaded file.
@@ -36,6 +30,7 @@ def load_file_from_url(
     if not os.path.exists(cached_file):
         print(f'Downloading: "{url}" to {cached_file}\n')
         from torch.hub import download_url_to_file
+
         download_url_to_file(url, cached_file, progress=progress)
     return cached_file
 
@@ -59,44 +54,40 @@ def load_models(
 
     @return: A list of paths containing the desired model(s)
     """
-    output = []
+    output: set[str] = set()
 
     try:
-        places = []
-
-        if command_path is not None and command_path != model_path:
-            pretrained_path = os.path.join(command_path, "experiments", "pretrained_models")
-            if os.path.exists(pretrained_path):
-                print(f"Appending path: {pretrained_path}")
-                places.append(pretrained_path)
-            elif os.path.exists(command_path):
-                places.append(command_path)
+        folders = [model_path]
 
-        places.append(model_path)
+        if command_path != model_path and command_path is not None:
+            if os.path.isdir(command_path):
+                folders.append(command_path)
+            elif os.path.isfile(command_path):
+                output.add(command_path)
 
-        for place in places:
+        for place in folders:
             for full_path in shared.walk_files(place, allowed_extensions=ext_filter):
                 if os.path.islink(full_path) and not os.path.exists(full_path):
                     print(f"Skipping broken symlink: {full_path}")
                     continue
                 if ext_blacklist is not None and any(full_path.endswith(x) for x in ext_blacklist):
                     continue
-                if full_path not in output:
-                    output.append(full_path)
+                if os.path.isfile(full_path):
+                    output.add(full_path)
 
         if model_url is not None and len(output) == 0:
             if download_name is not None:
-                output.append(load_file_from_url(model_url, model_dir=places[0], file_name=download_name))
+                output.add(load_file_from_url(model_url, model_dir=folders[0], file_name=download_name))
             else:
-                output.append(model_url)
+                output.add(model_url)
 
-    except Exception:
-        pass
+    except Exception as e:
+        display(e, "load_models")
 
-    return output
+    return sorted(output, key=lambda mdl: mdl.lower())
 
 
-def friendly_name(file: str):
+def friendly_name(file: str) -> str:
     if file.startswith("http"):
         file = urlparse(file).path
 
@@ -106,39 +97,19 @@ def friendly_name(file: str):
 
 
 def load_upscalers():
-    # We can only do this 'magic' method to dynamically load upscalers if they are referenced,
-    # so we'll try to import the esrgan_model.py file before looking in __subclasses__
-    importlib.import_module("modules.esrgan_model")
-    all_upscalers = []
-    commandline_options = vars(shared.cmd_opts)
-
-    # some of upscaler classes will not go away after reloading their modules, and we'll end
-    # up with two copies of those classes. The newest copy will always be the last in the list,
-    # so we go from end to beginning and ignore duplicates
-    used_classes = {}
-    for cls in reversed(Upscaler.__subclasses__()):
-        classname = str(cls)
-        if classname not in used_classes:
-            used_classes[classname] = cls
-
-    for cls in reversed(used_classes.values()):
-        name = cls.__name__
-        cmd_name = f"{name.lower().replace('upscaler', '')}_models_path"
-        commandline_model_path = commandline_options.get(cmd_name, None)
-        scaler = cls(commandline_model_path)
-        scaler.user_path = commandline_model_path
-        scaler.model_download_path = commandline_model_path or scaler.model_path
-        all_upscalers += scaler.scalers
-
-    shared.sd_upscalers = sorted(
-        all_upscalers,
-        # Special case for UpscalerNone keeps it at the beginning of the list.
-        key=lambda x: (
-            ""
-            if isinstance(x.scaler, (UpscalerNone, UpscalerLanczos, UpscalerNearest))
-            else x.name.lower()
-        ),
-    )
+    from modules.esrgan_model import UpscalerESRGAN
+
+    commandline_model_path = shared.cmd_opts.esrgan_models_path
+    upscaler = UpscalerESRGAN(commandline_model_path)
+    upscaler.user_path = commandline_model_path
+    upscaler.model_download_path = commandline_model_path or upscaler.model_path
+
+    shared.sd_upscalers = [
+        *UpscalerNone().scalers,
+        *UpscalerLanczos().scalers,
+        *UpscalerNearest().scalers,
+        *sorted(upscaler.scalers, key=lambda s: s.name.lower()),
+    ]
 
 
 def load_spandrel_model(
@@ -164,10 +135,7 @@ def load_spandrel_model(
     if dtype:
         model_descriptor.model.to(dtype=dtype)
 
-    logger.debug(
-        "Loaded %s from %s (device=%s, half=%s, dtype=%s)",
-        arch, path, device, half, dtype,
-    )
+    logger.debug("Loaded %s from %s (device=%s, half=%s, dtype=%s)", arch, path, device, half, dtype)
 
     model_descriptor.model.eval()
     return model_descriptor

modules/options.py

@@ -11,7 +11,7 @@ from modules.paths_internal import script_path
 
 
 class OptionInfo:
-    def __init__(self, default=None, label="", component=None, component_args=None, onchange=None, section=None, refresh=None, comment_before='', comment_after='', infotext=None, restrict_api=False, category_id=None):
+    def __init__(self, default=None, label="", component=None, component_args=None, onchange=None, section=None, refresh=None, comment_before="", comment_after="", infotext=None, restrict_api=False, category_id=None):
         self.default = default
         self.label = label
         self.component = component
@@ -60,7 +60,14 @@ class OptionInfo:
 
 class OptionHTML(OptionInfo):
     def __init__(self, text):
-        super().__init__(str(text).strip(), label='', component=lambda **kwargs: gr.HTML(elem_classes="settings-info", **kwargs))
+        super().__init__(str(text).strip(), label="", component=lambda **kwargs: gr.HTML(elem_classes="settings-info", **kwargs))
+
+        self.do_not_save = True
+
+
+class OptionDiv(OptionInfo):
+    def __init__(self):
+        super().__init__("", label="", component=lambda **kwargs: gr.HTML(elem_classes="settings-div", **kwargs))
 
         self.do_not_save = True
 
@@ -104,19 +111,19 @@ class Options:
 
                 # Restrict component arguments
                 comp_args = info.component_args if info else None
-                if isinstance(comp_args, dict) and comp_args.get('visible', True) is False:
+                if isinstance(comp_args, dict) and comp_args.get("visible", True) is False:
                     raise RuntimeError(f"not possible to set '{key}' because it is restricted")
 
                 # Check that this section isn't frozen
                 if cmd_opts.freeze_settings_in_sections is not None:
-                    frozen_sections = list(map(str.strip, cmd_opts.freeze_settings_in_sections.split(','))) # Trim whitespace from section names
+                    frozen_sections = list(map(str.strip, cmd_opts.freeze_settings_in_sections.split(",")))  # Trim whitespace from section names
                     section_key = info.section[0]
                     section_name = info.section[1]
                     assert section_key not in frozen_sections, f"not possible to set '{key}' because settings in section '{section_name}' ({section_key}) are frozen with --freeze-settings-in-sections"
 
                 # Check that this section of the settings isn't frozen
                 if cmd_opts.freeze_specific_settings is not None:
-                    frozen_keys = list(map(str.strip, cmd_opts.freeze_specific_settings.split(','))) # Trim whitespace from setting keys
+                    frozen_keys = list(map(str.strip, cmd_opts.freeze_specific_settings.split(",")))  # Trim whitespace from setting keys
                     assert key not in frozen_keys, f"not possible to set '{key}' because this setting is frozen with --freeze-specific-settings"
 
                 # Check shorthand option which disables editing options in "saving-paths"
@@ -201,20 +208,20 @@ class Options:
         except FileNotFoundError:
             self.data = {}
         except Exception:
-            errors.report(f'\nCould not load settings\nThe config file "{filename}" is likely corrupted\nIt has been moved to the "tmp/config.json"\nReverting config to default\n\n''', exc_info=True)
+            errors.report(f'\nCould not load settings\nThe config file "{filename}" is likely corrupted\nIt has been moved to the "tmp/config.json"\nReverting config to default\n\n' "", exc_info=True)
             os.replace(filename, os.path.join(script_path, "tmp", "config.json"))
             self.data = {}
         # 1.6.0 VAE defaults
-        if self.data.get('sd_vae_as_default') is not None and self.data.get('sd_vae_overrides_per_model_preferences') is None:
-            self.data['sd_vae_overrides_per_model_preferences'] = not self.data.get('sd_vae_as_default')
+        if self.data.get("sd_vae_as_default") is not None and self.data.get("sd_vae_overrides_per_model_preferences") is None:
+            self.data["sd_vae_overrides_per_model_preferences"] = not self.data.get("sd_vae_as_default")
 
         # 1.1.1 quicksettings list migration
-        if self.data.get('quicksettings') is not None and self.data.get('quicksettings_list') is None:
-            self.data['quicksettings_list'] = [i.strip() for i in self.data.get('quicksettings').split(',')]
+        if self.data.get("quicksettings") is not None and self.data.get("quicksettings_list") is None:
+            self.data["quicksettings_list"] = [i.strip() for i in self.data.get("quicksettings").split(",")]
 
         # 1.4.0 ui_reorder
-        if isinstance(self.data.get('ui_reorder'), str) and self.data.get('ui_reorder') and "ui_reorder_list" not in self.data:
-            self.data['ui_reorder_list'] = [i.strip() for i in self.data.get('ui_reorder').split(',')]
+        if isinstance(self.data.get("ui_reorder"), str) and self.data.get("ui_reorder") and "ui_reorder_list" not in self.data:
+            self.data["ui_reorder_list"] = [i.strip() for i in self.data.get("ui_reorder").split(",")]
 
         bad_settings = 0
         for k, v in self.data.items():
@@ -319,6 +326,7 @@ class OptionsCategory:
     id: str
     label: str
 
+
 class OptionsCategories:
     def __init__(self):
         self.mapping = {}

modules/postprocessing.py

@@ -95,30 +95,6 @@ def run_postprocessing(extras_mode, image, image_folder, input_dir, output_dir,
             if save_output:
                 fullfn, _ = images.save_image(pp.image, path=outpath, basename=basename, extension=opts.samples_format, info=infotext, short_filename=True, no_prompt=True, grid=False, pnginfo_section_name="extras", existing_info=existing_pnginfo, forced_filename=forced_filename, suffix=suffix)
 
-                if pp.caption:
-                    caption_filename = os.path.splitext(fullfn)[0] + ".txt"
-                    existing_caption = ""
-                    try:
-                        with open(caption_filename, encoding="utf8") as file:
-                            existing_caption = file.read().strip()
-                    except FileNotFoundError:
-                        pass
-
-                    action = shared.opts.postprocessing_existing_caption_action
-                    if action == 'Prepend' and existing_caption:
-                        caption = f"{existing_caption} {pp.caption}"
-                    elif action == 'Append' and existing_caption:
-                        caption = f"{pp.caption} {existing_caption}"
-                    elif action == 'Keep' and existing_caption:
-                        caption = existing_caption
-                    else:
-                        caption = pp.caption
-
-                    caption = caption.strip()
-                    if caption:
-                        with open(caption_filename, "w", encoding="utf8") as file:
-                            file.write(caption)
-
             if extras_mode != 2 or show_extras_results:
                 outputs.append(pp.image)
 

modules/processing.py

@@ -147,6 +147,7 @@ class StableDiffusionProcessing:
     seed_resize_from_w: int = -1
     seed_enable_extras: bool = True
     sampler_name: str = None
+    scheduler: str = None
     batch_size: int = 1
     n_iter: int = 1
     steps: int = 50
@@ -660,6 +661,7 @@ def create_infotext(p, all_prompts, all_seeds, all_subseeds, comments=None, iter
     generation_params = {
         "Steps": p.steps,
         "Sampler": p.sampler_name,
+        "Schedule type": p.scheduler,
         "CFG scale": p.cfg_scale,
         "Image CFG scale": getattr(p, 'image_cfg_scale', None),
         "Seed": p.all_seeds[0] if use_main_prompt else all_seeds[index],
@@ -728,6 +730,8 @@ def process_images(p: StableDiffusionProcessing) -> Processed:
             if k == 'sd_vae':
                 sd_vae.reload_vae_weights()
 
+        sd_samplers.fix_p_invalid_sampler_and_scheduler(p)
+
         res = process_images_inner(p)
 
     finally:
@@ -1049,6 +1053,7 @@ class StableDiffusionProcessingTxt2Img(StableDiffusionProcessing):
     hr_resize_y: int = 0
     hr_checkpoint_name: str = None
     hr_sampler_name: str = None
+    hr_scheduler: str = None
     hr_prompt: str = ''
     hr_negative_prompt: str = ''
     force_task_id: str = None
@@ -1140,6 +1145,11 @@ class StableDiffusionProcessingTxt2Img(StableDiffusionProcessing):
             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
+
             if tuple(self.hr_prompt) != tuple(self.prompt):
                 self.extra_generation_params["Hires prompt"] = self.hr_prompt
 

modules/processing_scripts/comments.py

@@ -40,7 +40,7 @@ script_callbacks.on_before_token_counter(before_token_counter)
 
 shared.options_templates.update(
     shared.options_section(
-        ("sd", "Stable Diffusion", "sd"),
-        {"enable_prompt_comments": shared.OptionInfo(True, "Enable comments").info("Use # anywhere in the prompt to hide the text between # and the end of the line from the generation.")},
+        ("ui_alternatives", "UI Alternatives", "ui"),
+        {"enable_prompt_comments": shared.OptionInfo(True, "Enable Comments").info("Ignore the texts between # and the end of the line from the prompts")},
     )
 )

modules/processing_scripts/mahiro.py

@@ -6,6 +6,7 @@ https://github.com/comfyanonymous/ComfyUI/blob/v0.3.26/comfy_extras/nodes_mahiro
 import gradio as gr
 import torch
 import torch.nn.functional as F
+
 from modules import scripts
 from modules.infotext_utils import PasteField
 from modules.shared import opts

modules/processing_scripts/refiner.py

@@ -1,4 +1,5 @@
 import gradio as gr
+
 from modules import scripts, sd_models
 from modules.infotext_utils import PasteField
 from modules.shared import opts

modules/processing_scripts/rescale_cfg.py

@@ -5,6 +5,7 @@ https://github.com/comfyanonymous/ComfyUI/blob/v0.3.7/comfy_extras/nodes_model_a
 
 import gradio as gr
 import torch
+
 from modules import scripts
 from modules.infotext_utils import PasteField
 from modules.shared import opts

modules/processing_scripts/sampler.py

@@ -0,0 +1,66 @@
+import gradio as gr
+
+from modules import scripts, sd_samplers, sd_schedulers, shared
+from modules.infotext_utils import PasteField
+from modules.ui_components import FormRow
+
+
+class ScriptSampler(scripts.ScriptBuiltinUI):
+    create_group = False
+    section = "sampler"
+
+    def __init__(self):
+        self.steps = None
+        self.sampler_name = None
+        self.scheduler = None
+
+    def title(self):
+        return "Sampler"
+
+    def show(self, is_img2img):
+        return scripts.AlwaysVisible
+
+    def ui(self, is_img2img):
+        sampler_names: list[str] = sd_samplers.visible_sampler_names()
+        scheduler_names: list[str] = [x.label for x in sd_schedulers.schedulers]
+
+        with FormRow(elem_id=f"sampler_selection_{self.tabname}"):
+            self.sampler_name = gr.Dropdown(
+                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",
+                    elem_id=f"{self.tabname}_scheduler",
+                    choices=scheduler_names,
+                    value=scheduler_names[0],
+                )
+            else:
+                self.scheduler = gr.State(value="Automatic")
+                self.scheduler.do_not_save_to_config = True
+            self.steps = gr.Slider(
+                minimum=1,
+                maximum=150,
+                step=1,
+                elem_id=f"{self.tabname}_steps",
+                label="Sampling steps",
+                value=20,
+            )
+
+        self.infotext_fields = [
+            PasteField(self.steps, "Steps", api="steps"),
+            PasteField(self.sampler_name, sd_samplers.get_sampler_from_infotext, api="sampler_name"),
+        ]
+
+        if shared.opts.show_scheduler:
+            self.infotext_fields.append(PasteField(self.scheduler, sd_samplers.get_scheduler_from_infotext, api="scheduler"))
+
+        return self.steps, self.sampler_name, self.scheduler
+
+    def setup(self, p, steps, sampler_name, scheduler):
+        p.steps = steps
+        p.sampler_name = sampler_name
+        p.scheduler = scheduler

modules/processing_scripts/seed.py

@@ -1,6 +1,7 @@
 import json
 
 import gradio as gr
+
 from modules import errors, infotext_utils, scripts, ui
 from modules.infotext_utils import PasteField
 from modules.shared import cmd_opts

modules/scripts_postprocessing.py

@@ -19,7 +19,6 @@ class PostprocessedImage:
         self.extra_images = []
         self.nametags = []
         self.disable_processing = False
-        self.caption = None
 
     def get_suffix(self, used_suffixes=None):
         used_suffixes = {} if used_suffixes is None else used_suffixes

modules/sd_emphasis.py

@@ -25,12 +25,12 @@ class Emphasis:
 
 class EmphasisNone(Emphasis):
     name = "None"
-    description = "disable the mechanism entirely and treat (:.1.1) as literal characters"
+    description = "disable Emphasis entirely and treat (:1.2) as literal characters"
 
 
 class EmphasisIgnore(Emphasis):
     name = "Ignore"
-    description = "treat all empasised words as if they have no emphasis"
+    description = "treat all words as if they have no emphasis"
 
 
 class EmphasisOriginal(Emphasis):
@@ -48,7 +48,7 @@ class EmphasisOriginal(Emphasis):
 
 class EmphasisOriginalNoNorm(EmphasisOriginal):
     name = "No norm"
-    description = "same as original, but without normalization (seems to work better for SDXL)"
+    description = "implementation without normalization (fix certain issues for SDXL)"
 
     def after_transformers(self):
         self.z = self.z * self.multipliers.reshape(self.multipliers.shape + (1,)).expand(self.z.shape)
@@ -59,7 +59,11 @@ def get_current_option(emphasis_option_name):
 
 
 def get_options_descriptions():
-    return ", ".join(f"{x.name}: {x.description}" for x in options)
+    return f"""
+        <ul style='margin-left: 1.5em'><li>
+            {"</li><li>".join(f"<b>{x.name}</b>: {x.description}" for x in options)}
+        </li></ul>
+            """
 
 
 options = [

modules/sd_samplers.py

@@ -1,21 +1,43 @@
-from modules import sd_samplers_kdiffusion, sd_samplers_timesteps, sd_samplers_lcm, shared
-
-# imports for functions that previously were here and are used by other modules
-from modules.sd_samplers_common import samples_to_image_grid, sample_to_image  # noqa: F401
+import functools
+import logging
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from modules.sd_samplers_common import SamplerData
+
+from modules import (
+    sd_samplers_kdiffusion,
+    sd_samplers_lcm,
+    sd_samplers_timesteps,
+    sd_schedulers,
+    shared,
+)
+from modules.sd_samplers_common import (  # noqa: F401
+    sample_to_image,
+    samples_to_image_grid,
+)
 from modules_forge import forge_alter_samplers
 
 all_samplers = [
     *sd_samplers_kdiffusion.samplers_data_k_diffusion,
     *sd_samplers_timesteps.samplers_data_timesteps,
     *sd_samplers_lcm.samplers_data_lcm,
-    *forge_alter_samplers.samplers_data_alter
+    *forge_alter_samplers.samplers_data_alter,
 ]
 all_samplers_map = {x.name: x for x in all_samplers}
 
-samplers = []
-samplers_for_img2img = []
-samplers_map = {}
-samplers_hidden = {}
+samplers: list["SamplerData"] = []
+samplers_for_img2img: list["SamplerData"] = []
+samplers_map: dict[str, str] = {}
+samplers_hidden: set[str] = {}
+
+
+def get_sampler_from_infotext(d: dict):
+    return get_sampler_and_scheduler(d.get("Sampler"), d.get("Schedule type"))[0]
+
+
+def get_scheduler_from_infotext(d: dict):
+    return get_sampler_and_scheduler(d.get("Sampler"), d.get("Schedule type"))[1]
 
 
 def find_sampler_config(name):
@@ -30,7 +52,7 @@ def find_sampler_config(name):
 def create_sampler(name, model):
     config = find_sampler_config(name)
 
-    assert config is not None, f'bad sampler name: {name}'
+    assert config is not None, f"bad sampler name: {name}"
 
     if model.is_sdxl and config.options.get("no_sdxl", False):
         raise Exception(f"Sampler {config.name} is not supported for SDXL")
@@ -44,10 +66,15 @@ def create_sampler(name, model):
 def set_samplers():
     global samplers, samplers_for_img2img, samplers_hidden
 
-    samplers_hidden = set(shared.opts.hide_samplers)
     samplers = all_samplers
     samplers_for_img2img = all_samplers
 
+    _samplers_hidden = set(shared.opts.hide_samplers)
+    if shared.opts.hide_samplers_invert:
+        samplers_hidden = set(x.name for x in samplers if x.name not in _samplers_hidden)
+    else:
+        samplers_hidden = _samplers_hidden
+
     samplers_map.clear()
     for sampler in all_samplers:
         samplers_map[sampler.name.lower()] = sampler.name
@@ -55,11 +82,73 @@ def set_samplers():
             samplers_map[alias.lower()] = sampler.name
 
 
-def visible_sampler_names():
-    if shared.opts.hide_samplers_invert:
-        return [x.name for x in samplers if x.name in samplers_hidden]
-    else:
-        return [x.name for x in samplers if x.name not in samplers_hidden]
+def visible_samplers() -> list["SamplerData"]:
+    return [x for x in samplers if x.name not in samplers_hidden]
+
+
+def visible_sampler_names() -> list[str]:
+    return [x.name for x in samplers if x.name not in samplers_hidden]
 
 
 set_samplers()
+
+
+def get_hr_sampler_and_scheduler(d: dict):
+    hr_sampler = d.get("Hires sampler", "Use same sampler")
+    sampler = d.get("Sampler") if hr_sampler == "Use same sampler" else hr_sampler
+
+    hr_scheduler = d.get("Hires schedule type", "Use same scheduler")
+    scheduler = d.get("Schedule type") if hr_scheduler == "Use same scheduler" else hr_scheduler
+
+    sampler, scheduler = get_sampler_and_scheduler(sampler, scheduler)
+
+    sampler = sampler if sampler != d.get("Sampler") else "Use same sampler"
+    scheduler = scheduler if scheduler != d.get("Schedule type") else "Use same scheduler"
+
+    return sampler, scheduler
+
+
+def get_hr_sampler_from_infotext(d: dict):
+    return get_hr_sampler_and_scheduler(d)[0]
+
+
+def get_hr_scheduler_from_infotext(d: dict):
+    return get_hr_sampler_and_scheduler(d)[1]
+
+
+@functools.lru_cache(maxsize=10, 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])
+
+    name = sampler_name or default_sampler.name
+
+    for scheduler in sd_schedulers.schedulers:
+        name_options = [scheduler.label, scheduler.name, *(scheduler.aliases or [])]
+
+        for name_option in name_options:
+            if name.endswith(" " + name_option):
+                found_scheduler = scheduler
+                name = name[0 : -(len(name_option) + 1)]
+                break
+
+    sampler = all_samplers_map.get(name, default_sampler)
+
+    _automatic = False
+    if sampler.options.get("scheduler", None) == found_scheduler.name:
+        found_scheduler = sd_schedulers.schedulers[0]
+        _automatic = True
+
+    if not status:
+        return sampler.name, found_scheduler.label
+    else:
+        return sampler.name, found_scheduler.label, _automatic
+
+
+def fix_p_invalid_sampler_and_scheduler(p):
+    i_sampler_name, i_scheduler = p.sampler_name, p.scheduler
+    p.sampler_name, p.scheduler, _automatic = get_sampler_and_scheduler(p.sampler_name, p.scheduler, status=True)
+    if i_sampler_name != p.sampler_name:
+        logging.warning(f'Sampler Correction: "{i_sampler_name}" -> "{p.sampler_name}"')
+    if i_scheduler != p.scheduler and not _automatic:
+        logging.warning(f'Scheduler Correction: "{i_scheduler}" -> "{p.scheduler}"')

modules/sd_samplers_cfg_denoiser.py

@@ -1,14 +1,14 @@
 import torch
 from modules import prompt_parser, sd_samplers_common
-
+from modules.script_callbacks import (
+    AfterCFGCallbackParams,
+    CFGDenoiserParams,
+    cfg_after_cfg_callback,
+    cfg_denoiser_callback,
+)
 from modules.shared import opts, state
 from modules_forge import forge_sampler
 
-from modules.script_callbacks import CFGDenoiserParams, cfg_denoiser_callback
-from modules.script_callbacks import AfterCFGCallbackParams, cfg_after_cfg_callback
-
-# from modules.script_callbacks import CFGDenoisedParams, cfg_denoised_callback
-
 
 def catenate_conds(conds):
     if not isinstance(conds[0], dict):
@@ -53,37 +53,29 @@ class CFGDenoiser(torch.nn.Module):
         """expected number of calls to denoiser calculated from self.steps and specifics of the selected sampler"""
 
         self.step = 0
-        self.image_cfg_scale = None
-        self.padded_cond_uncond = False
+        self.image_cfg_scale = 1.0
+        self.padded_cond_uncond = True
         self.padded_cond_uncond_v0 = False
         self.sampler = sampler
         self.model_wrap = None
         self.p = None
 
-        # Backward Compatibility
         self.mask_before_denoising = False
-
         self.classic_ddim_eps_estimation = False
 
     @property
     def inner_model(self):
-        raise NotImplementedError()
-
-    def combine_denoised(self, x_out, conds_list, uncond, cond_scale, timestep, x_in, cond):
-        denoised_uncond = x_out[-uncond.shape[0] :]
-        denoised = torch.clone(denoised_uncond)
-
-        for i, conds in enumerate(conds_list):
-            for cond_index, weight in conds:
-                denoised[i] += (x_out[cond_index] - denoised_uncond[i]) * (weight * cond_scale)
+        raise NotImplementedError
 
-        return denoised
+    # def combine_denoised(self, x_out, conds_list, uncond, cond_scale):
+    #     denoised_uncond = x_out[-uncond.shape[0] :]
+    #     denoised = torch.clone(denoised_uncond)
+    #     return denoised
 
-    def combine_denoised_for_edit_model(self, x_out, cond_scale):
-        out_cond, out_img_cond, out_uncond = x_out.chunk(3)
-        denoised = out_uncond + cond_scale * (out_cond - out_img_cond) + self.image_cfg_scale * (out_img_cond - out_uncond)
-
-        return denoised
+    # def combine_denoised_for_edit_model(self, x_out, cond_scale):
+    #     out_cond, out_img_cond, out_uncond = x_out.chunk(3)
+    #     denoised = out_uncond + cond_scale * (out_cond - out_img_cond) + self.image_cfg_scale * (out_img_cond - out_uncond)
+    #     return denoised
 
     def get_pred_x0(self, x_in, x_out, sigma):
         return x_out
@@ -95,7 +87,7 @@ class CFGDenoiser(torch.nn.Module):
         self.sampler.sampler_extra_args["cond"] = c
         self.sampler.sampler_extra_args["uncond"] = uc
 
-    def forward(self, x, sigma, uncond, cond, cond_scale, s_min_uncond, image_cond):
+    def forward(self, x, sigma, uncond, cond, cond_scale, s_min_uncond, image_cond, **kwargs):
         if state.interrupted or state.skipped:
             raise sd_samplers_common.InterruptedException
 
@@ -148,7 +140,16 @@ class CFGDenoiser(torch.nn.Module):
             ] * torch.randn_like(self.init_latent)
             x = apply_blend(x, noisy_initial_latent.to(self.init_latent))
 
-        denoiser_params = CFGDenoiserParams(x, image_cond, sigma, state.sampling_step, state.sampling_steps, cond, uncond, self)
+        denoiser_params = CFGDenoiserParams(
+            x,
+            image_cond,
+            sigma,
+            state.sampling_step,
+            state.sampling_steps,
+            cond,
+            uncond,
+            self,
+        )
         cfg_denoiser_callback(denoiser_params)
 
         if 0.0 <= self.step / self.total_steps <= opts.skip_early_cond:
@@ -156,13 +157,23 @@ class CFGDenoiser(torch.nn.Module):
         if 0.0 <= sigma[0] <= s_min_uncond:
             cond_scale = 1.0
 
+        skip_uncond: bool = abs(cond_scale - 1.0) < 10**-6
+        self.padded_cond_uncond = not skip_uncond
+
         denoised = forge_sampler.forge_sample(
             self,
             denoiser_params=denoiser_params,
             cond_scale=cond_scale,
             cond_composition=cond_composition,
+            skip_uncond=skip_uncond,
+            options=kwargs.get("model_options", None),
         )
 
+        # if getattr(self.p.sd_model, "cond_stage_key", None) == "edit" and getattr(self, "image_cfg_scale", 1.0) != 1.0:
+        #     denoised = self.combine_denoised_for_edit_model(denoised, cond_scale)
+        # elif not skip_uncond:
+        #     denoised = self.combine_denoised(denoised, cond_composition, uncond, cond_scale)
+
         if not self.mask_before_denoising and self.mask is not None:
             denoised = apply_blend(denoised)
 

modules/sd_samplers_cfgpp.py

@@ -0,0 +1,264 @@
+import torch
+from k_diffusion.sampling import (
+    BrownianTreeNoiseSampler,
+    default_noise_sampler,
+    get_ancestral_step,
+    to_d,
+)
+from tqdm.auto import trange
+
+
+def _set_model_options_post_cfg_function(model_options, post_cfg_function, disable_cfg1_optimization=False):
+    model_options["sampler_post_cfg_function"] = model_options.get("sampler_post_cfg_function", []) + [post_cfg_function]
+    if disable_cfg1_optimization:
+        model_options["disable_cfg1_optimization"] = True
+    return model_options
+
+
+def _sigma_fn(t):
+    return t.neg().exp()
+
+
+def _t_fn(sigma):
+    return sigma.log().neg()
+
+
+@torch.no_grad()
+def sample_euler_cfg_pp(model, x, sigmas, extra_args=None, callback=None, disable=None):
+    extra_args = {} if extra_args is None else extra_args
+
+    temp = [0]
+
+    def post_cfg_function(args):
+        temp[0] = args["uncond_denoised"]
+        return args["denoised"]
+
+    model_options = extra_args.get("model_options", {}).copy()
+    extra_args["model_options"] = _set_model_options_post_cfg_function(model_options, post_cfg_function, disable_cfg1_optimization=True)
+
+    s_in = x.new_ones([x.shape[0]])
+    for i in trange(len(sigmas) - 1, disable=disable):
+        sigma_hat = sigmas[i]
+        denoised = model(x, sigma_hat * s_in, **extra_args)
+        d = to_d(x, sigma_hat, temp[0])
+        if callback is not None:
+            callback(
+                {
+                    "x": x,
+                    "i": i,
+                    "sigma": sigmas[i],
+                    "sigma_hat": sigma_hat,
+                    "denoised": denoised,
+                }
+            )
+        x = denoised + d * sigmas[i + 1]
+    return x
+
+
+@torch.no_grad()
+def sample_euler_ancestral_cfg_pp(model, x, sigmas, extra_args=None, callback=None, disable=None, noise_sampler=None):
+    eta = 1.0
+    s_noise = 1.0
+    extra_args = {} if extra_args is None else extra_args
+    seed = extra_args.get("seed", None)
+    noise_sampler = default_noise_sampler(x, seed=seed) if noise_sampler is None else noise_sampler
+
+    temp = [0]
+
+    def post_cfg_function(args):
+        temp[0] = args["uncond_denoised"]
+        return args["denoised"]
+
+    model_options = extra_args.get("model_options", {}).copy()
+    extra_args["model_options"] = _set_model_options_post_cfg_function(model_options, post_cfg_function, disable_cfg1_optimization=True)
+
+    s_in = x.new_ones([x.shape[0]])
+    for i in trange(len(sigmas) - 1, disable=disable):
+        denoised = model(x, sigmas[i] * s_in, **extra_args)
+        sigma_down, sigma_up = get_ancestral_step(sigmas[i], sigmas[i + 1], eta=eta)
+        if callback is not None:
+            callback(
+                {
+                    "x": x,
+                    "i": i,
+                    "sigma": sigmas[i],
+                    "sigma_hat": sigmas[i],
+                    "denoised": denoised,
+                }
+            )
+        d = to_d(x, sigmas[i], temp[0])
+        x = denoised + d * sigma_down
+        if sigmas[i + 1] > 0:
+            x = x + noise_sampler(sigmas[i], sigmas[i + 1]) * s_noise * sigma_up
+    return x
+
+
+@torch.no_grad()
+def sample_dpmpp_sde_cfg_pp(model, x, sigmas, extra_args=None, callback=None, disable=None, noise_sampler=None):
+    eta = 1.0
+    s_noise = 1.0
+    r = 0.5
+
+    if len(sigmas) <= 1:
+        return x
+
+    sigma_min, sigma_max = sigmas[sigmas > 0].min(), sigmas.max()
+    noise_sampler = BrownianTreeNoiseSampler(x, sigma_min, sigma_max, seed=extra_args.get("seed", None), cpu=True) if noise_sampler is None else noise_sampler
+    extra_args = {} if extra_args is None else extra_args
+
+    temp = [0]
+
+    def post_cfg_function(args):
+        temp[0] = args["uncond_denoised"]
+        return args["denoised"]
+
+    model_options = extra_args.get("model_options", {}).copy()
+    extra_args["model_options"] = _set_model_options_post_cfg_function(model_options, post_cfg_function, disable_cfg1_optimization=True)
+
+    s_in = x.new_ones([x.shape[0]])
+
+    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:
+            d = to_d(x, sigmas[i], temp[0])
+            x = denoised + d * sigmas[i + 1]
+        else:
+            t, t_next = _t_fn(sigmas[i]), _t_fn(sigmas[i + 1])
+            h = t_next - t
+            s = t + h * r
+            fac = 1 / (2 * r)
+
+            sd, su = get_ancestral_step(_sigma_fn(t), _sigma_fn(s), eta)
+            s_ = _t_fn(sd)
+            x_2 = (_sigma_fn(s_) / _sigma_fn(t)) * x - (t - s_).expm1() * denoised
+            x_2 = x_2 + noise_sampler(_sigma_fn(t), _sigma_fn(s)) * s_noise * su
+            denoised_2 = model(x_2, _sigma_fn(s) * s_in, **extra_args)
+
+            sd, su = get_ancestral_step(_sigma_fn(t), _sigma_fn(t_next), eta)
+            denoised_d = (1 - fac) * temp[0] + fac * temp[0]
+            x = denoised_2 + to_d(x, sigmas[i], denoised_d) * sd
+            x = x + noise_sampler(_sigma_fn(t), _sigma_fn(t_next)) * s_noise * su
+    return x
+
+
+@torch.no_grad()
+def sample_dpmpp_2m_cfg_pp(model, x, sigmas, extra_args=None, callback=None, disable=None):
+    extra_args = {} if extra_args is None else extra_args
+    s_in = x.new_ones([x.shape[0]])
+
+    old_uncond_denoised = None
+    uncond_denoised = None
+
+    def post_cfg_function(args):
+        nonlocal uncond_denoised
+        uncond_denoised = args["uncond_denoised"]
+        return args["denoised"]
+
+    model_options = extra_args.get("model_options", {}).copy()
+    extra_args["model_options"] = _set_model_options_post_cfg_function(model_options, post_cfg_function, disable_cfg1_optimization=True)
+
+    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,
+                }
+            )
+        t, t_next = _t_fn(sigmas[i]), _t_fn(sigmas[i + 1])
+        h = t_next - t
+        if old_uncond_denoised is None or sigmas[i + 1] == 0:
+            denoised_mix = -torch.exp(-h) * uncond_denoised
+        else:
+            h_last = t - _t_fn(sigmas[i - 1])
+            r = h_last / h
+            denoised_mix = -torch.exp(-h) * uncond_denoised - torch.expm1(-h) * (1 / (2 * r)) * (denoised - old_uncond_denoised)
+        x = denoised + denoised_mix + torch.exp(-h) * x
+        old_uncond_denoised = uncond_denoised
+    return x
+
+
+@torch.no_grad()
+def sample_dpmpp_3m_sde_cfg_pp(model, x, sigmas, extra_args=None, callback=None, disable=None, eta=None, s_noise=None, noise_sampler=None):
+    eta = 1.0 if eta is None else eta
+    s_noise = 1.0 if s_noise is None else s_noise
+
+    if len(sigmas) <= 1:
+        return x
+
+    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]])
+
+    denoised_1, denoised_2 = None, None
+    h, h_1, h_2 = None, None, None
+
+    temp = [0]
+
+    def post_cfg_function(args):
+        temp[0] = args["uncond_denoised"]
+        return args["denoised"]
+
+    model_options = extra_args.get("model_options", {}).copy()
+    extra_args["model_options"] = _set_model_options_post_cfg_function(model_options, post_cfg_function, disable_cfg1_optimization=True)
+
+    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
+            h_eta = h * (eta + 1)
+
+            x = torch.exp(-h_eta) * (x + (denoised - temp[0])) + (-h_eta).expm1().neg() * denoised
+
+            if h_2 is not None:
+                r0 = h_1 / h
+                r1 = h_2 / h
+                d1_0 = (denoised - denoised_1) / r0
+                d1_1 = (denoised_1 - denoised_2) / r1
+                d1 = d1_0 + (d1_0 - d1_1) * r0 / (r0 + r1)
+                d2 = (d1_0 - d1_1) / (r0 + r1)
+                phi_2 = h_eta.neg().expm1() / h_eta + 1
+                phi_3 = phi_2 / h_eta - 0.5
+                x = x + phi_2 * d1 - phi_3 * d2
+            elif h_1 is not None:
+                r = h_1 / h
+                d = (denoised - denoised_1) / r
+                phi_2 = h_eta.neg().expm1() / h_eta + 1
+                x = x + phi_2 * d
+
+            if eta:
+                x = x + noise_sampler(sigmas[i], sigmas[i + 1]) * sigmas[i + 1] * (-2 * h * eta).expm1().neg().sqrt() * s_noise
+
+        denoised_1, denoised_2 = denoised, denoised_1
+        h_1, h_2 = h, h_1
+    return x