Upload sd-webui-kohya-hiresfix-saveable2.2 using SD-Hub

sd-webui-kohya-hiresfix-saveable2.2/.gitattributes

@@ -0,0 +1,2 @@
+# Auto detect text files and perform LF normalization
+* text=auto

sd-webui-kohya-hiresfix-saveable2.2/.gitignore

@@ -0,0 +1,3 @@
+
+*.pyc
+config.yaml

sd-webui-kohya-hiresfix-saveable2.2/README.md

@@ -0,0 +1,9 @@
+# Implementation Kohya Hires.fix for Auto1111 webui
+
+#### Stop step - at which sampling step disable fix, increase at higher resolution
+#### Depth - on which layer fix will be applied
+#### Downsampling scale - decrease at higher resolution, helps preserve composition at very high resolutions
+#### Upsampling scale - increasing can slightly improve quality at cost of VRAM
+
+## Source:
+https://gist.github.com/kohya-ss/3f774da220df102548093a7abc8538ed

sd-webui-kohya-hiresfix-saveable2.2/scripts/khrfix.py

@@ -0,0 +1,1134 @@
+# kohya_hires_fix_unified.py
+# Версия: 2.1 (Unified)
+# Совместимость: A1111 / modules.scripts API, PyTorch >= 1.12
+# Объединяет функционал Kohya Hires Fix RU+ и Original Legacy Mode
+
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Any, Dict, List, Optional, Tuple
+
+import gradio as gr
+import torch
+import torch.nn.functional as F
+from omegaconf import DictConfig, OmegaConf
+from modules import scripts, script_callbacks
+
+CONFIG_PATH = Path(__file__).with_suffix(".yaml")
+PRESETS_PATH = Path(__file__).with_name(Path(__file__).stem + ".presets.yaml")
+
+# ---- Предустановленные разрешения ----
+
+RESOLUTION_GROUPS = {
+    "Квадрат": [(1024, 1024)],
+    "Портрет": [(640, 1536), (768, 1344), (832, 1216), (896, 1152), (768, 1152)],
+    "Альбом": [(1536, 640), (1344, 768), (1216, 832), (1152, 896), (1024, 1536)],
+}
+RESOLUTION_CHOICES: List[str] = ["— не применять —"]
+for group, dims in RESOLUTION_GROUPS.items():
+    for w, h in dims:
+        RESOLUTION_CHOICES.append(f"{group}: {w}x{h}")
+
+
+def parse_resolution_label(label: str) -> Optional[Tuple[int, int]]:
+    if not label or label.startswith("—"):
+        return None
+    try:
+        _, wh = label.split(":")
+        w, h = wh.strip().lower().split("x")
+        return int(w), int(h)
+    except Exception:
+        return None
+
+
+# ---- Вспомогательные утилиты ----
+
+def _safe_mode(mode: str) -> str:
+    if mode == "nearest-exact":
+        return mode
+    if mode in {"bicubic", "bilinear", "nearest"}:
+        return mode
+    return "bilinear"
+
+
+def _load_yaml(path: Path, default: dict) -> dict:
+    try:
+        return OmegaConf.to_container(OmegaConf.load(path), resolve=True) or default
+    except Exception:
+        return default
+
+
+def _atomic_save_yaml(path: Path, data: dict) -> None:
+    try:
+        tmp = path.with_suffix(path.suffix + ".tmp")
+        OmegaConf.save(DictConfig(data), tmp)
+        tmp.replace(path)
+    except Exception:
+        pass
+
+
+def _load_presets() -> Dict[str, dict]:
+    data = _load_yaml(PRESETS_PATH, {})
+    return {str(k): dict(v) for k, v in data.items()}
+
+
+def _save_presets(presets: Dict[str, dict]) -> None:
+    _atomic_save_yaml(PRESETS_PATH, presets)
+
+
+def _clamp(x: float, lo: float, hi: float) -> float:
+    return float(max(lo, min(hi, x)))
+
+
+def _norm_mode_choice(value: str, default_: str = "auto") -> str:
+    """Нормализация строкового значения."""
+    try:
+        v = str(value).strip().lower()
+    except Exception:
+        v = ""
+    if v in {"true", "t", "1", "yes", "y"}:
+        return "true"
+    if v in {"false", "f", "0", "no", "n"}:
+        return "false"
+    if v in {"auto", "a", "авто"}:
+        return "auto"
+    return str(default_).strip().lower()
+
+
+def _compute_adaptive_params(
+    width: int,
+    height: int,
+    profile: str,
+    base_s1: float,
+    base_s2: float,
+    base_d1: int,
+    base_d2: int,
+    base_down: float,
+    base_up: float,
+    keep_unitary_product: bool,
+) -> Tuple[float, float, int, int, float, float]:
+    """Адаптировать (s1, s2, d1, d2, downscale, upscale) под MPix и аспект."""
+    rel_mpx = (max(1, int(width)) * max(1, int(height))) / float(1024 * 1024)
+    aspect = max(width, height) / float(min(width, height))
+
+    prof = (profile or "").strip().lower()
+    s1 = float(base_s1)
+    s2 = float(base_s2)
+    d1 = int(base_d1)
+    d2 = int(base_d2)
+    down = float(base_down)
+    up = float(base_up)
+
+    if prof.startswith("конс"):
+        s_add = -0.02
+        d_add = 0
+    elif prof.startswith("агре"):
+        s_add = 0.05
+        d_add = 1
+    else:
+        s_add = 0.0
+        d_add = 0
+
+    if rel_mpx >= 1.5:
+        s_add += 0.08
+        down -= 0.10
+    elif rel_mpx >= 1.1:
+        s_add += 0.05
+        down -= 0.05
+    elif rel_mpx <= 0.8:
+        s_add -= 0.02
+        down += 0.05
+
+    if aspect >= 1.6:
+        d_add += 1
+    elif aspect <= 1.1:
+        d_add -= 1
+
+    s1 = _clamp(s1 + s_add * 0.7, 0.0, 0.5)
+    s2 = _clamp(s2 + s_add, 0.0, 0.5)
+
+    d1 = max(1, d1 + d_add)
+    d2 = max(1, d2 + d_add)
+
+    down = _clamp(down, 0.1, 1.0)
+    if keep_unitary_product:
+        up = 1.0 / max(1e-6, down)
+    else:
+        up = _clamp(up * (base_down / max(1e-6, down)), 1.0, 4.0)
+
+    return s1, s2, d1, d2, down, up
+
+
+# ---- Класс пресета ----
+
+class HiresPreset:
+    def __init__(self, **kwargs: Any) -> None:
+        self.category: str = "Общие"
+        self.algo_mode: str = "Enhanced (RU+)"  # Новый/старый режим
+
+        self.d1: int = 3
+        self.d2: int = 4
+        self.s1: float = 0.15
+        self.s2: float = 0.30
+
+        self.scaler: str = "bicubic"
+        self.downscale: float = 0.5
+        self.upscale: float = 2.0
+
+        # Два раздельных smooth_scaling
+        self.smooth_scaling_enh: bool = True
+        self.smooth_scaling_legacy: bool = True
+
+        self.smoothing_curve: str = "Линейная"
+
+        self.early_out: bool = False
+
+        # Два раздельных only_one_pass
+        self.only_one_pass_enh: bool = True
+        self.only_one_pass_legacy: bool = True
+
+        self.keep_unitary_product: bool = False
+        self.align_corners_mode: str = "False"
+        self.recompute_scale_factor_mode: str = "False"
+
+        self.resolution_choice: str = RESOLUTION_CHOICES[0]
+        self.apply_resolution: bool = False
+        self.adaptive_by_resolution: bool = True
+        self.adaptive_profile: str = "Сбалансированный"
+
+        # Поддержка старых ключей из YAML (smooth_scaling/only_one_pass)
+        legacy_smooth = kwargs.pop("smooth_scaling", None)
+        legacy_one = kwargs.pop("only_one_pass", None)
+
+        for k, v in kwargs.items():
+            if hasattr(self, k):
+                setattr(self, k, v)
+
+        if legacy_smooth is not None:
+            self.smooth_scaling_enh = bool(legacy_smooth)
+            self.smooth_scaling_legacy = bool(legacy_smooth)
+        if legacy_one is not None:
+            self.only_one_pass_enh = bool(legacy_one)
+            self.only_one_pass_legacy = bool(legacy_one)
+
+    def to_dict(self) -> Dict[str, Any]:
+        return {
+            "category": self.category,
+            "algo_mode": self.algo_mode,
+            "d1": self.d1,
+            "d2": self.d2,
+            "s1": self.s1,
+            "s2": self.s2,
+            "scaler": self.scaler,
+            "downscale": self.downscale,
+            "upscale": self.upscale,
+            "smooth_scaling_enh": self.smooth_scaling_enh,
+            "smooth_scaling_legacy": self.smooth_scaling_legacy,
+            "smoothing_curve": self.smoothing_curve,
+            "early_out": self.early_out,
+            "only_one_pass_enh": self.only_one_pass_enh,
+            "only_one_pass_legacy": self.only_one_pass_legacy,
+            "keep_unitary_product": self.keep_unitary_product,
+            "align_corners_mode": self.align_corners_mode,
+            "recompute_scale_factor_mode": self.recompute_scale_factor_mode,
+            "resolution_choice": self.resolution_choice,
+            "apply_resolution": self.apply_resolution,
+            "adaptive_by_resolution": self.adaptive_by_resolution,
+            "adaptive_profile": self.adaptive_profile,
+        }
+
+
+DEFAULT_PRESETS: Dict[str, Dict[str, Any]] = {
+    "XL · портрет (безопасный)": {
+        "category": "XL",
+        "algo_mode": "Enhanced (RU+)",
+        "resolution_choice": "Портрет: 832x1216",
+        "apply_resolution": True,
+        "adaptive_by_resolution": True,
+        "adaptive_profile": "Сбалансированный",
+        "d1": 3,
+        "s1": 0.18,
+        "d2": 5,
+        "s2": 0.32,
+        "scaler": "bicubic",
+        "downscale": 0.6,
+        "upscale": 1.8,
+        "smooth_scaling_enh": True,
+        "smooth_scaling_legacy": True,
+        "smoothing_curve": "Smoothstep",
+        "early_out": False,
+        "only_one_pass_enh": True,
+        "only_one_pass_legacy": True,
+        "keep_unitary_product": True,
+    },
+    "SD15 · Legacy Old Style": {
+        "category": "SD15",
+        "algo_mode": "Legacy (Original)",
+        "resolution_choice": "— не применять —",
+        "apply_resolution": False,
+        "adaptive_by_resolution": False,
+        "d1": 3,
+        "s1": 0.15,
+        "d2": 4,
+        "s2": 0.30,
+        "scaler": "bicubic",
+        "downscale": 0.5,
+        "upscale": 2.0,
+        "smooth_scaling_enh": True,
+        "smooth_scaling_legacy": True,
+        "early_out": False,
+        "only_one_pass_enh": True,
+        "only_one_pass_legacy": True,
+    },
+}
+
+
+class PresetManager:
+    def __init__(self) -> None:
+        self._cache: Dict[str, HiresPreset] = {}
+        self.reload()
+
+    def reload(self) -> None:
+        raw = _load_presets()
+        if raw is None:
+            raw = {}
+        if not raw:
+            raw = {name: pdata.copy() for name, pdata in DEFAULT_PRESETS.items()}
+
+        self._cache.clear()
+        for name, data in raw.items():
+            base = HiresPreset().to_dict()
+            if isinstance(data, dict):
+                base.update(data or {})
+            try:
+                self._cache[str(name)] = HiresPreset(**base)
+            except Exception:
+                continue
+
+    def _save(self) -> None:
+        raw = {name: preset.to_dict() for name, preset in self._cache.items()}
+        _save_presets(raw)
+
+    def names(self) -> List[str]:
+        return sorted(self._cache.keys())
+
+    def get(self, name: str) -> Optional[HiresPreset]:
+        return self._cache.get(name)
+
+    def upsert(self, name: str, preset: HiresPreset) -> None:
+        self._cache[name] = preset
+        self._save()
+
+    def delete(self, name: str) -> None:
+        if name in self._cache:
+            del self._cache[name]
+            self._save()
+
+    def categories(self) -> List[str]:
+        cats = {(p.category or "Общие") for p in self._cache.values()}
+        return sorted(cats) if cats else []
+
+    def names_for_category(self, category: Optional[str]) -> List[str]:
+        if not category or category == "Все":
+            return self.names()
+        cat = category or "Общие"
+        return sorted(
+            name for name, preset in self._cache.items()
+            if (preset.category or "Общие") == cat
+        )
+
+
+class Scaler(torch.nn.Module):
+    """Универсальная обёртка. Поддерживает и логику New, и логику Old (через настройки)."""
+
+    def __init__(
+        self,
+        scale: float,
+        block: torch.nn.Module,
+        scaler: str,
+        align_mode: str = "false",
+        recompute_mode: str = "false",
+    ) -> None:
+        super().__init__()
+        self.scale: float = float(scale)
+        self.block: torch.nn.Module = block
+        self.scaler: str = _safe_mode(scaler)
+        self.align_mode: str = _norm_mode_choice(align_mode, "false")
+        self.recompute_mode: str = _norm_mode_choice(recompute_mode, "false")
+
+    def forward(self, x: torch.Tensor, *args, **kwargs):
+        if self.scale == 1.0:
+            return self.block(x, *args, **kwargs)
+
+        h, w = x.shape[-2:]
+        new_h = max(1, int(h * self.scale))
+        new_w = max(1, int(w * self.scale))
+
+        align_corners = None
+        if self.scaler in {"bilinear", "bicubic", "linear", "trilinear"}:
+            if self.align_mode == "true":
+                align_corners = True
+            elif self.align_mode == "false":
+                align_corners = False
+            else:
+                align_corners = None
+
+        x_scaled = F.interpolate(
+            x,
+            size=(new_h, new_w),
+            mode=self.scaler,
+            align_corners=align_corners,
+        )
+
+        out = self.block(x_scaled, *args, **kwargs)
+        return out
+
+
+class KohyaHiresFix(scripts.Script):
+    def __init__(self) -> None:
+        super().__init__()
+        self.config: DictConfig = DictConfig(_load_yaml(CONFIG_PATH, {}))
+        self.disable: bool = False
+        self.step_limit: int = 0
+        self.infotext_fields = []
+        self._cb_registered: bool = False
+
+    def title(self) -> str:
+        return "Kohya Hires.fix · Unified"
+
+    def show(self, is_img2img: bool):
+        return scripts.AlwaysVisible
+
+    @staticmethod
+    def _unwrap_all(model) -> None:
+        if not model:
+            return
+        for i, b in enumerate(getattr(model, "input_blocks", [])):
+            if isinstance(b, Scaler):
+                model.input_blocks[i] = b.block
+        for i, b in enumerate(getattr(model, "output_blocks", [])):
+            if isinstance(b, Scaler):
+                model.output_blocks[i] = b.block
+
+    @staticmethod
+    def _map_output_index(model, in_idx: int, early_out: bool) -> Optional[int]:
+        outs = getattr(model, "output_blocks", None)
+        if not outs:
+            return None
+        n = len(outs)
+        if early_out:
+            return max(0, min(int(in_idx), n - 1))
+        mirror = (n - 1) - int(in_idx)
+        return max(0, min(mirror, n - 1))
+
+    def ui(self, is_img2img: bool):
+        self.infotext_fields = []
+        pm = PresetManager()
+        cfg = self.config
+
+        last_algo_mode = cfg.get("algo_mode", "Enhanced (RU+)")
+        last_resolution_choice = cfg.get("resolution_choice", RESOLUTION_CHOICES[0])
+        last_apply_resolution = cfg.get("apply_resolution", False)
+        last_adaptive_by_resolution = cfg.get("adaptive_by_resolution", True)
+        last_adaptive_profile = cfg.get("adaptive_profile", "Сбалансированный")
+        last_s1 = cfg.get("s1", 0.15)
+        last_s2 = cfg.get("s2", 0.30)
+        last_d1 = cfg.get("d1", 3)
+        last_d2 = cfg.get("d2", 4)
+        last_scaler = cfg.get("scaler", "bicubic")
+        last_downscale = cfg.get("downscale", 0.5)
+        last_upscale = cfg.get("upscale", 2.0)
+
+        # Раздельные флаги, плюс поддержка старых ключей
+        last_smooth_enh = cfg.get("smooth_scaling_enh", True)
+        last_smooth_leg = cfg.get("smooth_scaling_legacy", True)
+        last_only_enh = cfg.get("only_one_pass_enh", True)
+        last_only_leg = cfg.get("only_one_pass_legacy", True)
+
+        legacy_smooth = cfg.get("smooth_scaling", None)
+        if legacy_smooth is not None:
+            last_smooth_enh = bool(legacy_smooth)
+            last_smooth_leg = bool(legacy_smooth)
+        legacy_one = cfg.get("only_one_pass", None)
+        if legacy_one is not None:
+            last_only_enh = bool(legacy_one)
+            last_only_leg = bool(legacy_one)
+
+        last_smoothing_curve = cfg.get("smoothing_curve", "Линейная")
+        last_early_out = cfg.get("early_out", False)
+        last_keep1 = cfg.get("keep_unitary_product", False)
+        last_align_mode = cfg.get("align_corners_mode", "False")
+        last_recompute_mode = cfg.get("recompute_scale_factor_mode", "False")
+        last_simple_mode = cfg.get("simple_mode", True)
+
+        with gr.Accordion(label="Kohya Hires.fix", open=False):
+            with gr.Row():
+                enable = gr.Checkbox(label="Включить расширение", value=False)
+                algo_mode = gr.Radio(
+                    choices=["Enhanced (RU+)", "Legacy (Original)"],
+                    value=last_algo_mode,
+                    label="Алгоритм работы / Algorithm Mode",
+                )
+
+            with gr.Row():
+                simple_mode = gr.Checkbox(
+                    label="Простой режим (скрыть продвинутые настройки)",
+                    value=last_simple_mode,
+                )
+
+            # ---- Предустановленные разрешения ----
+            with gr.Group():
+                gr.Markdown("**Предустановленные разрешения**")
+                with gr.Row():
+                    resolution_choice = gr.Dropdown(
+                        choices=RESOLUTION_CHOICES,
+                        value=last_resolution_choice,
+                        label="Выбрать разрешение",
+                    )
+                    apply_resolution = gr.Checkbox(
+                        label="Применить разрешение к width/height",
+                        value=last_apply_resolution,
+                    )
+
+            # ---- Базовые параметры ----
+            with gr.Group():
+                gr.Markdown("**Базовые параметры hires.fix**")
+                with gr.Row():
+                    s1 = gr.Slider(0.0, 0.5, step=0.01, label="Остановить на (доля шага) — Пара 1", value=last_s1)
+                    d1 = gr.Slider(1, 10, step=1, label="Глубина блока — Пара 1", value=last_d1)
+                with gr.Row():
+                    s2 = gr.Slider(0.0, 0.5, step=0.01, label="Остановить на (доля шага) — Пара 2", value=last_s2)
+                    d2 = gr.Slider(1, 10, step=1, label="Глубина блока — Пара 2", value=last_d2)
+
+                with gr.Row():
+                    scaler = gr.Dropdown(
+                        choices=["bicubic", "bilinear", "nearest", "nearest-exact"],
+                        label="Режим интерполяции слоя",
+                        value=last_scaler,
+                    )
+                    downscale = gr.Slider(0.1, 1.0, step=0.05, label="Коэффициент даунскейла (вход)", value=last_downscale)
+                    upscale = gr.Slider(1.0, 4.0, step=0.1, label="Коэффициент апскейла (выход)", value=last_upscale)
+
+                with gr.Row():
+                    smooth_scaling_enh = gr.Checkbox(
+                        label="Плавное изменение масштаба (Enhanced)",
+                        value=last_smooth_enh,
+                        visible=(last_algo_mode == "Enhanced (RU+)")
+                    )
+                    smooth_scaling_legacy = gr.Checkbox(
+                        label="Плавное изменение масштаба (Legacy old)",
+                        value=last_smooth_leg,
+                        visible=(last_algo_mode == "Legacy (Original)")
+                    )
+                    smoothing_curve = gr.Dropdown(
+                        choices=["Линейная", "Smoothstep"],
+                        value=last_smoothing_curve,
+                        label="Кривая сглаживания (только Enhanced)",
+                        visible=True
+                    )
+                    keep_unitary_product = gr.Checkbox(
+                        label="Сохранять суммарный масштаб = 1 (только Enhanced)",
+                        value=last_keep1,
+                    )
+
+                with gr.Row():
+                    early_out = gr.Checkbox(label="Ранний апскейл (Early Out)", value=last_early_out)
+                    only_one_pass_enh = gr.Checkbox(
+                        label="Только один проход (Enhanced)",
+                        value=last_only_enh,
+                        visible=(last_algo_mode == "Enhanced (RU+)")
+                    )
+                    only_one_pass_legacy = gr.Checkbox(
+                        label="Только один проход (Legacy old)",
+                        value=last_only_leg,
+                        visible=(last_algo_mode == "Legacy (Original)")
+                    )
+
+            # ---- Продвинутые настройки ----
+            with gr.Group(visible=not last_simple_mode) as advanced_group:
+                with gr.Group():
+                    gr.Markdown("**Интерполяция (только Enhanced)**")
+                    with gr.Row():
+                        align_corners_mode = gr.Dropdown(
+                            choices=["False", "True", "Авто"],
+                            value=last_align_mode,
+                            label="align_corners режим",
+                        )
+                        recompute_scale_factor_mode = gr.Dropdown(
+                            choices=["False", "True", "Авто"],
+                            value=last_recompute_mode,
+                            label="recompute_scale_factor режим",
+                        )
+
+                with gr.Group():
+                    gr.Markdown("**Адаптация под разрешение**")
+                    with gr.Row():
+                        adaptive_by_resolution = gr.Checkbox(
+                            label="Адаптировать параметры под текущее разрешение",
+                            value=last_adaptive_by_resolution,
+                        )
+                        adaptive_profile = gr.Dropdown(
+                            choices=["Консервативный", "Сбалансированный", "Агрессивный"],
+                            value=last_adaptive_profile,
+                            label="Профиль адаптации",
+                        )
+                    preview_md = gr.Markdown("Нажмите кнопку ниже для предпросмотра параметров.")
+                    btn_preview = gr.Button("Показать рассчитанные параметры", variant="secondary")
+
+                # Пресеты
+                with gr.Group():
+                    gr.Markdown("**Пресеты**")
+                    with gr.Row():
+                        preset_category_filter = gr.Dropdown(
+                            choices=["Все"] + pm.categories(),
+                            value="Все",
+                            label="Категория (фильтр)",
+                        )
+                        preset_select = gr.Dropdown(
+                            choices=pm.names_for_category(None),
+                            value=None,
+                            label="Выбрать пресет",
+                        )
+
+                    with gr.Row():
+                        preset_name = gr.Textbox(label="Имя пресета", placeholder="имя...", value="")
+                        preset_category_input = gr.Textbox(label="Категория", placeholder="Общие...", value="Общие")
+
+                    with gr.Row():
+                        btn_save = gr.Button("Сохранить", variant="primary")
+                        btn_load = gr.Button("Загрузить")
+                        btn_delete = gr.Button("Удалить", variant="stop")
+
+                    preset_status = gr.Markdown("")
+
+            # --- Логика UI ---
+
+            def _toggle_mode(is_simple: bool):
+                return gr.update(visible=not is_simple)
+
+            simple_mode.change(_toggle_mode, inputs=[simple_mode], outputs=[advanced_group])
+
+            def _toggle_algo_vis(mode: str):
+                is_enh = (mode == "Enhanced (RU+)")
+                return (
+                    gr.update(visible=is_enh),          # smooth_scaling_enh
+                    gr.update(visible=not is_enh),      # smooth_scaling_legacy
+                    gr.update(visible=is_enh),          # smoothing_curve
+                    gr.update(visible=is_enh),          # keep_unitary_product
+                    gr.update(visible=is_enh),          # align_corners_mode
+                    gr.update(visible=is_enh),          # recompute_scale_factor_mode
+                    gr.update(visible=is_enh),          # only_one_pass_enh
+                    gr.update(visible=not is_enh),      # only_one_pass_legacy
+                )
+
+            algo_mode.change(
+                _toggle_algo_vis,
+                inputs=[algo_mode],
+                outputs=[
+                    smooth_scaling_enh,
+                    smooth_scaling_legacy,
+                    smoothing_curve,
+                    keep_unitary_product,
+                    align_corners_mode,
+                    recompute_scale_factor_mode,
+                    only_one_pass_enh,
+                    only_one_pass_legacy,
+                ]
+            )
+
+            # Пресеты
+            def _update_preset_list_for_category(cat: str):
+                pm.reload()
+                return gr.update(choices=pm.names_for_category(cat), value=None)
+
+            preset_category_filter.change(
+                _update_preset_list_for_category, inputs=[preset_category_filter], outputs=[preset_select]
+            )
+
+            def _save_preset_cb(
+                name, cat_in, cat_filt,
+                mode, d1_v, d2_v, s1_v, s2_v,
+                scl, dw, up,
+                sm_enh, sm_leg,
+                sm_c, eo,
+                one_enh, one_leg,
+                k1, al, rc,
+                res, app, ad, ad_p
+            ):
+                name = (name or "").strip()
+                if not name:
+                    return gr.update(), gr.update(), "⚠️ Имя?"
+                cat = (cat_in or "").strip() or (cat_filt if cat_filt != "Все" else "Общие")
+
+                base = HiresPreset().to_dict()
+                base.update({
+                    "category": cat, "algo_mode": mode,
+                    "d1": int(d1_v), "d2": int(d2_v),
+                    "s1": float(s1_v), "s2": float(s2_v),
+                    "scaler": str(scl), "downscale": float(dw), "upscale": float(up),
+                    "smooth_scaling_enh": bool(sm_enh),
+                    "smooth_scaling_legacy": bool(sm_leg),
+                    "smoothing_curve": str(sm_c),
+                    "early_out": bool(eo),
+                    "only_one_pass_enh": bool(one_enh),
+                    "only_one_pass_legacy": bool(one_leg),
+                    "keep_unitary_product": bool(k1),
+                    "align_corners_mode": str(al),
+                    "recompute_scale_factor_mode": str(rc),
+                    "resolution_choice": str(res),
+                    "apply_resolution": bool(app),
+                    "adaptive_by_resolution": bool(ad),
+                    "adaptive_profile": str(ad_p),
+                })
+                pm.upsert(name, HiresPreset(**base))
+                cats = ["Все"] + pm.categories()
+                return (
+                    gr.update(choices=cats, value=cat),
+                    gr.update(choices=pm.names_for_category(cat), value=name),
+                    f"✅ Сохранён «{name}».",
+                )
+
+            def _load_preset_cb(name):
+                name = (name or "").strip()
+                pm.reload()
+                preset = pm.get(name)
+                if not preset:
+                    # 24 полей + текст
+                    return (*[gr.update()]*24, f"⚠️ Не найден: {name}")
+                p = preset.to_dict()
+                return (
+                    p.get("algo_mode", "Enhanced (RU+)"),
+                    int(p.get("d1", 3)),
+                    int(p.get("d2", 4)),
+                    float(p.get("s1", 0.15)),
+                    float(p.get("s2", 0.30)),
+                    str(p.get("scaler", "bicubic")),
+                    float(p.get("downscale", 0.5)),
+                    float(p.get("upscale", 2.0)),
+                    bool(p.get("smooth_scaling_enh", True)),
+                    bool(p.get("smooth_scaling_legacy", True)),
+                    str(p.get("smoothing_curve", "Линейная")),
+                    bool(p.get("early_out", False)),
+                    bool(p.get("only_one_pass_enh", True)),
+                    bool(p.get("only_one_pass_legacy", True)),
+                    bool(p.get("keep_unitary_product", False)),
+                    str(p.get("align_corners_mode", "False")),
+                    str(p.get("recompute_scale_factor_mode", "False")),
+                    str(p.get("resolution_choice", RESOLUTION_CHOICES[0])),
+                    bool(p.get("apply_resolution", False)),
+                    bool(p.get("adaptive_by_resolution", True)),
+                    str(p.get("adaptive_profile", "Сбалансированный")),
+                    gr.update(value=name),
+                    gr.update(value=p.get("category", "Общие")),
+                    f"✅ Загружен «{name}».",
+                )
+
+            def _delete_preset_cb(name, cat_filt):
+                pm.delete(name)
+                cats = ["Все"] + pm.categories()
+                return (
+                    gr.update(choices=cats, value=cat_filt),
+                    gr.update(choices=pm.names_for_category(cat_filt), value=None),
+                    f"🗑️ Удалён «{name}».",
+                )
+
+            btn_save.click(
+                _save_preset_cb,
+                inputs=[
+                    preset_name, preset_category_input, preset_category_filter,
+                    algo_mode, d1, d2, s1, s2,
+                    scaler, downscale, upscale,
+                    smooth_scaling_enh, smooth_scaling_legacy,
+                    smoothing_curve, early_out,
+                    only_one_pass_enh, only_one_pass_legacy,
+                    keep_unitary_product, align_corners_mode, recompute_scale_factor_mode,
+                    resolution_choice, apply_resolution,
+                    adaptive_by_resolution, adaptive_profile,
+                ],
+                outputs=[preset_category_filter, preset_select, preset_status],
+            )
+
+            btn_load.click(
+                _load_preset_cb,
+                inputs=[preset_select],
+                outputs=[
+                    algo_mode,
+                    d1, d2,
+                    s1, s2,
+                    scaler,
+                    downscale, upscale,
+                    smooth_scaling_enh, smooth_scaling_legacy,
+                    smoothing_curve,
+                    early_out,
+                    only_one_pass_enh, only_one_pass_legacy,
+                    keep_unitary_product,
+                    align_corners_mode, recompute_scale_factor_mode,
+                    resolution_choice, apply_resolution,
+                    adaptive_by_resolution, adaptive_profile,
+                    preset_name, preset_category_input,
+                    preset_status,
+                ],
+            )
+
+            btn_delete.click(
+                _delete_preset_cb,
+                inputs=[preset_select, preset_category_filter],
+                outputs=[preset_category_filter, preset_select, preset_status],
+            )
+
+            def _preview_cb(
+                res_v, adapt_v, adapt_prof_v,
+                s1_v, s2_v, d1_v, d2_v,
+                down_v, up_v, keep1_v, mode_v
+            ):
+                wh = parse_resolution_label(res_v)
+                w, h = wh if wh else (1024, 1024)
+
+                if adapt_v:
+                    try:
+                        u_s1, u_s2, u_d1, u_d2, u_down, u_up = _compute_adaptive_params(
+                            w, h, adapt_prof_v,
+                            s1_v, s2_v, d1_v, d2_v,
+                            down_v, up_v, keep1_v
+                        )
+                    except Exception:
+                        u_s1, u_s2, u_d1, u_d2, u_down, u_up = s1_v, s2_v, d1_v, d2_v, down_v, up_v
+                else:
+                    u_s1, u_s2, u_d1, u_d2, u_down, u_up = s1_v, s2_v, d1_v, d2_v, down_v, up_v
+
+                return (
+                    f"**Mode:** {mode_v}\n"
+                    f"**Res:** {w}x{h}\n"
+                    f"**S1:** {u_s1:.2f}, **D1:** {u_d1}\n"
+                    f"**S2:** {u_s2:.2f}, **D2:** {u_d2}\n"
+                    f"**Down:** {u_down:.2f}, **Up:** {u_up:.2f}"
+                )
+
+            btn_preview.click(
+                _preview_cb,
+                inputs=[
+                    resolution_choice,
+                    adaptive_by_resolution, adaptive_profile,
+                    s1, s2, d1, d2,
+                    downscale, upscale,
+                    keep_unitary_product,
+                    algo_mode,
+                ],
+                outputs=[preview_md],
+            )
+
+        # Infotext
+        self.infotext_fields.append((enable, lambda d: d.get("DSHF_s1", False)))
+        for k, el in {
+            "DSHF_mode": algo_mode,
+            "DSHF_s1": s1,
+            "DSHF_d1": d1,
+            "DSHF_s2": s2,
+            "DSHF_d2": d2,
+            "DSHF_scaler": scaler,
+            "DSHF_down": downscale,
+            "DSHF_up": upscale,
+            "DSHF_smooth_enh": smooth_scaling_enh,
+            "DSHF_smooth_legacy": smooth_scaling_legacy,
+            "DSHF_early": early_out,
+            "DSHF_one_enh": only_one_pass_enh,
+            "DSHF_one_legacy": only_one_pass_legacy,
+        }.items():
+            self.infotext_fields.append((el, k))
+
+        return [
+            enable,
+            simple_mode,
+            algo_mode,
+            only_one_pass_enh,
+            only_one_pass_legacy,
+            d1, d2,
+            s1, s2,
+            scaler,
+            downscale, upscale,
+            smooth_scaling_enh, smooth_scaling_legacy,
+            smoothing_curve,
+            early_out,
+            keep_unitary_product,
+            align_corners_mode, recompute_scale_factor_mode,
+            resolution_choice, apply_resolution,
+            adaptive_by_resolution, adaptive_profile,
+        ]
+
+    def process(
+        self, p,
+        enable, simple, algo_mode,
+        only_one_pass_enh, only_one_pass_legacy,
+        d1, d2, s1, s2,
+        scaler, downscale, upscale,
+        smooth_scaling_enh, smooth_scaling_legacy,
+        smoothing_curve,
+        early_out,
+        keep_unitary_product,
+        align_ui, recompute_ui,
+        res_choice, apply_res,
+        adapt, adapt_prof
+    ):
+        self.step_limit = 0
+        self.config = DictConfig({
+            "algo_mode": algo_mode,
+            "simple_mode": simple,
+            "s1": s1,
+            "s2": s2,
+            "d1": d1,
+            "d2": d2,
+            "scaler": scaler,
+            "downscale": downscale,
+            "upscale": upscale,
+            "smooth_scaling_enh": smooth_scaling_enh,
+            "smooth_scaling_legacy": smooth_scaling_legacy,
+            "smoothing_curve": smoothing_curve,
+            "early_out": early_out,
+            "only_one_pass_enh": only_one_pass_enh,
+            "only_one_pass_legacy": only_one_pass_legacy,
+            "keep_unitary_product": keep_unitary_product,
+            "align_corners_mode": align_ui,
+            "recompute_scale_factor_mode": recompute_ui,
+            "resolution_choice": res_choice,
+            "apply_resolution": apply_res,
+            "adaptive_by_resolution": adapt,
+            "adaptive_profile": adapt_prof,
+        })
+
+        if apply_res:
+            wh = parse_resolution_label(res_choice)
+            if wh:
+                p.width, p.height = wh
+
+        # Если выключено или скрипт помечен как сломанный — снимаем всё и выходим
+        if not enable or self.disable:
+            try:
+                script_callbacks.remove_current_script_callbacks()
+            except Exception:
+                pass
+            self._cb_registered = False
+            try:
+                model_container = getattr(p.sd_model, "model", None)
+                if model_container is not None and hasattr(model_container, "diffusion_model"):
+                    KohyaHiresFix._unwrap_all(model_container.diffusion_model)
+            except Exception:
+                pass
+            return
+
+        # --- Адаптация параметров ---
+        use_s1, use_s2 = float(s1), float(s2)
+        use_d1, use_d2 = int(d1), int(d2)
+        use_down, use_up = float(downscale), float(upscale)
+
+        if adapt:
+            try:
+                use_s1, use_s2, use_d1, use_d2, use_down, use_up = _compute_adaptive_params(
+                    int(getattr(p, "width", 1024)),
+                    int(getattr(p, "height", 1024)),
+                    adapt_prof,
+                    s1, s2, d1, d2,
+                    downscale, upscale,
+                    keep_unitary_product,
+                )
+            except Exception:
+                pass
+
+        if use_s1 > use_s2:
+            use_s2 = use_s1
+
+        model_container = getattr(p.sd_model, "model", None)
+        if not model_container or not hasattr(model_container, "diffusion_model"):
+            return
+        model = model_container.diffusion_model
+        max_inp = len(getattr(model, "input_blocks", [])) - 1
+
+        d1_idx = max(0, min(int(use_d1) - 1, max_inp))
+        d2_idx = max(0, min(int(use_d2) - 1, max_inp))
+        scaler_mode = _safe_mode(scaler)
+
+        if algo_mode == "Legacy (Original)":
+            align_mode = "false"
+            recompute_mode = "false"
+        else:
+            align_mode = _norm_mode_choice(align_ui, "auto")
+            recompute_mode = _norm_mode_choice(recompute_ui, "auto")
+
+        use_smooth_enh = bool(smooth_scaling_enh)
+        use_smooth_legacy = bool(smooth_scaling_legacy)
+        use_one_enh = bool(only_one_pass_enh)
+        use_one_legacy = bool(only_one_pass_legacy)
+
+        def denoiser_callback(params: script_callbacks.CFGDenoiserParams):
+            total = max(1, int(params.total_sampling_steps))
+            current = params.sampling_step
+
+            try:
+                # ========================= LEGACY (ORIGINAL) MODE =========================
+                if algo_mode == "Legacy (Original)":
+                    if use_one_legacy and self.step_limit:
+                        return
+
+                    legacy_pairs = [(use_s1, d1_idx), (use_s2, d2_idx)]
+
+                    n_out = len(model.output_blocks)
+
+                    for s_stop, d_idx in legacy_pairs:
+                        if s_stop <= 0:
+                            continue
+
+                        if d_idx < 0 or d_idx >= len(model.input_blocks):
+                            continue
+
+                        if early_out:
+                            out_idx = d_idx
+                        else:
+                            out_idx = n_out - 1 - d_idx
+
+                        if out_idx < 0 or out_idx >= n_out:
+                            continue
+
+                        if current < total * s_stop:
+                            # вставить Scaler
+                            if not isinstance(model.input_blocks[d_idx], Scaler):
+                                model.input_blocks[d_idx] = Scaler(
+                                    use_down,
+                                    model.input_blocks[d_idx],
+                                    scaler_mode,
+                                    align_mode,
+                                    recompute_mode,
+                                )
+                                model.output_blocks[out_idx] = Scaler(
+                                    use_up,
+                                    model.output_blocks[out_idx],
+                                    scaler_mode,
+                                    align_mode,
+                                    recompute_mode,
+                                )
+                            elif use_smooth_legacy:
+                                # старая математика smooth_scaling (как в khrfix_old.py)
+                                scale_ratio = current / (total * s_stop)
+                                cur_down = min((1.0 - use_down) * scale_ratio + use_down, 1.0)
+                                model.input_blocks[d_idx].scale = cur_down
+                                model.output_blocks[out_idx].scale = use_up * (
+                                    use_down / max(1e-6, cur_down)
+                                )
+                            return
+
+                        elif isinstance(model.input_blocks[d_idx], Scaler):
+                            is_p2 = (s_stop == use_s2 and d_idx == d2_idx)
+                            if d1_idx != d2_idx or is_p2:
+                                model.input_blocks[d_idx] = model.input_blocks[d_idx].block
+                                model.output_blocks[out_idx] = model.output_blocks[out_idx].block
+
+                    if use_one_legacy and current > 0:
+                        if current >= total * max(use_s1, use_s2):
+                            self.step_limit = 1
+
+                # ========================= ENHANCED (RU+) MODE =========================
+                else:
+                    if use_one_enh and self.step_limit:
+                        return
+
+                    combined: Dict[int, float] = {}
+                    for s_stop, d_i in ((float(use_s1), d1_idx), (float(use_s2), d2_idx)):
+                        if s_stop > 0:
+                            combined[d_i] = max(combined.get(d_i, 0.0), s_stop)
+
+                    max_stop = max(combined.values()) if combined else 0.0
+
+                    for d_i, s_stop in combined.items():
+                        out_i = KohyaHiresFix._map_output_index(model, d_i, early_out)
+                        if out_i is None:
+                            continue
+
+                        if current < total * s_stop:
+                            if not isinstance(model.input_blocks[d_i], Scaler):
+                                model.input_blocks[d_i] = Scaler(
+                                    use_down,
+                                    model.input_blocks[d_i],
+                                    scaler_mode,
+                                    align_mode,
+                                    recompute_mode,
+                                )
+                                model.output_blocks[out_i] = Scaler(
+                                    use_up,
+                                    model.output_blocks[out_i],
+                                    scaler_mode,
+                                    align_mode,
+                                    recompute_mode,
+                                )
+
+                            if use_smooth_enh:
+                                ratio = float(max(0.0, min(1.0, current / (total * s_stop))))
+                                if (smoothing_curve or "").lower().startswith("smooth"):
+                                    ratio = ratio * ratio * (3.0 - 2.0 * ratio)
+
+                                cur_down = min((1.0 - use_down) * ratio + use_down, 1.0)
+                                model.input_blocks[d_i].scale = cur_down
+
+                                if keep_unitary_product:
+                                    cur_up = 1.0 / max(1e-6, cur_down)
+                                else:
+                                    cur_up = use_up * (use_down / max(1e-6, cur_down))
+                                    cur_up = _clamp(cur_up, 1.0, 4.0)
+
+                                model.output_blocks[out_i].scale = cur_up
+                            else:
+                                model.input_blocks[d_i].scale = use_down
+                                model.output_blocks[out_i].scale = use_up
+                        else:
+                            if isinstance(model.input_blocks[d_i], Scaler):
+                                model.input_blocks[d_i] = model.input_blocks[d_i].block
+                                model.output_blocks[out_i] = model.output_blocks[out_i].block
+
+                    if use_one_enh and max_stop > 0 and current >= total * max_stop:
+                        self.step_limit = 1
+
+            except Exception as e:
+                # Если что-то пошло не так — аккуратно откатываемся и выключаем скрипт
+                try:
+                    KohyaHiresFix._unwrap_all(model)
+                except Exception:
+                    pass
+                try:
+                    script_callbacks.remove_current_script_callbacks()
+                except Exception:
+                    pass
+                self._cb_registered = False
+                self.disable = True
+                print(f"[KohyaHiresFix Unified] Disabled after error: {type(e).__name__}: {e}")
+
+        if self._cb_registered:
+            try:
+                script_callbacks.remove_current_script_callbacks()
+            except Exception:
+                pass
+
+        script_callbacks.on_cfg_denoiser(denoiser_callback)
+        self._cb_registered = True
+
+        p.extra_generation_params.update({
+            "DSHF_mode": algo_mode,
+            "DSHF_s1": use_s1,
+            "DSHF_s2": use_s2,
+            "DSHF_down": use_down,
+            "DSHF_up": use_up,
+        })
+
+    def postprocess(self, p, processed, *args):
+        try:
+            model_container = getattr(p.sd_model, "model", None)
+            if model_container and hasattr(model_container, "diffusion_model"):
+                KohyaHiresFix._unwrap_all(model_container.diffusion_model)
+        finally:
+            try:
+                _atomic_save_yaml(
+                    CONFIG_PATH,
+                    OmegaConf.to_container(self.config, resolve=True) or {},
+                )
+            except Exception:
+                pass
+            self._cb_registered = False
+
+    def process_batch(self, p, *args, **kwargs):
+        self.step_limit = 0

sd-webui-kohya-hiresfix-saveable2.2/scripts/khrfix.yaml

@@ -0,0 +1,22 @@
+algo_mode: Enhanced (RU+)
+simple_mode: true
+s1: 0.15
+s2: 0.3
+d1: 3
+d2: 4
+scaler: bicubic
+downscale: 0.85
+upscale: 2
+smooth_scaling_enh: true
+smooth_scaling_legacy: true
+smoothing_curve: Smoothstep
+early_out: true
+only_one_pass_enh: true
+only_one_pass_legacy: true
+keep_unitary_product: false
+align_corners_mode: Авто
+recompute_scale_factor_mode: Авто
+resolution_choice: — не применять —
+apply_resolution: false
+adaptive_by_resolution: false
+adaptive_profile: Консервативный