Update app.py

app.py

@@ -1,289 +1,185 @@
 import gradio as gr
 import numpy as np
 import torch
-import re
-
-from diffusers import (
-    StableDiffusionPipeline,
-    ControlNetModel,
-    StableDiffusionControlNetPipeline,
-    DDIMScheduler,
-)
+from diffusers import DiffusionPipeline
 from peft import PeftModel
+import re
 from PIL import Image
 
-# ------------------------------------------------------------------
-# Пример «заготовки» для IP-Adapter:
-# Предполагается, что у вас есть некий класс, умеющий:
-# 1) Загружать веса IP-Adapter
-# 2) Преобразовывать дополнительное «референс-изображение» в эмбеддинг
-# 3) Подмешивать этот эмбеддинг в процесс диффузии или текстовые эмбеддинги
-# ------------------------------------------------------------------
-class IPAdapterModel:
-    def __init__(self, path_to_weights: str, device="cpu"):
-        """
-        Инициализация и загрузка весов IP-Adapter.
-        path_to_weights - путь к файлам модели
-        """
-        # Здесь должен быть код инициализации вашей модели.
-        # Например, что-то вроде:
-        # self.model = torch.load(path_to_weights, map_location=device)
-        # self.model.eval()
-        # ...
-        self.device = device
-        self.dummy_weights_loaded = True  # признак, что "что-то" загрузили
-
-    def encode_reference_image(self, image: Image.Image):
-        """
-        Преобразовать референс-изображение в некий вектор (embedding),
-        который затем можно использовать для модификации генерации.
-        """
-        # В реальном коде будет извлечение фич.
-        # Для примера вернём фиктивный тензор.
-        dummy_embedding = torch.zeros((1, 768)).to(self.device)
-        return dummy_embedding
-
-    def blend_latents_with_adapter(self, latents: torch.Tensor, adapter_embedding: torch.Tensor, scale: float):
-        """
-        Примерная функция, которая «подмешивает» признаки из адаптера
-        в латенты перед декодированием.
-        latents: (batch, channels, height, width)
-        adapter_embedding: (1, embedding_dim)
-        scale: сила влияния адаптера
-        """
-        # Для демонстрации просто прибавим (scale * mean(adapter_embedding))
-        # В реальном IP-Adapter это гораздо сложнее.
-        if adapter_embedding is not None:
-            # Возьмём скаляр (к примеру)
-            mean_val = adapter_embedding.mean()
-            latents = latents + scale * mean_val
-        return latents
-
-
-# ------------------------------------------------------------------
+# Устройство и тип данных
+device = "cuda" if torch.cuda.is_available() else "cpu"
+torch_dtype = torch.float16 if torch.cuda.is_available() else torch.float32
+
 # Регулярное выражение для проверки корректности модели
-# ------------------------------------------------------------------
 VALID_REPO_ID_REGEX = re.compile(r"^[a-zA-Z0-9._\-]+/[a-zA-Z0-9._\-]+$")
-def is_valid_repo_id(repo_id):
-    return bool(VALID_REPO_ID_REGEX.match(repo_id)) and not repo_id.endswith(('-', '.'))
 
-# ------------------------------------------------------------------
-# Аппаратные настройки
-# ------------------------------------------------------------------
-device = "cuda" if torch.cuda.is_available() else "cpu"
-torch_dtype = torch.float16 if torch.cuda.is_available() else torch.float32
 
-# ------------------------------------------------------------------
-# Константы
-# ------------------------------------------------------------------
+def is_valid_repo_id(repo_id):
+    return bool(VALID_REPO_ID_REGEX.match(repo_id)) and not repo_id.endswith(("-", "."))
+
+# Базовые константы
 MAX_SEED = np.iinfo(np.int32).max
 MAX_IMAGE_SIZE = 1024
 
-# ------------------------------------------------------------------
-# Базовая модель (Stable Diffusion) по умолчанию
-# ------------------------------------------------------------------
+# Изначально загружаем модель по умолчанию (без ControlNet/IP-adapter)
 model_repo_id = "CompVis/stable-diffusion-v1-4"
+pipe = DiffusionPipeline.from_pretrained(model_repo_id, torch_dtype=torch_dtype, safety_checker=None).to(device)
 
-# Загрузка базового пайплайна (без ControlNet)
-pipe = StableDiffusionPipeline.from_pretrained(
-    model_repo_id, torch_dtype=torch_dtype, safety_checker=None
-).to(device)
-
-# ��рименим DDIM-схему как пример
-pipe.scheduler = DDIMScheduler.from_config(pipe.scheduler.config)
-
-# Пробуем подгрузить LoRA (unet + text_encoder)
+# Попробуем подгрузить LoRA-модификации (unet + text_encoder)
 try:
     pipe.unet = PeftModel.from_pretrained(pipe.unet, "./unet")
     pipe.text_encoder = PeftModel.from_pretrained(pipe.text_encoder, "./text_encoder")
 except Exception as e:
     print(f"Не удалось подгрузить LoRA по умолчанию: {e}")
 
-# ------------------------------------------------------------------
-# Инициализация «IP-Adapter» (для примера укажем вымышленный путь).
-# Предположим, что IP-Adapter мы храним в ./ip_adapter_weights
-# ------------------------------------------------------------------
-ip_adapter_model = None
-try:
-    ip_adapter_model = IPAdapterModel("./ip_adapter_weights", device=device)
-except Exception as e:
-    print(f"Не удалось загрузить IP-Adapter: {e}")
 
-# ------------------------------------------------------------------
-# Функция генерации
-# ------------------------------------------------------------------
 def infer(
-    model,                 # Текстовое поле: модель (repo) напр. "CompVis/stable-diffusion-v1-4"
-    prompt,                # Текст: позитивный промпт
-    negative_prompt,       # Текст: негативный промпт
-    seed,                  # Сид генератора
-    width,                 # Ширина
-    height,                # Высота
-    guidance_scale,        # guidance scale
-    num_inference_steps,   # Количество шагов диффузии
-    use_controlnet,        # Чекбокс: включать ли ControlNet
-    control_strength,      # Слайдер: сила влияния ControlNet
-    controlnet_mode,       # Выпадающий список: edge_detection, pose_estimation, depth_estimation
-    controlnet_image,      # Изображение для ControlNet
-    use_ip_adapter,        # Чекбокс: включать ли IP-adapter
-    ip_adapter_scale,      # Слайдер: сила влияния IP-adapter
-    ip_adapter_image,      # Изображение для IP-adapter
+    model,
+    prompt,
+    negative_prompt,
+    seed,
+    width,
+    height,
+    guidance_scale,
+    num_inference_steps,
+    use_controlnet,
+    control_strength,
+    controlnet_mode,
+    controlnet_image,
+    use_ip_adapter,
+    ip_adapter_scale,
+    ip_adapter_image,
     progress=gr.Progress(track_tqdm=True),
 ):
-    global model_repo_id, pipe, ip_adapter_model
+    """
+    Функция генерации изображения с учётом дополнительных опций:
+      - Если включён ControlNet или IP‑adapter, используется пайплайн StableDiffusionControlNetPipeline.
+      - При включённом IP‑adapter без ControlNet создаётся пустое (заглушка) изображение для параметра controlnet.
+      - В остальных случаях используется стандартный пайплайн.
+    """
+    global model_repo_id, pipe
+
+    # Если хотя бы один из режимов (ControlNet или IP‑adapter) включён, переключаемся на ControlNet‑пайплайн
+    if use_controlnet or use_ip_adapter:
+        # Если модель изменилась или текущий pipe не поддерживает IP‑adapter (нет метода load_ip_adapter),
+        # загружаем новый пайплайн.
+        if model != model_repo_id or not hasattr(pipe, "load_ip_adapter"):
+            try:
+                # Импорт необходимых классов внутри функции (если они не нужны при базовой генерации)
+                from diffusers import StableDiffusionControlNetPipeline, ControlNetModel
+            except ImportError as e:
+                raise gr.Error(f"Не удалось импортировать необходимые модули для ControlNet: {e}")
+
+            # Определяем, какую модель ControlNet использовать.
+            if use_controlnet:
+                if controlnet_mode == "edge_detection":
+                    cn_model_id = "lllyasviel/sd-controlnet-canny"
+                elif controlnet_mode == "pose_estimation":
+                    cn_model_id = "lllyasviel/sd-controlnet-openpose"
+                else:
+                    cn_model_id = "lllyasviel/sd-controlnet-canny"
+            else:
+                # Если включён только IP‑adapter, используем модель по умолчанию (например, canny)
+                cn_model_id = "lllyasviel/sd-controlnet-canny"
 
-    # ---------------------------
-    #  1) Проверяем, не сменил ли пользователь модель
-    # ---------------------------
-    if model != model_repo_id:
-        if not is_valid_repo_id(model):
-            raise gr.Error(f"Некорректный идентификатор модели: '{model}'. Проверьте название.")
+            try:
+                controlnet = ControlNetModel.from_pretrained(cn_model_id, torch_dtype=torch_dtype)
+                new_pipe = StableDiffusionControlNetPipeline.from_pretrained(
+                    model, torch_dtype=torch_dtype, controlnet=controlnet
+                ).to(device)
+                new_pipe.safety_checker = None
+
+                # Подгружаем LoRA-модификации (если они есть)
+                try:
+                    new_pipe.unet = PeftModel.from_pretrained(new_pipe.unet, "./unet")
+                    new_pipe.text_encoder = PeftModel.from_pretrained(new_pipe.text_encoder, "./text_encoder")
+                except Exception as e:
+                    print(f"Не удалось подгрузить LoRA: {e}")
+
+                # Если включён IP‑adapter, загружаем его и устанавливаем масштаб.
+                if use_ip_adapter:
+                    new_pipe.load_ip_adapter("h94/IP-Adapter", subfolder="models", weight_name="ip-adapter-plus_sd15.bin")
+                    new_pipe.set_ip_adapter_scale(ip_adapter_scale)
+
+                pipe = new_pipe
+                model_repo_id = model
+            except Exception as e:
+                raise gr.Error(f"Не удалось загрузить модель с ControlNet/IP-adapter '{model}'.\nОшибка: {e}")
+
+        # Подготавливаем изображение для передачи в ControlNet.
+        # Если включён ControlNet, пользователь должен загрузить изображение.
+        # Если нет, но включён IP‑adapter, создаём пустое изображение-заглушку.
+        if use_controlnet:
+            if controlnet_image is None:
+                raise gr.Error("ControlNet включён, но изображение для него не загружено.")
+            cn_image = controlnet_image
+        else:
+            cn_image = Image.new("RGB", (width, height), (255, 255, 255))
 
         try:
-            # Подгружаем модель (без ControlNet)
-            new_pipe = StableDiffusionPipeline.from_pretrained(
-                model, torch_dtype=torch_dtype, safety_checker=None
-            ).to(device)
-            new_pipe.scheduler = DDIMScheduler.from_config(new_pipe.scheduler.config)
+            generator = torch.Generator(device=device).manual_seed(seed)
+            # Вызываем пайплайн StableDiffusionControlNetPipeline.
+            # Первый позиционный аргумент — prompt, второй — изображение для управления (control image).
+            output = pipe(
+                prompt=prompt,
+                image=cn_image,
+                negative_prompt=negative_prompt,
+                guidance_scale=guidance_scale,
+                num_inference_steps=num_inference_steps,
+                width=width,
+                height=height,
+                generator=generator,
+                controlnet_conditioning_scale=control_strength if use_controlnet else 1.0,
+                ip_adapter_image=ip_adapter_image if use_ip_adapter else None,
+            )
+            image = output.images[0]
+        except Exception as e:
+            raise gr.Error(f"Ошибка при генерации изображения с ControlNet/IP-adapter: {e}")
+
+        return image, seed
 
-            # Повторно загружаем LoRA
+    else:
+        # Если ни один из дополнительных режимов не включён, используем стандартный пайплайн.
+        if model != model_repo_id:
+            if not is_valid_repo_id(model):
+                raise gr.Error(f"Некорректный идентификатор модели: '{model}'. Проверьте название.")
             try:
-                new_pipe.unet = PeftModel.from_pretrained(new_pipe.unet, "./unet")
-                new_pipe.text_encoder = PeftModel.from_pretrained(new_pipe.text_encoder, "./text_encoder")
+                new_pipe = DiffusionPipeline.from_pretrained(model, torch_dtype=torch_dtype).to(device)
+                try:
+                    new_pipe.unet = PeftModel.from_pretrained(new_pipe.unet, "./unet")
+                    new_pipe.text_encoder = PeftModel.from_pretrained(new_pipe.text_encoder, "./text_encoder")
+                except Exception as e:
+                    print(f"Не удалось подгрузить LoRA: {e}")
+                pipe = new_pipe
+                model_repo_id = model
             except Exception as e:
-                print(f"��е удалось подгрузить LoRA для новой модели: {e}")
-
-            pipe = new_pipe
-            model_repo_id = model
-
-        except Exception as e:
-            raise gr.Error(f"Не удалось загрузить модель '{model}'.\nОшибка: {e}")
-
-    # ---------------------------
-    #  2) Если включён ControlNet — создаём ControlNetPipeline
-    # ---------------------------
-    local_pipe = pipe  # по умолчанию используем базовый pipe
-
-    if use_controlnet:
-        # Выбираем репозиторий ControlNet в зависимости от режима
-        if controlnet_mode == "edge_detection":
-            controlnet_repo = "lllyasviel/sd-controlnet-canny"
-        elif controlnet_mode == "pose_estimation":
-            controlnet_repo = "lllyasviel/sd-controlnet-openpose"
-        elif controlnet_mode == "depth_estimation":
-            controlnet_repo = "lllyasviel/sd-controlnet-depth"
-        else:
-            raise gr.Error(f"Неизвестный режим ControlNet: {controlnet_mode}")
+                raise gr.Error(f"Не удалось загрузить модель '{model}'.\nОшибка: {e}")
 
         try:
-            controlnet_model = ControlNetModel.from_pretrained(
-                controlnet_repo,
-                torch_dtype=torch_dtype
-            ).to(device)
-
-            # Создаём новый pipeline, указывая ControlNet
-            local_pipe = StableDiffusionControlNetPipeline(
-                vae=pipe.vae,
-                text_encoder=pipe.text_encoder,
-                tokenizer=pipe.tokenizer,
-                unet=pipe.unet,
-                controlnet=controlnet_model,
-                scheduler=pipe.scheduler,
-                safety_checker=None,
-                feature_extractor=pipe.feature_extractor,
-                requires_safety_checker=False,
-            ).to(device)
-
+            generator = torch.Generator(device=device).manual_seed(seed)
+            image = pipe(
+                prompt=prompt,
+                negative_prompt=negative_prompt,
+                guidance_scale=guidance_scale,
+                num_inference_steps=num_inference_steps,
+                width=width,
+                height=height,
+                generator=generator,
+            ).images[0]
         except Exception as e:
-            raise gr.Error(f"Ошибка загрузки ControlNet ({controlnet_mode}): {e}")
-
-    # ---------------------------
-    #  3) Генератор случайных чисел для детерминированности
-    # ---------------------------
-    generator = torch.Generator(device=device).manual_seed(seed)
-
-    # ---------------------------
-    #  4) Если есть IP-Adapter, подгружаем фичи из референс-изображения
-    # ---------------------------
-    ip_adapter_embedding = None
-    if use_ip_adapter and ip_adapter_model is not None and ip_adapter_model.dummy_weights_loaded:
-        if ip_adapter_image is not None:
-            ip_adapter_embedding = ip_adapter_model.encode_reference_image(ip_adapter_image)
-        else:
-            print("IP-Adapter включён, но не загружено референс-изображение.")
-    elif use_ip_adapter:
-        print("IP-Adapter включён, но модель не загружена или не инициализирована.")
-
-    # ---------------------------
-    #  5) Выполняем диффузию
-    #    (с учётом ControlNet, если включён)
-    # ---------------------------
-
-    # Параметры для ControlNetPipeline
-    #   - Для edge/pose/depth обычно передают control_image через параметр "image"
-    #   - Дополнительно можно задать "controlnet_conditioning_scale" (aka strength)
-    #     чтобы указать вес ControlNet.
-    #   - Документация: https://huggingface.co/docs/diffusers/main/en/api/pipelines/stable_diffusion/controlnet
-    extra_kwargs = {}
-    if use_controlnet and controlnet_image is not None:
-        extra_kwargs["image"] = controlnet_image
-        extra_kwargs["controlnet_conditioning_scale"] = control_strength
-    elif use_controlnet:
-        print("ControlNet включён, но не загружено изображение для ControlNet.")
-
-    # Запуск генерации
-    try:
-        output = local_pipe(
-            prompt=prompt,
-            negative_prompt=negative_prompt,
-            num_inference_steps=num_inference_steps,
-            guidance_scale=guidance_scale,
-            width=width,
-            height=height,
-            generator=generator,
-            **extra_kwargs
-        )
-        image = output.images[0]
-        latents = getattr(output, "latents", None)  # не во всех версиях diffusers есть latents
-    except Exception as e:
-        raise gr.Error(f"Ошибка п��и генерации изображения: {e}")
-
-    # ---------------------------
-    #  6) Применяем IP-Adapter к результату (если нужно).
-    #    В реальных библиотеках IP-Adapter может вмешиваться раньше (до/во время диффузии).
-    #    Для примера демонстрируем "пост-обработку latents" (если latents сохранились).
-    # ---------------------------
-    if use_ip_adapter and ip_adapter_embedding is not None and latents is not None:
-        try:
-            # Простейший «пример» подмешивания в латенты
-            new_latents = ip_adapter_model.blend_latents_with_adapter(latents, ip_adapter_embedding, ip_adapter_scale)
-
-            # Теперь нужно декодировать latents в картинку заново
-            # (подразумеваем, что local_pipe поддерживает .vae.decode())
-            new_latents = new_latents.to(dtype=pipe.vae.dtype)
-            image = pipe.vae.decode(new_latents / 0.18215)
-            image = (image / 2 + 0.5).clamp(0, 1)
-            image = image.detach().cpu().permute(0, 2, 3, 1).numpy()[0]
-            image = (image * 255).astype(np.uint8)
-            image = Image.fromarray(image)
+            raise gr.Error(f"Ошибка при генерации изображения: {e}")
 
-        except Exception as e:
-            raise gr.Error(f"Ошибка при применении IP-Adapter: {e}")
+        return image, seed
 
-    return image, seed
 
-# ------------------------------------------------------------------
 # Примеры для удобного тестирования
-# ------------------------------------------------------------------
 examples = [
     "Astronaut in a jungle, cold color palette, muted colors, detailed, 8k",
     "An astronaut riding a green horse",
     "A delicious ceviche cheesecake slice",
 ]
 
-# ------------------------------------------------------------------
-# CSS (дополнительно, опционально)
-# ------------------------------------------------------------------
+# Дополнительный CSS для оформления
 css = """
 #col-container {
     margin: 0 auto;
@@ -291,167 +187,151 @@ css = """
 }
 """
 
-# ------------------------------------------------------------------
 # Создаём Gradio-приложение
-# ------------------------------------------------------------------
-import sys
-
-def run_app():
-    with gr.Blocks(css=css) as demo:
-        with gr.Column(elem_id="col-container"):
-            gr.Markdown("# Text-to-Image App (ControlNet + IP-Adapter)")
-
-            # Поле для ввода/смены модели
-            model = gr.Textbox(
-                label="Model (HuggingFace repo)",
-                value="CompVis/stable-diffusion-v1-4",
-                interactive=True
-            )
+with gr.Blocks(css=css) as demo:
+    with gr.Column(elem_id="col-container"):
+        gr.Markdown("# Text-to-Image App")
+
+        # Поле для ввода/смены модели
+        model = gr.Textbox(
+            label="Model",
+            value="CompVis/stable-diffusion-v1-4",  # Значение по умолчанию
+            interactive=True,
+        )
+
+        # Основные поля для Prompt и Negative Prompt
+        prompt = gr.Text(
+            label="Prompt",
+            show_label=False,
+            max_lines=1,
+            placeholder="Enter your prompt",
+            container=False,
+        )
+        negative_prompt = gr.Text(
+            label="Negative prompt",
+            max_lines=1,
+            placeholder="Enter a negative prompt",
+            visible=True,
+        )
+
+        # Слайдер для выбора seed
+        seed = gr.Slider(
+            label="Seed",
+            minimum=0,
+            maximum=MAX_SEED,
+            step=1,
+            value=42,
+        )
 
-            # Основные поля для Prompt и Negative Prompt
-            prompt = gr.Text(
-                label="Prompt",
-                show_label=False,
-                max_lines=1,
-                placeholder="Enter your prompt",
-                container=False,
+        # Слайдеры для guidance_scale и num_inference_steps
+        guidance_scale = gr.Slider(
+            label="Guidance scale",
+            minimum=0.0,
+            maximum=10.0,
+            step=0.1,
+            value=7.0,
+        )
+        num_inference_steps = gr.Slider(
+            label="Number of inference steps",
+            minimum=1,
+            maximum=50,
+            step=1,
+            value=20,
+        )
+
+        # Чекбокс для включения ControlNet
+        use_controlnet = gr.Checkbox(label="Использовать ControlNet", value=False)
+        # Группа дополнительных настроек для ControlNet (будет показана только при включённом чекбоксе)
+        with gr.Group(visible=False) as controlnet_group:
+            control_strength = gr.Slider(
+                label="ControlNet conditioning scale",
+                minimum=0.0,
+                maximum=2.0,
+                step=0.1,
+                value=0.7,
             )
-            negative_prompt = gr.Text(
-                label="Negative prompt",
-                max_lines=1,
-                placeholder="Enter a negative prompt",
-                visible=True,
+            controlnet_mode = gr.Dropdown(
+                label="Режим работы ControlNet",
+                choices=["edge_detection", "pose_estimation"],
+                value="edge_detection",
             )
-
-            # Слайдер для выбора seed
-            seed = gr.Slider(
-                label="Seed",
-                minimum=0,
-                maximum=MAX_SEED,
-                step=1,
-                value=42,
+            controlnet_image = gr.Image(
+                label="Изображение для ControlNet",
+                source="upload",
+                type="pil",
             )
 
-            # Слайдеры
-            guidance_scale = gr.Slider(
-                label="Guidance scale",
+        # Чекбокс для включения IP‑adapter
+        use_ip_adapter = gr.Checkbox(label="Использовать IP-adapter", value=False)
+        # Группа дополнительных настроек для IP‑adapter
+        with gr.Group(visible=False) as ip_adapter_group:
+            ip_adapter_scale = gr.Slider(
+                label="IP-adapter Scale",
                 minimum=0.0,
-                maximum=15.0,
+                maximum=2.0,
                 step=0.1,
-                value=7.0,
+                value=0.6,
             )
-            num_inference_steps = gr.Slider(
-                label="Number of inference steps",
-                minimum=1,
-                maximum=100,
-                step=1,
-                value=20,
+            ip_adapter_image = gr.Image(
+                label="Изображение для IP-adapter",
+                source="upload",
+                type="pil",
             )
 
-            # Кнопка запуска
-            run_button = gr.Button("Run", variant="primary")
-
-            # Поле для отображения результата
-            result = gr.Image(label="Result", show_label=False)
-
-            # Продвинутые настройки
-            with gr.Accordion("Advanced Settings", open=False):
-                with gr.Row():
-                    width = gr.Slider(
-                        label="Width",
-                        minimum=256,
-                        maximum=MAX_IMAGE_SIZE,
-                        step=64,
-                        value=512,
-                    )
-                    height = gr.Slider(
-                        label="Height",
-                        minimum=256,
-                        maximum=MAX_IMAGE_SIZE,
-                        step=64,
-                        value=512,
-                    )
-
-                # Блоки ControlNet
-                use_controlnet = gr.Checkbox(label="Use ControlNet", value=False)
-                with gr.Group(visible=False) as controlnet_group:
-                    control_strength = gr.Slider(
-                        label="ControlNet Strength (Conditioning Scale)",
-                        minimum=0.0,
-                        maximum=2.0,
-                        step=0.1,
-                        value=1.0,
-                    )
-                    controlnet_mode = gr.Dropdown(
-                        label="ControlNet Mode",
-                        choices=["edge_detection", "pose_estimation", "depth_estimation"],
-                        value="edge_detection",
-                    )
-                    controlnet_image = gr.Image(
-                        label="ControlNet Image (map / pose / edges)",
-                        type="pil"
-                    )
-
-                def update_controlnet_group(use_controlnet):
-                    return {"visible": use_controlnet}
-
-                use_controlnet.change(
-                    update_controlnet_group,
-                    inputs=[use_controlnet],
-                    outputs=[controlnet_group]
+        # Обработка событий для показа/скрытия дополнительных настроек
+        use_controlnet.change(lambda x: gr.update(visible=x), inputs=use_controlnet, outputs=controlnet_group)
+        use_ip_adapter.change(lambda x: gr.update(visible=x), inputs=use_ip_adapter, outputs=ip_adapter_group)
+
+        # Кнопка запуска
+        run_button = gr.Button("Run", variant="primary")
+
+        # Поле для отображения результата
+        result = gr.Image(label="Result", show_label=False)
+
+        # Продвинутые настройки (Accordion)
+        with gr.Accordion("Advanced Settings", open=False):
+            with gr.Row():
+                width = gr.Slider(
+                    label="Width",
+                    minimum=256,
+                    maximum=MAX_IMAGE_SIZE,
+                    step=32,
+                    value=512,
                 )
-
-                # Блоки IP-adapter
-                use_ip_adapter = gr.Checkbox(label="Use IP-adapter", value=False)
-                with gr.Group(visible=False) as ip_adapter_group:
-                    ip_adapter_scale = gr.Slider(
-                        label="IP-adapter Scale",
-                        minimum=0.0,
-                        maximum=2.0,
-                        step=0.1,
-                        value=1.0,
-                    )
-                    ip_adapter_image = gr.Image(
-                        label="IP-adapter Image (reference)",
-                        type="pil"
-                    )
-
-                def update_ip_adapter_group(use_ip_adapter):
-                    return {"visible": use_ip_adapter}
-
-                use_ip_adapter.change(
-                    update_ip_adapter_group,
-                    inputs=[use_ip_adapter],
-                    outputs=[ip_adapter_group]
+                height = gr.Slider(
+                    label="Height",
+                    minimum=256,
+                    maximum=MAX_IMAGE_SIZE,
+                    step=32,
+                    value=512,
                 )
 
-            # Примеры
-            gr.Examples(examples=examples, inputs=[prompt])
-
-            # Связка кнопки "Run" с функцией "infer"
-            run_button.click(
-                infer,
-                inputs=[
-                    model,
-                    prompt,
-                    negative_prompt,
-                    seed,
-                    width,
-                    height,
-                    guidance_scale,
-                    num_inference_steps,
-                    use_controlnet,
-                    control_strength,
-                    controlnet_mode,
-                    controlnet_image,
-                    use_ip_adapter,
-                    ip_adapter_scale,
-                    ip_adapter_image
-                ],
-                outputs=[result, seed],
-            )
-
-    demo.launch()
+        # Примеры
+        gr.Examples(examples=examples, inputs=[prompt])
+
+        # Связка кнопки "Run" с функцией "infer"
+        run_button.click(
+            infer,
+            inputs=[
+                model,
+                prompt,
+                negative_prompt,
+                seed,
+                width,
+                height,
+                guidance_scale,
+                num_inference_steps,
+                use_controlnet,
+                control_strength,
+                controlnet_mode,
+                controlnet_image,
+                use_ip_adapter,
+                ip_adapter_scale,
+                ip_adapter_image,
+            ],
+            outputs=[result, seed],
+        )
 
+# Запуск приложения
 if __name__ == "__main__":
-    run_app()
+    demo.launch()