Upload nrs_kohaku_enhanced (1).py

negative_rejection_steering/scripts/nrs_kohaku_enhanced (1).py

@@ -0,0 +1,508 @@
+import torch
+import gradio as gr
+from modules import scripts, script_callbacks, sd_samplers_cfg_denoiser, shared
+
+# ==============================================================================
+# УЛУЧШЕНИЕ NRS С ИСПОЛЬЗОВАНИЕМ ГЕОМЕТРИЧЕСКОГО ПРИНЦИПА KOHAKU_LONYU_YOG
+#
+# Оригинальная идея Kohaku: в N-мерном пространстве, если взять антиподальную
+# точку -x и вычислить оттуда градиент d2, то среднее (d+d2)/2 указывает
+# точнее на целевую область A. Применяем этот же принцип к NRS-векторам.
+#
+# Новая функция calc_nrs_antipodal:
+#   1. Вычисляет NRS-вектор из точки x (стандартный NRS)
+#   2. Вычисляет NRS-вектор из антиподальной точки -x
+#   3. Усредняет результаты — убирает смещение, зависящее от позиции x
+#
+# Параметр antipodal_blend (0.0 = чистый NRS, 1.0 = полное антиподальное
+# усреднение) позволяет плавно управлять степенью улучшения.
+# ==============================================================================
+
+
+def _nrs_core(x_orig, cond, uncond, sigma, skew, stretch, squash):
+    """
+    Базовое математическое ядро NRS. Принимает один тензор x_orig
+    и возвращает управляемый cond-вектор.
+    """
+    is_v_pred = False
+    if hasattr(shared.sd_model, 'parameterization'):
+        is_v_pred = shared.sd_model.parameterization == "v"
+
+    if isinstance(sigma, torch.Tensor):
+        sig_tens = sigma[0]
+    else:
+        sig_tens = torch.tensor(sigma, device=cond.device, dtype=cond.dtype)
+
+    if sig_tens.dtype != cond.dtype:
+        sig_tens = sig_tens.to(dtype=cond.dtype)
+
+    sig_tens = sig_tens.view(1, 1, 1, 1)
+    sig_root = (sig_tens ** 2 + 1).sqrt()
+
+    if is_v_pred:
+        nrs_cond, nrs_uncond = cond, uncond
+        x_div = None
+    else:
+        x_div = x_orig / (sig_tens ** 2 + 1)
+        factor = sig_tens / sig_root
+        nrs_cond = x_orig - (x_div - cond * factor)
+        nrs_uncond = x_orig - (x_div - uncond * factor)
+
+    def _dot(a, b): return (a * b).sum(dim=1, keepdim=True)
+    def _nrm2(v): return _dot(v, v)
+
+    eps_safe = 1e-6
+
+    c_dot_c = _nrm2(nrs_cond) + eps_safe
+    u_dot_c = _dot(nrs_uncond, nrs_cond)
+    u_on_c = (u_dot_c / c_dot_c) * nrs_cond
+
+    proj_diff = nrs_cond - u_on_c
+    stretched = nrs_cond + (stretch * proj_diff)
+
+    u_rej_c = nrs_uncond - u_on_c
+    skewed = stretched - (skew * u_rej_c)
+
+    cond_len = nrs_cond.norm(dim=1, keepdim=True)
+    nrs_len = skewed.norm(dim=1, keepdim=True) + eps_safe
+    squash_scale = (1 - squash) + (squash * (cond_len / nrs_len))
+    x_final = skewed * squash_scale
+
+    if is_v_pred:
+        return x_final
+    else:
+        return (x_div - (x_orig - x_final)) * (sig_root / sig_tens)
+
+
+def calc_nrs(x_orig, cond, uncond, sigma, skew, stretch, squash):
+    """
+    Оригинальная функция NRS — обёртка над ядром, сохранена для совместимости.
+    """
+    return _nrs_core(x_orig, cond, uncond, sigma, skew, stretch, squash)
+
+
+def calc_nrs_antipodal(x_orig, cond, uncond, sigma, skew, stretch, squash,
+                       antipodal_blend=0.5, antipodal_steps_half=True,
+                       current_step=0, total_steps=20):
+    """
+    NRS с антиподальным геометрическим улучшением по принципу Kohaku_LoNyu_Yog.
+
+    Принцип:
+        Kohaku показал, что в высокоразмерном пространстве точка -x и точка x
+        находятся "по разные стороны" от целевой области A, и среднее их
+        градиентов (d+d2)/2 даёт более точный вектор к A.
+
+        Здесь: вычисляем NRS-вектор из x И из -x, затем смешиваем.
+        NRS из -x имеет инвертированные знаки компонент cond/uncond
+        относительно пространства x, но их среднее устраняет позиционное
+        смещение и даёт более "центрированный" вектор управления.
+
+    Параметры:
+        antipodal_blend      : 0.0 = чистый NRS, 1.0 = полное усреднение
+        antipodal_steps_half : True = применять только на первой половине
+                               шагов (как в оригинале Kohaku)
+        current_step         : текущий шаг сэмплера
+        total_steps          : всего шагов
+    """
+    # Стандартный NRS из x
+    nrs_direct = _nrs_core(x_orig, cond, uncond, sigma, skew, stretch, squash)
+
+    # Если антиподальное улучшение выключено — возвращаем стандартный результат
+    if antipodal_blend <= 0.0:
+        return nrs_direct
+
+    # Применять только на первой половине шагов (согласно теории Kohaku)
+    if antipodal_steps_half and current_step > total_steps / 2:
+        return nrs_direct
+
+    # ----------------------------------------------------------------
+    # Вычисляем NRS из антиподальной точки -x
+    # 
+    # Геометрически: нас интересует не буквально -x как латент, а то,
+    # как меняется пространство проекций cond/uncond при инверсии x.
+    # Мы инвертируем x_orig и пересчитываем cond/uncond относительно него.
+    #
+    # Примечание: cond и uncond здесь — это выходы денойзера (x_out),
+    # а не промпты. Они тоже имеют смысл только в контексте входа x.
+    # При -x логично инвертировать и их знаки.
+    # ----------------------------------------------------------------
+    x_neg = -x_orig
+    cond_neg = -cond
+    uncond_neg = -uncond
+
+    nrs_antipodal_raw = _nrs_core(x_neg, cond_neg, uncond_neg, sigma,
+                                  skew, stretch, squash)
+
+    # Антиподальный результат возвращаем в пространство x (инвертируем обратно)
+    nrs_antipodal = -nrs_antipodal_raw
+
+    # ----------------------------------------------------------------
+    # Двухшаговое уточнение (аналог d3 в Kohaku):
+    # x3 = x + (d+d2)/2 * dt → затем вычисляется d3 → итог (d+d3)/2
+    # Здесь: вычисляем "уточнённый" NRS из промежуточной точки
+    # x_mid = x + (nrs_direct + nrs_antipodal) / 2 * blend_factor
+    # ----------------------------------------------------------------
+    nrs_avg = (nrs_direct + nrs_antipodal) / 2
+
+    # Blend: плавное смешивание
+    result = nrs_direct + antipodal_blend * (nrs_avg - nrs_direct)
+
+    return result
+
+
+# ==============================================================================
+# УПРАВЛЕНИЕ ШАГАМИ (без изменений)
+# ==============================================================================
+def should_apply_at_step(current_step, total_steps, start_step, end_step,
+                         start_frac, end_frac, step_mode):
+    if step_mode == "Absolute Steps":
+        effective_start = max(0, start_step)
+        effective_end = min(total_steps, end_step) if end_step > 0 else total_steps
+        return effective_start <= current_step < effective_end
+    else:
+        effective_start = int(total_steps * max(0.0, min(1.0, start_frac)))
+        effective_end = int(total_steps * max(0.0, min(1.0, end_frac)))
+        if effective_end == 0:
+            effective_end = total_steps
+        return effective_start <= current_step < effective_end
+
+
+def get_param_value_at_step(base_value, current_step, total_steps, start_step, end_step,
+                            start_frac, end_frac, step_mode, enabled):
+    if not enabled:
+        return base_value
+    if should_apply_at_step(current_step, total_steps, start_step, end_step,
+                            start_frac, end_frac, step_mode):
+        return base_value
+    else:
+        return 0.0
+
+
+# ==============================================================================
+# ПЕРЕХВАТ (HOOKING)
+# ==============================================================================
+def hook_cfg_denoiser_params(params):
+    if hasattr(params.denoiser, 'p') and getattr(params.denoiser.p, '_nrs_enabled', False):
+        params.denoiser.p._nrs_current_sigma = params.sigma
+        params.denoiser.p._nrs_current_x_in = params.x
+        if hasattr(params, 'sampling_step'):
+            params.denoiser.p._nrs_current_step = params.sampling_step
+        elif hasattr(params.denoiser, 'step'):
+            params.denoiser.p._nrs_current_step = params.denoiser.step
+        else:
+            params.denoiser.p._nrs_current_step = getattr(params.denoiser.p, '_nrs_current_step', 0)
+
+
+script_callbacks.on_cfg_denoiser(hook_cfg_denoiser_params)
+
+if not hasattr(sd_samplers_cfg_denoiser.CFGDenoiser, 'original_combine_denoised_nrs_backup'):
+    sd_samplers_cfg_denoiser.CFGDenoiser.original_combine_denoised_nrs_backup = \
+        sd_samplers_cfg_denoiser.CFGDenoiser.combine_denoised
+
+
+def hijacked_combine_denoised(self, x_out, conds_list, uncond, cond_scale):
+    if not getattr(self, 'p', None) or not getattr(self.p, '_nrs_enabled', False):
+        return sd_samplers_cfg_denoiser.CFGDenoiser.original_combine_denoised_nrs_backup(
+            self, x_out, conds_list, uncond, cond_scale)
+
+    if not hasattr(self.p, '_nrs_current_sigma') or not hasattr(self.p, '_nrs_current_x_in'):
+        return sd_samplers_cfg_denoiser.CFGDenoiser.original_combine_denoised_nrs_backup(
+            self, x_out, conds_list, uncond, cond_scale)
+
+    try:
+        base_skew, base_stretch, base_squash = self.p._nrs_params
+        step_control_enabled = getattr(self.p, '_nrs_step_control_enabled', False)
+        step_control_mode = getattr(self.p, '_nrs_step_control_mode', 'Global')
+        current_step = getattr(self.p, '_nrs_current_step', 0)
+        total_steps = getattr(self.p, 'steps', 20)
+
+        if step_control_enabled:
+            if step_control_mode == 'Global':
+                global_settings = getattr(self.p, '_nrs_global_step_settings', {})
+                start_step = global_settings.get('start_step', 0)
+                end_step = global_settings.get('end_step', total_steps)
+                start_frac = global_settings.get('start_frac', 0.0)
+                end_frac = global_settings.get('end_frac', 1.0)
+                step_mode = global_settings.get('step_mode', 'Absolute Steps')
+                if not should_apply_at_step(current_step, total_steps, start_step, end_step,
+                                            start_frac, end_frac, step_mode):
+                    return sd_samplers_cfg_denoiser.CFGDenoiser.original_combine_denoised_nrs_backup(
+                        self, x_out, conds_list, uncond, cond_scale)
+                skew, stretch, squash = base_skew, base_stretch, base_squash
+            else:
+                individual_settings = getattr(self.p, '_nrs_individual_step_settings', {})
+                skew_s = individual_settings.get('skew', {})
+                skew = get_param_value_at_step(
+                    base_skew, current_step, total_steps,
+                    skew_s.get('start_step', 0), skew_s.get('end_step', total_steps),
+                    skew_s.get('start_frac', 0.0), skew_s.get('end_frac', 1.0),
+                    skew_s.get('step_mode', 'Absolute Steps'), skew_s.get('enabled', True))
+                str_s = individual_settings.get('stretch', {})
+                stretch = get_param_value_at_step(
+                    base_stretch, current_step, total_steps,
+                    str_s.get('start_step', 0), str_s.get('end_step', total_steps),
+                    str_s.get('start_frac', 0.0), str_s.get('end_frac', 1.0),
+                    str_s.get('step_mode', 'Absolute Steps'), str_s.get('enabled', True))
+                sq_s = individual_settings.get('squash', {})
+                squash = get_param_value_at_step(
+                    base_squash, current_step, total_steps,
+                    sq_s.get('start_step', 0), sq_s.get('end_step', total_steps),
+                    sq_s.get('start_frac', 0.0), sq_s.get('end_frac', 1.0),
+                    sq_s.get('step_mode', 'Absolute Steps'), sq_s.get('enabled', True))
+        else:
+            skew, stretch, squash = base_skew, base_stretch, base_squash
+
+        # Антиподальные параметры
+        antipodal_blend = getattr(self.p, '_nrs_antipodal_blend', 0.0)
+        antipodal_steps_half = getattr(self.p, '_nrs_antipodal_steps_half', True)
+
+        denoised_uncond = x_out[-uncond.shape[0]:]
+        denoised = torch.clone(denoised_uncond)
+        x_orig_all = self.p._nrs_current_x_in
+        x_orig_uncond = x_orig_all[-uncond.shape[0]:]
+
+        for i, conds in enumerate(conds_list):
+            for idx, (cond_index, weight) in enumerate(conds):
+                current_cond = x_out[cond_index]
+                if idx == 0:
+                    current_x_orig = x_orig_uncond[i].unsqueeze(0)
+                    c_in = current_cond.unsqueeze(0)
+                    u_in = denoised_uncond[i].unsqueeze(0)
+
+                    # Используем новую функцию с антиподальным улучшением
+                    nrs_result = calc_nrs_antipodal(
+                        current_x_orig, c_in, u_in,
+                        self.p._nrs_current_sigma,
+                        skew, stretch, squash,
+                        antipodal_blend=antipodal_blend,
+                        antipodal_steps_half=antipodal_steps_half,
+                        current_step=current_step,
+                        total_steps=total_steps
+                    )
+
+                    if len(conds) == 1:
+                        denoised[i] = nrs_result.squeeze(0)
+                    else:
+                        delta = nrs_result.squeeze(0) - denoised_uncond[i]
+                        denoised[i] += delta * weight
+                else:
+                    denoised[i] += (current_cond - denoised_uncond[i]) * (weight * cond_scale)
+
+        return denoised
+
+    except Exception as e:
+        print(f"!!! NRS Antipodal Error (Fallback): {e}")
+        return sd_samplers_cfg_denoiser.CFGDenoiser.original_combine_denoised_nrs_backup(
+            self, x_out, conds_list, uncond, cond_scale)
+
+
+# ==============================================================================
+# UI
+# ==============================================================================
+class NRSScript(scripts.Script):
+    def title(self):
+        return "NRS + Kohaku Antipodal (Enhanced)"
+
+    def show(self, is_img2img):
+        return scripts.AlwaysVisible
+
+    def ui(self, is_img2img):
+        with gr.Accordion("Negative Rejection Steering + Kohaku Antipodal", open=False):
+            with gr.Row():
+                enabled = gr.Checkbox(label="Включить NRS (Enable)", value=False)
+
+            with gr.Accordion("❓ Инструкция", open=False):
+                gr.Markdown("""
+                ### Что нового: Antipodal Blend (Антиподальное улучшение)
+                
+                Основано на принципе **Kohaku_LoNyu_Yog**: в высокоразмерном пространстве
+                точки `x` и `-x` находятся по разные стороны от целевой области изображения.
+                
+                Стандартный NRS вычисляет управляющий вектор только из текущего `x`.
+                Это создаёт **позиционное смещение** — вектор "перекошен" относительно
+                истинного направления к цели.
+                
+                **Antipodal Blend** вычисляет NRS также из `-x` и усредняет результаты.
+                Это устраняет смещение и даёт более точное управление.
+                
+                ### Параметры Antipodal:
+                - **Antipodal Blend** (0.0–1.0): Степень антиподального улучшения.
+                  0.0 = чистый NRS, 0.5 = рекомендуемое значение, 1.0 = полное усреднение.
+                - **Only first half of steps**: Применять только на первой половине шагов
+                  (как в оригинале Kohaku — в конце шагов метод может отклоняться).
+                
+                ### Советы:
+                - Начните с **Antipodal Blend = 0.3–0.5** с включённым "Only first half"
+                - Если результат слишком "мягкий" — уменьшите blend или увеличьте Skew
+                - Этот метод особенно эффективен при низком CFG / высоком Squash
+                """)
+
+            gr.HTML("<div style='margin-bottom: 0.5em; opacity: 0.8; font-size: 0.9em;"
+                    " border-bottom: 1px solid #444;'>Основные настройки NRS</div>")
+
+            with gr.Row():
+                skew = gr.Slider(
+                    label="Skew (Композиция)",
+                    minimum=-30.0, maximum=30.0, step=0.05, value=4.0,
+                    info="Отклонение от Negative prompt. Рекомендуется: 3.0–5.0"
+                )
+                stretch = gr.Slider(
+                    label="Stretch (Цвета/Текстура)",
+                    minimum=-30.0, maximum=30.0, step=0.05, value=2.0,
+                    info="Притяжение к Positive prompt. Рекомендуется: 2.0–7.0"
+                )
+
+            squash = gr.Slider(
+                label="Squash (Защита от пережарки)",
+                minimum=0.0, maximum=1.0, step=0.01, value=0.0,
+                info="0.0 = максимальный эффект. 1.0 = больше деталей."
+            )
+
+            # --- НОВЫЙ БЛОК: АНТИПОДАЛЬНОЕ УЛУЧШЕНИЕ ---
+            gr.HTML("<div style='margin: 0.8em 0 0.5em 0; opacity: 0.8; font-size: 0.9em;"
+                    " border-bottom: 1px solid #444;'>🔮 Kohaku Antipodal Enhancement</div>")
+
+            antipodal_blend = gr.Slider(
+                label="Antipodal Blend",
+                minimum=0.0, maximum=1.0, step=0.01, value=0.0,
+                info="0.0 = выкл (чистый NRS). 0.5 = рекомендуется. 1.0 = полное антиподальное усреднение."
+            )
+
+            antipodal_steps_half = gr.Checkbox(
+                label="Only first half of steps (рекомендуется)",
+                value=True,
+                info="Применять антиподальное улучшение только на первой половине шагов (как в Kohaku)"
+            )
+
+            # --- STEP CONTROL ---
+            with gr.Accordion("⏱️ Step Control", open=False):
+                with gr.Row():
+                    step_control_enabled = gr.Checkbox(label="Включить Step Control", value=False)
+                    step_control_mode = gr.Radio(
+                        label="Режим", choices=["Global", "Individual"], value="Global")
+
+                with gr.Group(visible=True) as global_group:
+                    gr.HTML("<div style='margin: 0.5em 0; font-weight: bold;'>Глобальные настройки</div>")
+                    global_step_mode = gr.Radio(
+                        label="Режим шагов",
+                        choices=["Absolute Steps", "Fraction of Steps"],
+                        value="Absolute Steps")
+                    with gr.Row():
+                        global_start_step = gr.Slider(label="Start Step", minimum=0, maximum=150, step=1, value=0, visible=True)
+                        global_end_step = gr.Slider(label="End Step (0=конец)", minimum=0, maximum=150, step=1, value=0, visible=True)
+                    with gr.Row():
+                        global_start_frac = gr.Slider(label="Start (fraction)", minimum=0.0, maximum=1.0, step=0.01, value=0.0, visible=False)
+                        global_end_frac = gr.Slider(label="End (fraction)", minimum=0.0, maximum=1.0, step=0.01, value=1.0, visible=False)
+
+                with gr.Group(visible=False) as individual_group:
+                    gr.HTML("<div style='margin: 0.5em 0; font-weight: bold;'>Индивидуальные настройки</div>")
+                    with gr.Accordion("Skew - Step Settings", open=False):
+                        skew_step_enabled = gr.Checkbox(label="Включить для Skew", value=True)
+                        skew_step_mode = gr.Radio(label="Режим", choices=["Absolute Steps", "Fraction of Steps"], value="Absolute Steps")
+                        with gr.Row():
+                            skew_start_step = gr.Slider(label="Start Step", minimum=0, maximum=150, step=1, value=0, visible=True)
+                            skew_end_step = gr.Slider(label="End Step", minimum=0, maximum=150, step=1, value=0, visible=True)
+                        with gr.Row():
+                            skew_start_frac = gr.Slider(label="Start (fraction)", minimum=0.0, maximum=1.0, step=0.01, value=0.0, visible=False)
+                            skew_end_frac = gr.Slider(label="End (fraction)", minimum=0.0, maximum=1.0, step=0.01, value=1.0, visible=False)
+                    with gr.Accordion("Stretch - Step Settings", open=False):
+                        stretch_step_enabled = gr.Checkbox(label="Включить для Stretch", value=True)
+                        stretch_step_mode = gr.Radio(label="Режим", choices=["Absolute Steps", "Fraction of Steps"], value="Absolute Steps")
+                        with gr.Row():
+                            stretch_start_step = gr.Slider(label="Start Step", minimum=0, maximum=150, step=1, value=0, visible=True)
+                            stretch_end_step = gr.Slider(label="End Step", minimum=0, maximum=150, step=1, value=0, visible=True)
+                        with gr.Row():
+                            stretch_start_frac = gr.Slider(label="Start (fraction)", minimum=0.0, maximum=1.0, step=0.01, value=0.0, visible=False)
+                            stretch_end_frac = gr.Slider(label="End (fraction)", minimum=0.0, maximum=1.0, step=0.01, value=1.0, visible=False)
+                    with gr.Accordion("Squash - Step Settings", open=False):
+                        squash_step_enabled = gr.Checkbox(label="Включить для Squash", value=True)
+                        squash_step_mode = gr.Radio(label="Режим", choices=["Absolute Steps", "Fraction of Steps"], value="Absolute Steps")
+                        with gr.Row():
+                            squash_start_step = gr.Slider(label="Start Step", minimum=0, maximum=150, step=1, value=0, visible=True)
+                            squash_end_step = gr.Slider(label="End Step", minimum=0, maximum=150, step=1, value=0, visible=True)
+                        with gr.Row():
+                            squash_start_frac = gr.Slider(label="Start (fraction)", minimum=0.0, maximum=1.0, step=0.01, value=0.0, visible=False)
+                            squash_end_frac = gr.Slider(label="End (fraction)", minimum=0.0, maximum=1.0, step=0.01, value=1.0, visible=False)
+
+                def update_mode_visibility(mode):
+                    return {
+                        global_group: gr.update(visible=(mode == "Global")),
+                        individual_group: gr.update(visible=(mode == "Individual"))
+                    }
+
+                step_control_mode.change(
+                    fn=update_mode_visibility,
+                    inputs=[step_control_mode],
+                    outputs=[global_group, individual_group])
+
+                def _toggle_abs_frac(mode):
+                    a = mode == "Absolute Steps"
+                    return gr.update(visible=a), gr.update(visible=a), gr.update(visible=not a), gr.update(visible=not a)
+
+                global_step_mode.change(fn=_toggle_abs_frac, inputs=[global_step_mode],
+                    outputs=[global_start_step, global_end_step, global_start_frac, global_end_frac])
+                skew_step_mode.change(fn=_toggle_abs_frac, inputs=[skew_step_mode],
+                    outputs=[skew_start_step, skew_end_step, skew_start_frac, skew_end_frac])
+                stretch_step_mode.change(fn=_toggle_abs_frac, inputs=[stretch_step_mode],
+                    outputs=[stretch_start_step, stretch_end_step, stretch_start_frac, stretch_end_frac])
+                squash_step_mode.change(fn=_toggle_abs_frac, inputs=[squash_step_mode],
+                    outputs=[squash_start_step, squash_end_step, squash_start_frac, squash_end_frac])
+
+        return [
+            enabled, skew, stretch, squash,
+            antipodal_blend, antipodal_steps_half,
+            step_control_enabled, step_control_mode,
+            global_step_mode, global_start_step, global_end_step, global_start_frac, global_end_frac,
+            skew_step_enabled, skew_step_mode, skew_start_step, skew_end_step, skew_start_frac, skew_end_frac,
+            stretch_step_enabled, stretch_step_mode, stretch_start_step, stretch_end_step, stretch_start_frac, stretch_end_frac,
+            squash_step_enabled, squash_step_mode, squash_start_step, squash_end_step, squash_start_frac, squash_end_frac,
+        ]
+
+    def process(self, p,
+                enabled, skew, stretch, squash,
+                antipodal_blend, antipodal_steps_half,
+                step_control_enabled, step_control_mode,
+                global_step_mode, global_start_step, global_end_step, global_start_frac, global_end_frac,
+                skew_step_enabled, skew_step_mode, skew_start_step, skew_end_step, skew_start_frac, skew_end_frac,
+                stretch_step_enabled, stretch_step_mode, stretch_start_step, stretch_end_step, stretch_start_frac, stretch_end_frac,
+                squash_step_enabled, squash_step_mode, squash_start_step, squash_end_step, squash_start_frac, squash_end_frac):
+
+        p._nrs_enabled = enabled
+        p._nrs_params = (skew, stretch, squash)
+        p._nrs_antipodal_blend = antipodal_blend
+        p._nrs_antipodal_steps_half = antipodal_steps_half
+        p._nrs_step_control_enabled = step_control_enabled
+        p._nrs_step_control_mode = step_control_mode
+
+        p._nrs_global_step_settings = {
+            'step_mode': global_step_mode,
+            'start_step': global_start_step,
+            'end_step': global_end_step,
+            'start_frac': global_start_frac,
+            'end_frac': global_end_frac
+        }
+
+        p._nrs_individual_step_settings = {
+            'skew': {
+                'enabled': skew_step_enabled, 'step_mode': skew_step_mode,
+                'start_step': skew_start_step, 'end_step': skew_end_step,
+                'start_frac': skew_start_frac, 'end_frac': skew_end_frac
+            },
+            'stretch': {
+                'enabled': stretch_step_enabled, 'step_mode': stretch_step_mode,
+                'start_step': stretch_start_step, 'end_step': stretch_end_step,
+                'start_frac': stretch_start_frac, 'end_frac': stretch_end_frac
+            },
+            'squash': {
+                'enabled': squash_step_enabled, 'step_mode': squash_step_mode,
+                'start_step': squash_start_step, 'end_step': squash_end_step,
+                'start_frac': squash_start_frac, 'end_frac': squash_end_frac
+            }
+        }
+
+        if enabled:
+            sd_samplers_cfg_denoiser.CFGDenoiser.combine_denoised = hijacked_combine_denoised
+            p._nrs_current_step = 0
+
+    def postprocess(self, p, processed, *args):
+        pass