Upload sd-webui-xl_vec using SD-Hub

.gitattributes

@@ -166,3 +166,6 @@ outputs/txt2img-images/2025-09-13/00014-1035.png filter=lfs diff=lfs merge=lfs -
 outputs/txt2img-images/2025-09-13/00015-1323.png filter=lfs diff=lfs merge=lfs -text
 outputs/txt2img-images/2025-09-13/00016-1728.png filter=lfs diff=lfs merge=lfs -text
 outputs/txt2img-images/2025-09-13/00017-2053.png filter=lfs diff=lfs merge=lfs -text
+sd-webui-xl_vec/images/crop_top.png filter=lfs diff=lfs merge=lfs -text
+sd-webui-xl_vec/images/mult.png filter=lfs diff=lfs merge=lfs -text
+sd-webui-xl_vec/images/original_size.png filter=lfs diff=lfs merge=lfs -text

sd-webui-xl_vec/.gitignore

@@ -0,0 +1,2 @@
+__pycache__
+/.vs

sd-webui-xl_vec/README.md

@@ -0,0 +1,37 @@
+# XL Vec
+
+## What is this?
+
+This is an extension for [stable-diffusion-webui](https://github.com/AUTOMATIC1111/stable-diffusion-webui) which overwrites SDXL's CLIP outputs.
+
+## Usage
+
+Input values as you like.
+
+![GUI](images/gui.png)
+
+Overwritten values are dumped into stdout.
+
+![stdout](images/log.png)
+
+## Examples
+
+```
+Hassaku XL alphaV0.7 / DPM++ 3M SDE / 30 steps / 576x1024
+Prompt: a cute girl sitting in flower garden, clear anime face, insanely frilled white dress, absurdly long brown hair, small silver tiara, long sleeves highneck dress, looking at viewer
+Negative Prompt: maid
+```
+
+See PNGInfo for details.
+
+### Crop Top
+
+![Crop top](images/crop_top.png)
+
+### Original Width/Height
+
+![Original Width/Height](images/original_size.png)
+
+### Token Multiplier
+
+![Token Multiplier](images/mult.png)

sd-webui-xl_vec/scripts/sdhook.py

@@ -0,0 +1,279 @@
+import sys
+from typing import Any, Callable, Union
+
+from torch import nn
+from torch.utils.hooks import RemovableHandle
+
+from ldm.modules.diffusionmodules.openaimodel import (
+    TimestepEmbedSequential,
+)
+from ldm.modules.attention import (
+    SpatialTransformer,
+    BasicTransformerBlock,
+    CrossAttention,
+    MemoryEfficientCrossAttention,
+)
+from ldm.modules.diffusionmodules.openaimodel import (
+    ResBlock,
+)
+from modules.processing import StableDiffusionProcessing
+from modules import shared
+
+class ForwardHook:
+    
+    def __init__(self, module: nn.Module, fn: Callable[[nn.Module, Callable[..., Any], Any], Any]):
+        self.o = module.forward
+        self.fn = fn
+        self.module = module
+        self.module.forward = self.forward
+    
+    def remove(self):
+        if self.module is not None and self.o is not None:
+            self.module.forward = self.o
+            self.module = None
+            self.o = None
+        self.fn = None
+    
+    def forward(self, *args, **kwargs):
+        if self.module is not None and self.o is not None:
+            if self.fn is not None:
+                return self.fn(self.module, self.o, *args, **kwargs)
+        return None
+        
+
+class SDHook:
+    
+    def __init__(self, enabled: bool):
+        self._enabled = enabled
+        self._handles: list[Union[RemovableHandle,ForwardHook]] = []
+    
+    @property
+    def enabled(self):
+        return self._enabled
+    
+    @enabled.setter
+    def enabled(self, v: bool):
+        self._enabled = bool(v)
+    
+    @property
+    def batch_num(self):
+        return shared.state.job_no
+    
+    @property
+    def step_num(self):
+        return shared.state.current_image_sampling_step
+    
+    def __enter__(self):
+        if self.enabled:
+            pass
+    
+    def __exit__(self, exc_type, exc_value, traceback):
+        if self.enabled:
+            for handle in self._handles:
+                handle.remove()
+            self._handles.clear()
+            self.dispose()
+    
+    def dispose(self):
+        pass
+    
+    def setup(
+        self,
+        p: StableDiffusionProcessing
+    ):
+        if not self.enabled:
+            return
+        
+        wrapper = getattr(p.sd_model, "model", None)
+        
+        unet: Union[nn.Module,None] = getattr(wrapper, "diffusion_model", None) if wrapper is not None else None
+        vae: Union[nn.Module,None] = getattr(p.sd_model, "first_stage_model", None)
+        clip: Union[nn.Module,None] = getattr(p.sd_model, "cond_stage_model", None)
+        
+        assert unet is not None, "p.sd_model.diffusion_model is not found. broken model???"
+        self._do_hook(p, p.sd_model, unet=unet, vae=vae, clip=clip) # type: ignore
+        self.on_setup()
+    
+    def on_setup(self):
+        pass
+    
+    def _do_hook(
+        self,
+        p: StableDiffusionProcessing,
+        model: Any,
+        unet: Union[nn.Module,None],
+        vae: Union[nn.Module,None],
+        clip: Union[nn.Module,None]
+    ):
+        assert model is not None, "empty model???"
+        
+        if clip is not None:
+            self.hook_clip(p, clip)
+        
+        if unet is not None:
+            self.hook_unet(p, unet)
+        
+        if vae is not None:
+            self.hook_vae(p, vae)
+    
+    def hook_vae(
+        self,
+        p: StableDiffusionProcessing,
+        vae: nn.Module
+    ):
+        pass
+
+    def hook_unet(
+        self,
+        p: StableDiffusionProcessing,
+        unet: nn.Module
+    ):
+        pass
+
+    def hook_clip(
+        self,
+        p: StableDiffusionProcessing,
+        clip: nn.Module
+    ):
+        pass
+
+    def hook_layer(
+        self,
+        module: Union[nn.Module,Any],
+        fn: Callable[[nn.Module, tuple, Any], Any]
+    ):
+        if not self.enabled:
+            return
+        
+        assert module is not None
+        assert isinstance(module, nn.Module)
+        self._handles.append(module.register_forward_hook(fn))
+
+    def hook_layer_pre(
+        self,
+        module: Union[nn.Module,Any],
+        fn: Callable[[nn.Module, tuple], Any]
+    ):
+        if not self.enabled:
+            return
+        
+        assert module is not None
+        assert isinstance(module, nn.Module)
+        self._handles.append(module.register_forward_pre_hook(fn))
+
+    def hook_forward(
+        self,
+        module: Union[nn.Module,Any],
+        fn: Callable[[nn.Module, Callable[..., Any], Any], Any]
+    ):
+        assert module is not None
+        assert isinstance(module, nn.Module)
+        self._handles.append(ForwardHook(module, fn))
+    
+    def log(self, msg: str):
+        print(msg, file=sys.stderr)
+
+
+# enumerate SpatialTransformer in TimestepEmbedSequential 
+def each_transformer(unet_block: TimestepEmbedSequential):
+    for block in unet_block.children():
+        if isinstance(block, SpatialTransformer):
+            yield block
+
+# enumerate BasicTransformerBlock in SpatialTransformer
+def each_basic_block(trans: SpatialTransformer):
+    for block in trans.transformer_blocks.children():
+        if isinstance(block, BasicTransformerBlock):
+            yield block
+
+# enumerate Attention Layers in TimestepEmbedSequential
+# each_transformer + each_basic_block
+def each_attns(unet_block: TimestepEmbedSequential):
+    for n, trans in enumerate(each_transformer(unet_block)):
+        for depth, basic_block in enumerate(each_basic_block(trans)):
+            # attn1: Union[CrossAttention,MemoryEfficientCrossAttention]
+            # attn2: Union[CrossAttention,MemoryEfficientCrossAttention]
+            
+            attn1, attn2 = basic_block.attn1, basic_block.attn2
+            assert isinstance(attn1, CrossAttention) or isinstance(attn1, MemoryEfficientCrossAttention)
+            assert isinstance(attn2, CrossAttention) or isinstance(attn2, MemoryEfficientCrossAttention)
+            
+            yield n, depth, attn1, attn2
+
+def each_unet_attn_layers(unet: nn.Module):
+    def get_attns(layer_index: int, block: TimestepEmbedSequential, format: str):
+        for n, d, attn1, attn2 in each_attns(block):
+            kwargs = {
+                'layer_index': layer_index,
+                'trans_index': n,
+                'block_index': d
+            }
+            yield format.format(attn_name='sattn', **kwargs), attn1
+            yield format.format(attn_name='xattn', **kwargs), attn2
+    
+    def enumerate_all(blocks: nn.ModuleList, format: str):
+        for idx, block in enumerate(blocks.children()):
+            if isinstance(block, TimestepEmbedSequential):
+                yield from get_attns(idx, block, format)
+    
+    inputs: nn.ModuleList = unet.input_blocks           # type: ignore
+    middle: TimestepEmbedSequential = unet.middle_block # type: ignore
+    outputs: nn.ModuleList = unet.output_blocks         # type: ignore
+    
+    yield from enumerate_all(inputs, 'IN{layer_index:02}_{trans_index:02}_{block_index:02}_{attn_name}')
+    yield from get_attns(0, middle, 'M{layer_index:02}_{trans_index:02}_{block_index:02}_{attn_name}')
+    yield from enumerate_all(outputs, 'OUT{layer_index:02}_{trans_index:02}_{block_index:02}_{attn_name}')
+
+
+def each_unet_transformers(unet: nn.Module):
+    def get_trans(layer_index: int, block: TimestepEmbedSequential, format: str):
+        for n, trans in enumerate(each_transformer(block)):
+            kwargs = {
+                'layer_index': layer_index,
+                'block_index': n,
+                'block_name': 'trans',
+            }
+            yield format.format(**kwargs), trans
+    
+    def enumerate_all(blocks: nn.ModuleList, format: str):
+        for idx, block in enumerate(blocks.children()):
+            if isinstance(block, TimestepEmbedSequential):
+                yield from get_trans(idx, block, format)
+    
+    inputs: nn.ModuleList = unet.input_blocks           # type: ignore
+    middle: TimestepEmbedSequential = unet.middle_block # type: ignore
+    outputs: nn.ModuleList = unet.output_blocks         # type: ignore
+    
+    yield from enumerate_all(inputs, 'IN{layer_index:02}_{block_index:02}_{block_name}')
+    yield from get_trans(0, middle, 'M{layer_index:02}_{block_index:02}_{block_name}')
+    yield from enumerate_all(outputs, 'OUT{layer_index:02}_{block_index:02}_{block_name}')
+
+
+def each_resblock(unet_block: TimestepEmbedSequential):
+    for block in unet_block.children():
+        if isinstance(block, ResBlock):
+            yield block
+
+def each_unet_resblock(unet: nn.Module):
+    def get_resblock(layer_index: int, block: TimestepEmbedSequential, format: str):
+        for n, res in enumerate(each_resblock(block)):
+            kwargs = {
+                'layer_index': layer_index,
+                'block_index': n,
+                'block_name': 'resblock',
+            }
+            yield format.format(**kwargs), res
+    
+    def enumerate_all(blocks: nn.ModuleList, format: str):
+        for idx, block in enumerate(blocks.children()):
+            if isinstance(block, TimestepEmbedSequential):
+                yield from get_resblock(idx, block, format)
+    
+    inputs: nn.ModuleList = unet.input_blocks           # type: ignore
+    middle: TimestepEmbedSequential = unet.middle_block # type: ignore
+    outputs: nn.ModuleList = unet.output_blocks         # type: ignore
+    
+    yield from enumerate_all(inputs, 'IN{layer_index:02}_{block_index:02}_{block_name}')
+    yield from get_resblock(0, middle, 'M{layer_index:02}_{block_index:02}_{block_name}')
+    yield from enumerate_all(outputs, 'OUT{layer_index:02}_{block_index:02}_{block_name}')
+

sd-webui-xl_vec/scripts/xl_clip.py

@@ -0,0 +1,48 @@
+import torch
+import open_clip
+
+try:
+    from sgm.modules import GeneralConditioner as CLIP_SDXL
+    from sgm.modules.encoders.modules import FrozenOpenCLIPEmbedder2
+    from modules.sd_hijack_open_clip import FrozenOpenCLIPEmbedder2WithCustomWords
+except:
+    print(f"[XL Vec] failed to load `sgm.modules`")
+    raise
+
+
+
+def get_pooled(clip: CLIP_SDXL, text: str, layer='last', index=-1):
+    # cf. sgm/modules/encoders/modules.py:FrozenOpenCLIPEmbedder2
+    
+    mod = clip.embedders[1]
+    if isinstance(mod, FrozenOpenCLIPEmbedder2WithCustomWords):
+        mod = mod.wrapped
+    
+    assert isinstance(mod, FrozenOpenCLIPEmbedder2)
+    
+    tokens = open_clip.tokenize([text]).to(mod.device)
+    
+    x = mod.model.token_embedding(tokens)  # [batch_size, n_ctx, d_model]
+    x = x + mod.model.positional_embedding
+    x = x.permute(1, 0, 2)  # NLD -> LND
+    x = mod.text_transformer_forward(x, attn_mask=mod.model.attn_mask)
+
+    o = x[layer]
+    o = mod.model.ln_final(o)
+    
+    eot = tokens.argmax(dim=-1)
+    p = torch.zeros_like(eot)
+    if 0 <= index:
+        p[0] = index
+    else:
+        p[0] = eot.item() + index + 1
+    
+    real_index = p.item()
+    assert 0 <= real_index < 77, f'index={index}, real_index={real_index}'
+        
+    pooled = (
+        o[torch.arange(o.shape[0]), p]
+        @ mod.model.text_projection
+    )
+    
+    return pooled, real_index

sd-webui-xl_vec/scripts/xl_vec.py

@@ -0,0 +1,473 @@
+NAME = 'XL Vec'
+
+import logging
+import traceback
+from threading import Lock
+from torch import Tensor, FloatTensor, nn
+import gradio as gr
+from modules.processing import StableDiffusionProcessing
+from modules import scripts
+
+from scripts.sdhook import SDHook
+from scripts.xl_clip import CLIP_SDXL, get_pooled
+from scripts.xl_vec_xyz import init_xyz
+
+# --- LOGGING ---
+logger = logging.getLogger(__name__)
+
+# --- CONSTANTS ---
+SDXL_POOLED_DIM = 1280       # Размер pooled embedding вектора SDXL
+AESTHETIC_SCORE_EPS = 0.01   # Допуск для сравнения float значений (aesthetic score)
+DEFAULT_AESTHETIC_SCORE = 6.0
+
+# --- PRESETS ---
+PRESETS = {
+    "Manual / Custom": None,
+    "1:1 Square (1024x1024)": (1024, 1024),
+    "4:3 Photo (1152x896)": (1152, 896),
+    "3:4 Portrait (896x1152)": (896, 1152),
+    "16:9 Cinema (1344x768)": (1344, 768),
+    "9:16 Mobile (768x1344)": (768, 1344),
+    "21:9 Wide (1536x640)": (1536, 640),
+    "2:3 Classic (832x1216)": (832, 1216),
+}
+
+
+def hook_input(args: 'Hook', mod: nn.Module, inputs: tuple[dict[str, Tensor]]) -> tuple[dict[str, Tensor]]:
+    """
+    Перехватывает входные данные CLIP модели для подмены параметров conditioning
+    (размеры, кроп, эстетическая оценка).
+    
+    Args:
+        args: Экземпляр Hook с параметрами
+        mod: CLIP модуль
+        inputs: Tuple с входными данными
+        
+    Returns:
+        Модифицированные входные данные
+    """
+    if not args.enabled:
+        return inputs
+    
+    assert isinstance(mod, CLIP_SDXL), f"Expected CLIP_SDXL, got {type(mod)}"
+    input_data = inputs[0]
+    
+    def create(v: list[float], src: FloatTensor) -> FloatTensor:
+        """Создает тензор с правильным device и dtype."""
+        return FloatTensor(v).to(dtype=src.dtype, device=src.device)
+    
+    def put(name: str, v: list[float]) -> None:
+        """Безопасно заменяет значение в input_data."""
+        if name in input_data:
+            src = input_data[name]
+            input_data[name] = create(v, src).reshape(src.shape)
+    
+    # Применяем геометрические параметры
+    put('original_size_as_tuple', [args.original_height, args.original_width])
+    put('crop_coords_top_left', [args.crop_top, args.crop_left])
+    put('target_size_as_tuple', [args.target_height, args.target_width])
+    
+    # Логика определения Positive/Negative промпта через Aesthetic Score
+    try:
+        current_score = input_data['aesthetic_score'].item()
+        if args.is_positive_prompt(current_score):
+            put('aesthetic_score', [args.aesthetic_score])
+        else:
+            put('aesthetic_score', [args.negative_aesthetic_score])
+    except (KeyError, AttributeError) as e:
+        logger.warning(f"[XL Vec] Cannot access aesthetic_score: {e}")
+    
+    return inputs
+
+
+def hook_output(args: 'Hook', mod: nn.Module, inputs: tuple[dict[str, Tensor]], output: dict) -> dict:
+    """
+    Перехватывает выход CLIP модели для замены векторов токенов.
+    
+    Args:
+        args: Экземпляр Hook с параметрами
+        mod: CLIP модуль
+        inputs: Входные данные
+        output: Выходные данные с ключом 'vector'
+        
+    Returns:
+        Модифицированные выходные данные
+    """
+    if not args.enabled:
+        return output
+    
+    try:
+        # Определяем, работаем ли мы с Positive или Negative промптом
+        current_score = inputs[0]['aesthetic_score'].item()
+        prompt, index, multiplier = args.get_prompt_params(current_score)
+        
+        # Если параметры не заданы пользователем, ничего не делаем
+        if (prompt is None or len(prompt) == 0) and (index == -1 and multiplier == 1.0):
+            return output
+
+        # Если текст замены не задан, используем оригинальный промпт
+        if prompt is None or len(prompt) == 0:
+            prompt = inputs[0]['txt'][0]
+        
+        assert isinstance(mod, CLIP_SDXL), f"Expected CLIP_SDXL, got {type(mod)}"
+        
+        # Получаем новый pooled embedding с защитой от рекурсии
+        with args._lock:
+            args.enabled = False
+            try:
+                pooled, token_idx = get_pooled(mod, prompt, index=index)
+            finally:
+                args.enabled = True
+        
+        # Подмена вектора с проверкой размерности
+        if output['vector'].shape[1] >= SDXL_POOLED_DIM:
+            output['vector'][:, 0:SDXL_POOLED_DIM] = pooled[:] * multiplier
+            logger.info(
+                f"[XL Vec] Vector override: '{inputs[0]['txt']}' -> '{prompt}' "
+                f"@ token {token_idx} [x{multiplier:.2f}]"
+            )
+        else:
+            logger.error(
+                f"[XL Vec] Vector dimension mismatch: expected >={SDXL_POOLED_DIM}, "
+                f"got {output['vector'].shape[1]}"
+            )
+
+    except Exception as e:
+        logger.error(f"[XL Vec] Error in hook_output: {e}")
+        traceback.print_exc()
+
+    return output
+
+
+class Hook(SDHook):
+    """Хук для модификации CLIP conditioning в SDXL."""
+    
+    def __init__(
+        self,
+        enabled: bool,
+        p: StableDiffusionProcessing,
+        crop_left: float, crop_top: float,
+        original_width: float, original_height: float,
+        target_width: float, target_height: float,
+        aesthetic_score: float, negative_aesthetic_score: float,
+        extra_prompt: str | None, extra_negative_prompt: str | None,
+        token_index: int | float, negative_token_index: int | float,
+        eot_multiplier: float, negative_eot_multiplier: float,
+        with_hr: bool,
+        base_aesthetic_score: float,
+    ):
+        super().__init__(enabled)
+        
+        # Валидация параметров
+        self._validate_params(
+            aesthetic_score, negative_aesthetic_score, base_aesthetic_score,
+            original_width, original_height, target_width, target_height
+        )
+        
+        self.p = p
+        self.crop_left = float(crop_left)
+        self.crop_top = float(crop_top)
+        self.original_width = float(original_width)
+        self.original_height = float(original_height)
+        self.target_width = float(target_width)
+        self.target_height = float(target_height)
+        self.aesthetic_score = float(aesthetic_score)
+        self.negative_aesthetic_score = float(negative_aesthetic_score)
+        self.extra_prompt = extra_prompt
+        self.extra_negative_prompt = extra_negative_prompt
+        self.token_index = int(token_index)
+        self.negative_token_index = int(negative_token_index)
+        self.eot_multiplier = float(eot_multiplier)
+        self.negative_eot_multiplier = float(negative_eot_multiplier)
+        self.with_hr = bool(with_hr)
+        self.base_aesthetic_score = float(base_aesthetic_score)
+        
+        # Thread safety для предотвращения race conditions
+        self._lock = Lock()
+    
+    @staticmethod
+    def _validate_params(
+        aesthetic_score: float,
+        negative_aesthetic_score: float,
+        base_aesthetic_score: float,
+        original_width: float,
+        original_height: float,
+        target_width: float,
+        target_height: float
+    ) -> None:
+        """Валидирует входные параметры."""
+        for score, name in [
+            (aesthetic_score, "aesthetic_score"),
+            (negative_aesthetic_score, "negative_aesthetic_score"),
+            (base_aesthetic_score, "base_aesthetic_score")
+        ]:
+            if not (0 <= score <= 10):
+                raise ValueError(f"{name} должен быть в диапазоне [0, 10], получено {score}")
+        
+        for size, name in [
+            (original_width, "original_width"),
+            (original_height, "original_height"),
+            (target_width, "target_width"),
+            (target_height, "target_height")
+        ]:
+            if size < 0:
+                raise ValueError(f"{name} не может быть отрицательным, получено {size}")
+    
+    def is_positive_prompt(self, aesthetic_score: float) -> bool:
+        """
+        Определяет, является ли текущий промпт положительным.
+        
+        Args:
+            aesthetic_score: Текущее значение aesthetic score
+            
+        Returns:
+            True если это positive prompt, False если negative
+        """
+        return abs(aesthetic_score - self.base_aesthetic_score) < AESTHETIC_SCORE_EPS
+    
+    def get_prompt_params(self, aesthetic_score: float) -> tuple[str | None, int, float]:
+        """
+        Возвращает параметры промпта в зависимости от aesthetic_score.
+        
+        Args:
+            aesthetic_score: Текущее значение aesthetic score
+            
+        Returns:
+            Tuple (prompt, token_index, multiplier)
+        """
+        if self.is_positive_prompt(aesthetic_score):
+            return self.extra_prompt, self.token_index, self.eot_multiplier
+        else:
+            return self.extra_negative_prompt, self.negative_token_index, self.negative_eot_multiplier
+    
+    def cleanup(self) -> None:
+        """Корректно удаляет все хуки."""
+        try:
+            self.__exit__(None, None, None)
+        except Exception as e:
+            logger.warning(f"[XL Vec] Error during cleanup: {e}")
+    
+    def hook_clip(self, p: StableDiffusionProcessing, clip: nn.Module) -> None:
+        """Устанавливает хуки на CLIP модель."""
+        if not hasattr(p.sd_model, 'is_sdxl') or not p.sd_model.is_sdxl:
+            logger.debug("[XL Vec] Model is not SDXL, skipping hooks")
+            return
+        
+        def inp(*args, **kwargs):
+            return hook_input(self, *args, **kwargs)
+        
+        def outp(*args, **kwargs):
+            return hook_output(self, *args, **kwargs)
+        
+        self.hook_layer_pre(clip, inp)
+        self.hook_layer(clip, outp)
+
+
+class Script(scripts.Script):
+    """Скрипт для управления SDXL conditioning параметрами."""
+    
+    def title(self) -> str:
+        return NAME
+    
+    def show(self, is_img2img) -> scripts.AlwaysVisible:
+        return scripts.AlwaysVisible
+    
+    def ui(self, is_img2img):
+        with gr.Accordion(NAME, open=False):
+            with gr.Row():
+                enabled = gr.Checkbox(label='Enable XL Vec', value=False)
+                with_hr = gr.Checkbox(label='Active on Hires Fix', value=False, visible=False)
+
+            # --- GEOMETRY SECTION ---
+            with gr.Group():
+                gr.Markdown("### 📐 SDXL Geometry & Size")
+                
+                preset_dropdown = gr.Dropdown(
+                    label="⚡ Quick Resolution Preset",
+                    choices=list(PRESETS.keys()),
+                    value="Manual / Custom",
+                    type="value"
+                )
+
+                with gr.Row():
+                    original_width = gr.Slider(
+                        minimum=-1, maximum=4096, step=1, value=-1,
+                        label='Original Width (-1=auto)'
+                    )
+                    original_height = gr.Slider(
+                        minimum=-1, maximum=4096, step=1, value=-1,
+                        label='Original Height (-1=auto)'
+                    )
+                
+                with gr.Row():
+                    target_width = gr.Slider(
+                        minimum=-1, maximum=4096, step=1, value=-1,
+                        label='Target Width (-1=auto)'
+                    )
+                    target_height = gr.Slider(
+                        minimum=-1, maximum=4096, step=1, value=-1,
+                        label='Target Height (-1=auto)'
+                    )
+
+                # Callback: Dropdown -> Sliders
+                def apply_preset(choice):
+                    if choice in PRESETS and PRESETS[choice] is not None:
+                        w, h = PRESETS[choice]
+                        return w, h, w, h
+                    return gr.update(), gr.update(), gr.update(), gr.update()
+
+                preset_dropdown.change(
+                    fn=apply_preset,
+                    inputs=[preset_dropdown],
+                    outputs=[original_width, original_height, target_width, target_height]
+                )
+
+                # Callback: Sliders -> Dropdown (Reset to Manual)
+                def reset_dropdown():
+                    return "Manual / Custom"
+
+                for slider in [original_width, original_height, target_width, target_height]:
+                    slider.change(fn=reset_dropdown, inputs=None, outputs=[preset_dropdown])
+
+                with gr.Accordion("✂️ Crop Settings", open=False):
+                    with gr.Row():
+                        crop_left = gr.Slider(
+                            minimum=-10000, maximum=10000, step=1, value=0,
+                            label='Crop Left'
+                        )
+                        crop_top = gr.Slider(
+                            minimum=-10000, maximum=10000, step=1, value=0,
+                            label='Crop Top'
+                        )
+
+            # --- AESTHETICS SECTION ---
+            with gr.Group():
+                gr.Markdown("### 🎨 Aesthetics")
+                with gr.Row():
+                    aesthetic_score = gr.Slider(
+                        minimum=0.0, maximum=10.0, step=0.1, value=6.0,
+                        label="Positive Aesthetic Score"
+                    )
+                    negative_aesthetic_score = gr.Slider(
+                        minimum=0.0, maximum=10.0, step=0.1, value=2.5,
+                        label="Negative Aesthetic Score"
+                    )
+                
+                with gr.Accordion("⚙️ Detection Threshold (Advanced)", open=False):
+                    base_aesthetic_score = gr.Slider(
+                        minimum=0.0, maximum=10.0, step=0.1, value=6.0,
+                        label="Base Score Threshold"
+                    )
+                    gr.Info("Change this ONLY if you modified 'SDXL Aesthetic Score' in WebUI settings.")
+
+            # --- VECTORS SECTION ---
+            with gr.Accordion("🧠 Token & Vector Control", open=False):
+                with gr.Row():
+                    eot_multiplier = gr.Slider(
+                        minimum=-4.0, maximum=8.0, step=0.05, value=1.0,
+                        label='Pos. Vector Mult'
+                    )
+                    negative_eot_multiplier = gr.Slider(
+                        minimum=-4.0, maximum=8.0, step=0.05, value=1.0,
+                        label='Neg. Vector Mult'
+                    )
+                with gr.Row():
+                    token_index = gr.Slider(
+                        minimum=-77, maximum=76, step=1, value=-1,
+                        label='Pos. Token Index'
+                    )
+                    negative_token_index = gr.Slider(
+                        minimum=-77, maximum=76, step=1, value=-1,
+                        label='Neg. Token Index'
+                    )
+                with gr.Row():
+                    extra_prompt = gr.Textbox(
+                        lines=1, label='Extra Prompt',
+                        placeholder="Override positive prompt text..."
+                    )
+                    extra_negative_prompt = gr.Textbox(
+                        lines=1, label='Extra Negative',
+                        placeholder="Override negative prompt text..."
+                    )
+
+        return [
+            enabled, crop_left, crop_top, original_width, original_height,
+            target_width, target_height, aesthetic_score, negative_aesthetic_score,
+            extra_prompt, extra_negative_prompt, token_index, negative_token_index,
+            eot_multiplier, negative_eot_multiplier, with_hr,
+            base_aesthetic_score
+        ]
+    
+    def process(
+        self, p, enabled, crop_left, crop_top, original_width, original_height,
+        target_width, target_height, aesthetic_score, negative_aesthetic_score,
+        extra_prompt, extra_negative_prompt, token_index, negative_token_index,
+        eot_multiplier, negative_eot_multiplier, with_hr,
+        base_aesthetic_score=DEFAULT_AESTHETIC_SCORE
+    ):
+        """Обрабатывает параметры и устанавливает хуки перед генерацией."""
+        
+        # Очистка предыдущего хука (если остался)
+        if getattr(self, 'last_hooker', None) is not None:
+            self.last_hooker.cleanup()
+            self.last_hooker = None
+        
+        if not enabled:
+            return
+
+        # Автозаполнение размеров
+        if original_width < 0:
+            original_width = p.width
+        if original_height < 0:
+            original_height = p.height
+        if target_width < 0:
+            target_width = p.width
+        if target_height < 0:
+            target_height = p.height
+        
+        try:
+            self.last_hooker = Hook(
+                enabled=True, p=p,
+                crop_left=crop_left, crop_top=crop_top,
+                original_width=original_width, original_height=original_height,
+                target_width=target_width, target_height=target_height,
+                aesthetic_score=aesthetic_score,
+                negative_aesthetic_score=negative_aesthetic_score,
+                extra_prompt=extra_prompt, extra_negative_prompt=extra_negative_prompt,
+                token_index=token_index, negative_token_index=negative_token_index,
+                eot_multiplier=eot_multiplier,
+                negative_eot_multiplier=negative_eot_multiplier,
+                with_hr=with_hr, base_aesthetic_score=base_aesthetic_score
+            )
+        except ValueError as e:
+            logger.error(f"[XL Vec] Invalid parameters: {e}")
+            return
+
+        self.last_hooker.setup(p)
+        self.last_hooker.__enter__()
+        
+        # Обновление метаданных (Infotext)
+        p.extra_generation_params.update({
+            f'[{NAME}] Enabled': enabled,
+            f'[{NAME}] Original Size': f"{int(original_width)}x{int(original_height)}",
+            f'[{NAME}] Target Size': f"{int(target_width)}x{int(target_height)}",
+            f'[{NAME}] Aesthetic Score': aesthetic_score,
+        })
+        
+        if crop_left != 0 or crop_top != 0:
+            p.extra_generation_params[f'[{NAME}] Crop'] = f"{crop_left},{crop_top}"
+        
+        if abs(base_aesthetic_score - DEFAULT_AESTHETIC_SCORE) > AESTHETIC_SCORE_EPS:
+            p.extra_generation_params[f'[{NAME}] Base Score'] = base_aesthetic_score
+        
+        if eot_multiplier != 1.0:
+            p.extra_generation_params[f'[{NAME}] Token Mult'] = eot_multiplier
+
+        # Сброс кэша для применения новых условий
+        if hasattr(p, 'cached_c'):
+            p.cached_c = [None, None]
+        if hasattr(p, 'cached_uc'):
+            p.cached_uc = [None, None]
+
+
+init_xyz(Script, NAME)

sd-webui-xl_vec/scripts/xl_vec_xyz.py

@@ -0,0 +1,160 @@
+import os
+from typing import Union, List, Callable
+
+from modules import scripts
+from modules.processing import StableDiffusionProcessing, StableDiffusionProcessingTxt2Img, StableDiffusionProcessingImg2Img
+
+
+def __set_value(p: StableDiffusionProcessing, script: type, index: int, value):
+    args = list(p.script_args)
+    
+    if isinstance(p, StableDiffusionProcessingTxt2Img):
+        all_scripts = scripts.scripts_txt2img.scripts
+    else:
+        all_scripts = scripts.scripts_img2img.scripts
+    
+    froms = [x.args_from for x in all_scripts if isinstance(x, script)]
+    for idx in froms:
+        assert idx is not None
+        args[idx + index] = value
+    
+    p.script_args = type(p.script_args)(args)
+
+def __set_values(p: StableDiffusionProcessing, script: type, indices: list[int], values: list):
+    args = list(p.script_args)
+    
+    if isinstance(p, StableDiffusionProcessingTxt2Img):
+        all_scripts = scripts.scripts_txt2img.scripts
+    else:
+        all_scripts = scripts.scripts_img2img.scripts
+    
+    froms = [x.args_from for x in all_scripts if isinstance(x, script)]
+    for idx in froms:
+        assert idx is not None
+        for index, value in zip(indices, values):
+            args[idx + index] = value
+    
+    p.script_args = type(p.script_args)(args)
+
+
+
+def to_bool(v: str):
+    if len(v) == 0: return False
+    v = v.lower()
+    if 'true' in v: return True
+    if 'false' in v: return False
+    
+    try:
+        w = int(v)
+        return bool(w)
+    except:
+        acceptable = ['True', 'False', '1', '0']
+        s = ', '.join([f'`{v}`' for v in acceptable])
+        raise ValueError(f'value must be one of {s}.')
+
+
+class AxisOptions:
+    
+    def __init__(self, AxisOption: type, axis_options: list):
+        self.AxisOption = AxisOption
+        self.target = axis_options
+        self.options = []
+    
+    def __enter__(self):
+        self.options.clear()
+        return self
+    
+    def __exit__(self, ex_type, ex_value, trace):
+        if ex_type is not None:
+            return
+        
+        for opt in self.options:
+            self.target.append(opt)
+        
+        self.options.clear()
+    
+    def create(self, name: str, type_fn: Callable, action: Callable, choices: Union[List[str],None]):
+        if choices is None or len(choices) == 0:
+            opt = self.AxisOption(name, type_fn, action)
+        else:
+            opt = self.AxisOption(name, type_fn, action, choices=lambda: choices)
+        return opt
+    
+    def add(self, axis_option):
+        self.target.append(axis_option)
+
+
+__init = False
+
+def init_xyz(script: type, ext_name: str):
+    global __init
+    
+    if __init:
+        return
+    
+    for data in scripts.scripts_data:
+        name = os.path.basename(data.path)
+        if name != 'xy_grid.py' and name != 'xyz_grid.py':
+            continue
+        
+        if not hasattr(data.module, 'AxisOption'):
+            continue
+        
+        if not hasattr(data.module, 'axis_options'):
+            continue
+        
+        AxisOption = data.module.AxisOption
+        axis_options = data.module.axis_options
+        
+        if not isinstance(AxisOption, type):
+            continue
+        
+        if not isinstance(axis_options, list):
+            continue
+        
+        try:
+            create_options(ext_name, script, AxisOption, axis_options)
+        except:
+            pass
+            
+    __init = True
+
+
+def create_options(ext_name: str, script: type, AxisOptionClass: type, axis_options: list):
+    with AxisOptions(AxisOptionClass, axis_options) as opts:
+        def define(param: str, index: int, type_fn: Callable, choices: List[str] = []):
+            def fn(p, x, xs):
+                __set_value(p, script, index, x)
+            
+            name = f'[{ext_name}] {param}'
+            return opts.create(name, type_fn, fn, choices)
+        
+        def define2(param: str, indices: list[int], type_fn: Callable, choices: List[str] = []):
+            def fn(p, x, xs):
+                __set_values(p, script, indices, x)
+            
+            name = f'[{ext_name}] {param}'
+            return opts.create(name, type_fn, fn, choices)
+        
+        options = [
+            define('Enabled', 0, to_bool, choices=['false', 'true']),
+            define('Crop Left', 1, float),
+            define('Crop Top', 2, float),
+            define('Original Width', 3, float),
+            define('Original Height', 4, float),
+            define('Target Width', 5, float),
+            define('Target Height', 6, float),
+            define('Aesthetic Score', 7, float),
+            define('Negative Aesthetic Score', 8, float),
+            define2('Original WxH', [3, 4], lambda s: [float(x) for x in s.split('x')]),
+            define2('Target WxH', [5, 6], lambda s: [float(x) for x in s.split('x')]),
+            define('Extra Prompt', 9, str),
+            define('Extra Negative Prompt', 10, str),
+            define('Token Index', 11, int),
+            define('Negative Token Index', 12, int),
+            define('EOT Multiplier', 13, float),
+            define('Negative EOT Multiplier', 14, float),
+        ]
+        
+        for opt in options:
+            opts.add(opt)