Upload app.py with huggingface_hub

app.py

@@ -3,7 +3,6 @@ import numpy as np
 import random
 import json
 import torch
-import cv2
 from PIL import Image
 
 # Опциональный импорт spaces - нужен только для HF Spaces
@@ -23,13 +22,7 @@ import os
 import time
 import logging
 
-from diffusers import (
-    DiffusionPipeline,
-    QwenImageControlNetPipeline,
-    QwenImageControlNetModel,
-    AutoPipelineForImage2Image
-)
-from huggingface_hub import hf_hub_download
+from diffusers import DiffusionPipeline, AutoPipelineForImage2Image
 
 # Настройка логирования
 logging.basicConfig(
@@ -39,28 +32,10 @@ logging.basicConfig(
 )
 logger = logging.getLogger(__name__)
 
-# Preprocessor imports
-try:
-    from controlnet_aux import OpenposeDetector, AnylineDetector
-    CONTROLNET_AUX_AVAILABLE = True
-except ImportError:
-    CONTROLNET_AUX_AVAILABLE = False
-
-try:
-    from depth_anything_v2.dpt import DepthAnythingV2
-    DEPTH_ANYTHING_AVAILABLE = True
-except ImportError:
-    DEPTH_ANYTHING_AVAILABLE = False
-
 logger.info("=" * 60)
-logger.info("LOADING QWEN-SOLOBAND ADVANCED")
+logger.info("QWEN-SOLOBAND: Text2Image + Image2Image + LoRA")
 logger.info("=" * 60)
-
-# Логируем доступность препроцессоров
-if not CONTROLNET_AUX_AVAILABLE:
-    logger.warning("⚠️ controlnet_aux not available - Pose/Soft Edge будут упрощенными")
-if not DEPTH_ANYTHING_AVAILABLE:
-    logger.warning("⚠️ depth_anything_v2 not available - Depth будет упрощенным")
+logger.info(f"Environment: {'HF Spaces' if HF_SPACES else 'RunPod/Local'}")
 
 hf_token = os.environ.get("HF_TOKEN")
 device = "cuda" if torch.cuda.is_available() else "cpu"
@@ -79,19 +54,16 @@ if torch.cuda.is_available():
 # ЗАГРУЗКА МОДЕЛЕЙ
 # =================================================================
 
-# 1. Базовая модель для Text-to-Image
-logger.info("\n[1/3] Loading base Text2Image model...")
 model_id = "Gerchegg/Qwen-Soloband-Diffusers"
 
+# 1. Text2Image модель
+logger.info("\n[1/2] Loading Text2Image model...")
 try:
     start_time = time.time()
     
-    # Определяем device_map
     if gpu_count > 1:
         device_map = "balanced"
         logger.info(f"  Device map: balanced ({gpu_count} GPUs)")
-        
-        # Загружаем базовую модель с распределением
         pipe_txt2img = DiffusionPipeline.from_pretrained(
             model_id,
             torch_dtype=dtype,
@@ -100,8 +72,6 @@ try:
         )
     else:
         logger.info("  Device map: single GPU")
-        
-        # Для одной GPU загружаем сразу на устройство (экономит память)
         pipe_txt2img = DiffusionPipeline.from_pretrained(
             model_id,
             torch_dtype=dtype,
@@ -115,8 +85,8 @@ except Exception as e:
     logger.error(f"  ❌ Error loading Text2Image: {e}")
     raise
 
-# 2. Image-to-Image модель (используем ту же базу)
-logger.info("\n[2/3] Creating Image2Image pipeline...")
+# 2. Image2Image модель
+logger.info("\n[2/2] Creating Image2Image pipeline...")
 try:
     pipe_img2img = AutoPipelineForImage2Image.from_pipe(pipe_txt2img)
     logger.info("  ✓ Image2Image pipeline created")
@@ -124,69 +94,9 @@ except Exception as e:
     logger.error(f"  ❌ Error creating Image2Image: {e}")
     pipe_img2img = None
 
-# 3. ControlNet модель
-logger.info("\n[3/3] Loading ControlNet model...")
-try:
-    controlnet_model_id = "InstantX/Qwen-Image-ControlNet-Union"
-    
-    # Проверяем наличие модели в кэше и скачиваем если нет
-    import os
-    from pathlib import Path
-    
-    # Используем /workspace/.cache на RunPod или ~/.cache локально
-    if os.path.exists("/workspace"):
-        cache_base = Path("/workspace/.cache")
-    else:
-        cache_base = Path.home() / ".cache"
-    
-    cache_dir = cache_base / "huggingface" / "hub" / "models--InstantX--Qwen-Image-ControlNet-Union"
-    
-    if not cache_dir.exists():
-        logger.info("  📥 ControlNet не найден в кэше, скачиваю...")
-        logger.info(f"  Это займет 1-2 минуты...")
-        
-        try:
-            from huggingface_hub import snapshot_download
-            os.environ["HF_HUB_ENABLE_HF_TRANSFER"] = "0"
-            
-            snapshot_download(
-                repo_id=controlnet_model_id,
-                local_dir=cache_dir,
-                token=hf_token,
-                ignore_patterns=["*.md"]
-            )
-            logger.info("  ✓ ControlNet успешно загружен в кэш")
-        except Exception as download_error:
-            logger.warning(f"  ⚠️ Не удалось загрузить ControlNet: {download_error}")
-            logger.warning("  Продолжаем без ControlNet...")
-            raise download_error
-    else:
-        logger.info("  ✓ ControlNet найден в кэше")
-    
-    controlnet = QwenImageControlNetModel.from_pretrained(
-        controlnet_model_id,
-        torch_dtype=dtype,
-        token=hf_token
-    )
-    
-    # Создаем ControlNet pipeline на базе базовой модели
-    pipe_controlnet = QwenImageControlNetPipeline.from_pretrained(
-        model_id,
-        controlnet=controlnet,
-        torch_dtype=dtype,
-        token=hf_token
-    ).to(device)
-    
-    logger.info("  ✓ ControlNet loaded")
-    
-except Exception as e:
-    logger.error(f"  ❌ Error loading ControlNet: {e}")
-    logger.warning("  ControlNet will be disabled")
-    pipe_controlnet = None
-
 # Оптимизации памяти
 logger.info("\nApplying memory optimizations...")
-for pipe in [pipe_txt2img, pipe_img2img, pipe_controlnet]:
+for pipe in [pipe_txt2img, pipe_img2img]:
     if pipe and hasattr(pipe, 'vae'):
         if hasattr(pipe.vae, 'enable_tiling'):
             pipe.vae.enable_tiling()
@@ -200,54 +110,7 @@ logger.info("✓ ALL MODELS LOADED")
 logger.info("=" * 60)
 
 # =================================================================
-# ЗАГРУЗКА ПРЕПРОЦЕССОРОВ
-# =================================================================
-
-openpose_detector = None
-anyline_detector = None
-depth_anything = None
-
-if CONTROLNET_AUX_AVAILABLE:
-    try:
-        logger.info("\nLoading advanced preprocessors...")
-        openpose_detector = OpenposeDetector.from_pretrained("lllyasviel/Annotators")
-        logger.info("  ✓ OpenPose detector loaded")
-    except Exception as e:
-        logger.warning(f"  ⚠️ OpenPose failed: {e}")
-    
-    try:
-        anyline_detector = AnylineDetector.from_pretrained(
-            "TheMistoAI/MistoLine",
-            filename="MTEED.pth",
-            subfolder="Anyline"
-        ).to(device)
-        logger.info("  ✓ Anyline (Soft Edge) detector loaded")
-    except Exception as e:
-        logger.warning(f"  ⚠️ Anyline failed: {e}")
-
-if DEPTH_ANYTHING_AVAILABLE:
-    try:
-        logger.info("\nLoading Depth Anything V2...")
-        depth_model_config = {
-            'encoder': 'vitl',
-            'features': 256,
-            'out_channels': [256, 512, 1024, 1024]
-        }
-        depth_anything = DepthAnythingV2(**depth_model_config)
-        depth_anything_ckpt_path = hf_hub_download(
-            repo_id="depth-anything/Depth-Anything-V2-Large",
-            filename="depth_anything_v2_vitl.pth",
-            repo_type="model"
-        )
-        depth_anything.load_state_dict(torch.load(depth_anything_ckpt_path, map_location="cpu"))
-        depth_anything = depth_anything.to(device).eval()
-        logger.info("  ✓ Depth Anything V2 loaded")
-    except Exception as e:
-        logger.warning(f"  ⚠️ Depth Anything V2 failed: {e}")
-        depth_anything = None
-
-# =================================================================
-# PREPROCESSOR FUNCTIONS
+# HELPER FUNCTIONS
 # =================================================================
 
 def resize_image(input_image, max_size=1024):
@@ -271,65 +134,10 @@ def resize_image(input_image, max_size=1024):
     
     return input_image.resize((new_w, new_h), Image.Resampling.LANCZOS)
 
-def extract_canny(input_image, low_threshold=100, high_threshold=200):
-    """Canny edge detection"""
-    image = np.array(input_image)
-    edges = cv2.Canny(image, low_threshold, high_threshold)
-    edges = edges[:, :, None]
-    edges = np.concatenate([edges, edges, edges], axis=2)
-    return Image.fromarray(edges)
-
-def extract_depth(input_image):
-    """Depth map extraction using Depth Anything V2 or simple grayscale"""
-    if depth_anything is not None:
-        # Используем Depth Anything V2
-        image_np = np.array(input_image)
-        with torch.no_grad():
-            depth = depth_anything.infer_image(image_np[:, :, ::-1])
-        depth = (depth - depth.min()) / (depth.max() - depth.min()) * 255.0
-        depth = depth.astype(np.uint8)
-        return Image.fromarray(depth).convert('RGB')
-    else:
-        # Fallback - простая grayscale карта
-        gray = input_image.convert('L')
-        return gray.convert('RGB')
-
-def extract_pose(input_image):
-    """Pose detection using OpenPose or Canny fallback"""
-    if openpose_detector is not None:
-        # Используем OpenPose
-        return openpose_detector(input_image, hand_and_face=True)
-    else:
-        # Fallback - Canny edges
-        return extract_canny(input_image)
-
-def extract_soft_edge(input_image):
-    """Soft Edge detection using Anyline or Canny fallback"""
-    if anyline_detector is not None:
-        # Используем Anyline для мягких краев
-        return anyline_detector(input_image)
-    else:
-        # Fallback - Canny edges
-        return extract_canny(input_image)
-
-def get_control_image(input_image, control_type):
-    """Применяет препроцессор к изображению"""
-    if control_type == "Canny":
-        return extract_canny(input_image)
-    elif control_type == "Soft Edge":
-        return extract_soft_edge(input_image)
-    elif control_type == "Depth":
-        return extract_depth(input_image)
-    elif control_type == "Pose":
-        return extract_pose(input_image)
-    else:
-        return extract_canny(input_image)  # Fallback
-
 # =================================================================
 # LORA FUNCTIONS
 # =================================================================
 
-# Список доступных LoRA
 AVAILABLE_LORAS = {
     "Realism": {
         "repo": "flymy-ai/qwen-image-realism-lora",
@@ -348,6 +156,38 @@ AVAILABLE_LORAS = {
     }
 }
 
+loaded_loras = {}
+
+def load_lora(pipe, lora_name):
+    """Загружает LoRA в pipeline"""
+    if lora_name == "None" or lora_name not in AVAILABLE_LORAS:
+        return pipe
+    
+    if lora_name in loaded_loras:
+        logger.info(f"  Using cached LoRA: {lora_name}")
+        return pipe
+    
+    lora_info = AVAILABLE_LORAS[lora_name]
+    logger.info(f"  Loading LoRA: {lora_name} from {lora_info['repo']}")
+    
+    try:
+        pipe.load_lora_weights(
+            lora_info["repo"],
+            weight_name=lora_info["weights"]
+        )
+        loaded_loras[lora_name] = True
+        logger.info(f"  ✓ LoRA loaded: {lora_name}")
+    except Exception as e:
+        logger.warning(f"  ⚠️ Failed to load LoRA {lora_name}: {e}")
+    
+    return pipe
+
+def unload_loras(pipe):
+    """Выгружает все LoRA"""
+    if hasattr(pipe, 'unload_lora_weights'):
+        pipe.unload_lora_weights()
+        loaded_loras.clear()
+
 # =================================================================
 # GENERATION FUNCTIONS
 # =================================================================
@@ -378,29 +218,17 @@ def generate_text2img(
         seed = random.randint(0, MAX_SEED)
     
     logger.info(f"  Prompt: {prompt[:100]}...")
-    logger.info(f"  Size: {width}x{height}")
+    logger.info(f"  Resolution: {width}x{height}")
     logger.info(f"  Steps: {num_inference_steps}, CFG: {guidance_scale}")
-    logger.info(f"  Seed: {seed}")
-    logger.info(f"  LoRA: {lora_name} (scale: {lora_scale})")
+    logger.info(f"  Seed: {seed}, LoRA: {lora_name}")
     
     try:
         # Загружаем LoRA если выбрана
-        if lora_name != "None" and lora_name in AVAILABLE_LORAS:
-            lora_info = AVAILABLE_LORAS[lora_name]
-            logger.info(f"  Loading LoRA: {lora_info['repo']}")
-            
-            pipe_txt2img.load_lora_weights(
-                lora_info['repo'],
-                weight_name=lora_info.get('weights', 'pytorch_lora_weights.safetensors'),
-                token=hf_token
-            )
-            
-            # Добавляем trigger word
-            if lora_info['trigger']:
-                prompt = lora_info['trigger'] + prompt
-                logger.info(f"  Added trigger: {lora_info['trigger']}")
+        if lora_name != "None":
+            load_lora(pipe_txt2img, lora_name)
+            pipe_txt2img.set_adapters([lora_name], adapter_weights=[lora_scale])
         
-        generator = torch.Generator(device=device).manual_seed(seed)
+        generator = torch.Generator(device="cuda:0" if torch.cuda.is_available() else "cpu").manual_seed(seed)
         
         image = pipe_txt2img(
             prompt=prompt,
@@ -412,11 +240,7 @@ def generate_text2img(
             generator=generator
         ).images[0]
         
-        # Выгружаем LoRA после генерации
-        if lora_name != "None":
-            pipe_txt2img.unload_lora_weights()
-        
-        logger.info("  ✓ Generation completed")
+        logger.info("  ✓ Generation complete")
         
         return image, seed
         
@@ -444,37 +268,28 @@ def generate_img2img(
     logger.info("IMAGE-TO-IMAGE GENERATION")
     logger.info("=" * 60)
     
-    if input_image is None:
-        raise gr.Error("Please upload an input image")
+    if pipe_img2img is None:
+        raise gr.Error("Image2Image pipeline not available")
     
     if randomize_seed:
         seed = random.randint(0, MAX_SEED)
     
-    # Изменяем размер изображения
+    # Resize изображение
     resized = resize_image(input_image, max_size=1024)
     
     logger.info(f"  Prompt: {prompt[:100]}...")
-    logger.info(f"  Input size: {input_image.size} → {resized.size}")
+    logger.info(f"  Image size: {resized.size}")
     logger.info(f"  Strength: {strength}")
     logger.info(f"  Steps: {num_inference_steps}, CFG: {guidance_scale}")
-    logger.info(f"  LoRA: {lora_name}")
+    logger.info(f"  Seed: {seed}, LoRA: {lora_name}")
     
     try:
-        if pipe_img2img is None:
-            raise gr.Error("Image2Image pipeline not available")
-        
         # Загружаем LoRA если выбрана
-        if lora_name != "None" and lora_name in AVAILABLE_LORAS:
-            lora_info = AVAILABLE_LORAS[lora_name]
-            pipe_img2img.load_lora_weights(
-                lora_info['repo'],
-                weight_name=lora_info.get('weights', 'pytorch_lora_weights.safetensors'),
-                token=hf_token
-            )
-            if lora_info['trigger']:
-                prompt = lora_info['trigger'] + prompt
+        if lora_name != "None":
+            load_lora(pipe_img2img, lora_name)
+            pipe_img2img.set_adapters([lora_name], adapter_weights=[lora_scale])
         
-        generator = torch.Generator(device=device).manual_seed(seed)
+        generator = torch.Generator(device="cuda:0" if torch.cuda.is_available() else "cpu").manual_seed(seed)
         
         image = pipe_img2img(
             prompt=prompt,
@@ -482,296 +297,193 @@ def generate_img2img(
             image=resized,
             strength=strength,
             num_inference_steps=num_inference_steps,
-            true_cfg_scale=guidance_scale,
-            generator=generator
-        ).images[0]
-        
-        # Выгружаем LoRA
-        if lora_name != "None":
-            pipe_img2img.unload_lora_weights()
-        
-        logger.info("  ✓ Generation completed")
-        
-        return image, seed
-        
-    except Exception as e:
-        logger.error(f"  ❌ Error: {e}")
-        raise
-
-@spaces.GPU(duration=180)
-def generate_controlnet(
-    input_image,
-    prompt,
-    control_type="Canny",
-    negative_prompt=" ",
-    controlnet_conditioning_scale=1.0,
-    seed=42,
-    randomize_seed=False,
-    guidance_scale=5.0,
-    num_inference_steps=30,
-    lora_name="None",
-    lora_scale=1.0,
-    progress=gr.Progress(track_tqdm=True)
-):
-    """ControlNet генерация"""
-    
-    logger.info("\n" + "=" * 60)
-    logger.info("CONTROLNET GENERATION")
-    logger.info("=" * 60)
-    
-    if input_image is None:
-        raise gr.Error("Please upload an input image")
-    
-    if pipe_controlnet is None:
-        raise gr.Error("ControlNet pipeline not available")
-    
-    if randomize_seed:
-        seed = random.randint(0, MAX_SEED)
-    
-    # Изменяем размер и применяем препроцессор
-    resized = resize_image(input_image, max_size=1024)
-    control_image = get_control_image(resized, control_type)
-    
-    logger.info(f"  Prompt: {prompt[:100]}...")
-    logger.info(f"  Control type: {control_type}")
-    logger.info(f"  Control scale: {controlnet_conditioning_scale}")
-    logger.info(f"  Image size: {resized.size}")
-    logger.info(f"  LoRA: {lora_name}")
-    
-    try:
-        # Загружаем LoRA если выбрана
-        if lora_name != "None" and lora_name in AVAILABLE_LORAS:
-            lora_info = AVAILABLE_LORAS[lora_name]
-            pipe_controlnet.load_lora_weights(
-                lora_info['repo'],
-                weight_name=lora_info.get('weights', 'pytorch_lora_weights.safetensors'),
-                token=hf_token
-            )
-            if lora_info['trigger']:
-                prompt = lora_info['trigger'] + prompt
-        
-        generator = torch.Generator(device=device).manual_seed(seed)
-        
-        image = pipe_controlnet(
-            prompt=prompt,
-            negative_prompt=negative_prompt,
-            control_image=control_image,
-            controlnet_conditioning_scale=controlnet_conditioning_scale,
-            width=resized.width,
-            height=resized.height,
-            num_inference_steps=num_inference_steps,
             guidance_scale=guidance_scale,
             generator=generator
         ).images[0]
         
-        # Выгружаем LoRA
-        if lora_name != "None":
-            pipe_controlnet.unload_lora_weights()
-        
-        logger.info("  ✓ Generation completed")
+        logger.info("  ✓ Generation complete")
         
-        return image, control_image, seed
+        return image, seed
         
     except Exception as e:
         logger.error(f"  ❌ Error: {e}")
         raise
 
 # =================================================================
-# GRADIO INTERFACE
+# UI
 # =================================================================
 
-MAX_SEED = np.iinfo(np.int32).max
-
 css = """
 #col-container {
     margin: 0 auto;
-    max-width: 1400px;
+    max-width: 1200px;
 }
 """
 
-with gr.Blocks(css=css, theme=gr.themes.Soft()) as demo:
+# Загрузка examples
+try:
+    examples = json.loads(open("examples.json").read())
+except:
+    examples = []
+
+with gr.Blocks(css=css) as demo:
     gr.Markdown("""
-    # 🎨 Qwen Soloband - Image2Image + ControlNet + LoRA
+    # 🎨 Qwen Soloband: Text2Image + Image2Image + LoRA
     
-    **Продвинутая модель генерации** с поддержкой Image-to-Image, ControlNet и LoRA.
+    **Кастомная модель генерации изображений** на базе Qwen-Image DiT архитектуры.
     
-    ### ✨ Возможности:
-    - 🖼️ **Text-to-Image** - Генерация из текста
-    - 🔄 **Image-to-Image** - Модификация изображений (denoising strength)
-    - 🎮 **ControlNet** - Управление структурой (Canny, Depth, Pose)
-    - 🎭 **LoRA** - Стилизация (Realism, Anime, Film)
-    - 🔌 **Full API** - Все функции доступны через API
+    ### ✨ Возможности
+    - 🔥 **Text-to-Image** - генерация из текста
+    - 🖼️ **Image-to-Image** - преобразование изображений  
+    - 🎯 **LoRA поддержка** - Realism, Anime, Analog Film
+    - 🚀 **Multi-GPU** - автоматическое распределение
+    - ⚡ **Оптимизированная память** - VAE tiling/slicing
     
-    **Модель**: [Gerchegg/Qwen-Soloband-Diffusers](https://huggingface.co/Gerchegg/Qwen-Soloband-Diffusers)
+    **Модель**: [Qwen-Soloband-Diffusers](https://huggingface.co/Gerchegg/Qwen-Soloband-Diffusers)
     """)
     
-    with gr.Tabs() as tabs:
-        
-        # TAB 1: Text-to-Image
-        with gr.Tab("📝 Text-to-Image"):
+    with gr.Tabs():
+        # ============= TAB 1: TEXT2IMAGE =============
+        with gr.Tab("🎨 Text-to-Image"):
             with gr.Row():
                 with gr.Column(scale=1):
-                    t2i_prompt = gr.Text(
+                    t2i_prompt = gr.Textbox(
                         label="Prompt",
-                        placeholder="SB_AI, a beautiful landscape...",
+                        placeholder="SB_AI, a beautiful landscape with mountains...",
                         lines=3
                     )
+                    t2i_run = gr.Button("Generate", variant="primary", size="lg")
                     
-                    t2i_run = gr.Button("Generate", variant="primary")
-                    
-                    with gr.Accordion("Advanced Settings", open=False):
-                        t2i_negative = gr.Text(label="Negative Prompt", value="blurry, low quality")
+                    with gr.Accordion("Settings", open=False):
+                        t2i_negative = gr.Textbox(
+                            label="Negative Prompt",
+                            value="blurry, low quality, ugly, bad anatomy",
+                            lines=2
+                        )
                         
                         with gr.Row():
-                            t2i_width = gr.Slider(label="Width", minimum=512, maximum=2048, step=64, value=1664)
-                            t2i_height = gr.Slider(label="Height", minimum=512, maximum=2048, step=64, value=928)
+                            t2i_width = gr.Slider(
+                                label="Width", minimum=512, maximum=2048, step=64, value=1664
+                            )
+                            t2i_height = gr.Slider(
+                                label="Height", minimum=512, maximum=2048, step=64, value=928
+                            )
                         
                         with gr.Row():
-                            t2i_steps = gr.Slider(label="Steps", minimum=1, maximum=50, step=1, value=40)
-                            t2i_cfg = gr.Slider(label="CFG", minimum=0.0, maximum=7.5, step=0.1, value=2.5)
+                            t2i_cfg = gr.Slider(
+                                label="CFG Scale", minimum=1.0, maximum=7.5, step=0.1, value=2.5
+                            )
+                            t2i_steps = gr.Slider(
+                                label="Steps", minimum=1, maximum=50, step=1, value=40
+                            )
                         
                         with gr.Row():
-                            t2i_seed = gr.Slider(label="Seed", minimum=0, maximum=MAX_SEED, step=1, value=0)
-                            t2i_random_seed = gr.Checkbox(label="Random", value=True)
+                            t2i_seed = gr.Slider(
+                                label="Seed", minimum=0, maximum=MAX_SEED, step=1, value=42
+                            )
+                            t2i_random_seed = gr.Checkbox(label="Random seed", value=True)
                         
-                        t2i_lora = gr.Radio(
-                            label="LoRA Style",
-                            choices=["None"] + list(AVAILABLE_LORAS.keys()),
-                            value="None"
-                        )
-                        t2i_lora_scale = gr.Slider(label="LoRA Strength", minimum=0.0, maximum=2.0, step=0.1, value=1.0)
+                        with gr.Row():
+                            t2i_lora = gr.Dropdown(
+                                label="LoRA",
+                                choices=["None"] + list(AVAILABLE_LORAS.keys()),
+                                value="None"
+                            )
+                            t2i_lora_scale = gr.Slider(
+                                label="LoRA Scale", minimum=0.0, maximum=2.0, step=0.1, value=1.0
+                            )
                 
                 with gr.Column(scale=1):
                     t2i_output = gr.Image(label="Generated Image")
                     t2i_seed_output = gr.Number(label="Used Seed")
+            
+            t2i_run.click(
+                fn=generate_text2img,
+                inputs=[
+                    t2i_prompt, t2i_negative, t2i_width, t2i_height,
+                    t2i_seed, t2i_random_seed, t2i_cfg, t2i_steps,
+                    t2i_lora, t2i_lora_scale
+                ],
+                outputs=[t2i_output, t2i_seed_output],
+                api_name="text2img"
+            )
         
-        # TAB 2: Image-to-Image
-        with gr.Tab("🔄 Image-to-Image"):
+        # ============= TAB 2: IMAGE2IMAGE =============
+        with gr.Tab("🖼️ Image-to-Image"):
             with gr.Row():
                 with gr.Column(scale=1):
                     i2i_input = gr.Image(type="pil", label="Input Image")
-                    i2i_prompt = gr.Text(
+                    i2i_prompt = gr.Textbox(
                         label="Prompt",
-                        placeholder="Transform this image into...",
+                        placeholder="Enhanced version...",
                         lines=3
                     )
+                    i2i_run = gr.Button("Generate", variant="primary", size="lg")
                     
-                    i2i_strength = gr.Slider(
-                        label="Denoising Strength",
-                        info="0.0 = original image, 1.0 = complete redraw",
-                        minimum=0.0,
-                        maximum=1.0,
-                        step=0.05,
-                        value=0.75
-                    )
-                    
-                    i2i_run = gr.Button("Generate", variant="primary")
-                    
-                    with gr.Accordion("Advanced Settings", open=False):
-                        i2i_negative = gr.Text(label="Negative Prompt", value="blurry, low quality")
-                        
-                        with gr.Row():
-                            i2i_steps = gr.Slider(label="Steps", minimum=1, maximum=50, step=1, value=40)
-                            i2i_cfg = gr.Slider(label="CFG", minimum=0.0, maximum=7.5, step=0.1, value=2.5)
-                        
-                        with gr.Row():
-                            i2i_seed = gr.Slider(label="Seed", minimum=0, maximum=MAX_SEED, step=1, value=0)
-                            i2i_random_seed = gr.Checkbox(label="Random", value=True)
+                    with gr.Accordion("Settings", open=False):
+                        i2i_negative = gr.Textbox(
+                            label="Negative Prompt",
+                            value="blurry, low quality, ugly",
+                            lines=2
+                        )
                         
-                        i2i_lora = gr.Radio(
-                            label="LoRA Style",
-                            choices=["None"] + list(AVAILABLE_LORAS.keys()),
-                            value="None"
+                        i2i_strength = gr.Slider(
+                            label="Strength (transformation amount)",
+                            minimum=0.1, maximum=1.0, step=0.05, value=0.75
                         )
-                        i2i_lora_scale = gr.Slider(label="LoRA Strength", minimum=0.0, maximum=2.0, step=0.1, value=1.0)
-                
-                with gr.Column(scale=1):
-                    i2i_output = gr.Image(label="Generated Image")
-                    i2i_seed_output = gr.Number(label="Used Seed")
-        
-        # TAB 3: ControlNet
-        with gr.Tab("🎮 ControlNet"):
-            with gr.Row():
-                with gr.Column(scale=1):
-                    cn_input = gr.Image(type="pil", label="Input Image")
-                    cn_prompt = gr.Text(
-                        label="Prompt",
-                        placeholder="A detailed description...",
-                        lines=3
-                    )
-                    
-                    cn_control_type = gr.Radio(
-                        label="Control Type (Preprocessor)",
-                        choices=["Canny", "Soft Edge", "Depth", "Pose"],
-                        value="Canny"
-                    )
-                    
-                    cn_control_scale = gr.Slider(
-                        label="Control Strength",
-                        minimum=0.0,
-                        maximum=2.0,
-                        step=0.05,
-                        value=1.0
-                    )
-                    
-                    cn_run = gr.Button("Generate", variant="primary")
-                    
-                    with gr.Accordion("Advanced Settings", open=False):
-                        cn_negative = gr.Text(label="Negative Prompt", value="blurry, low quality")
                         
                         with gr.Row():
-                            cn_steps = gr.Slider(label="Steps", minimum=1, maximum=50, step=1, value=30)
-                            cn_cfg = gr.Slider(label="CFG", minimum=1.0, maximum=10.0, step=0.1, value=5.0)
+                            i2i_cfg = gr.Slider(
+                                label="CFG Scale", minimum=1.0, maximum=7.5, step=0.1, value=2.5
+                            )
+                            i2i_steps = gr.Slider(
+                                label="Steps", minimum=1, maximum=50, step=1, value=40
+                            )
                         
                         with gr.Row():
-                            cn_seed = gr.Slider(label="Seed", minimum=0, maximum=MAX_SEED, step=1, value=0)
-                            cn_random_seed = gr.Checkbox(label="Random", value=True)
+                            i2i_seed = gr.Slider(
+                                label="Seed", minimum=0, maximum=MAX_SEED, step=1, value=42
+                            )
+                            i2i_random_seed = gr.Checkbox(label="Random seed", value=True)
                         
-                        cn_lora = gr.Radio(
-                            label="LoRA Style",
-                            choices=["None"] + list(AVAILABLE_LORAS.keys()),
-                            value="None"
-                        )
-                        cn_lora_scale = gr.Slider(label="LoRA Strength", minimum=0.0, maximum=2.0, step=0.1, value=1.0)
+                        with gr.Row():
+                            i2i_lora = gr.Dropdown(
+                                label="LoRA",
+                                choices=["None"] + list(AVAILABLE_LORAS.keys()),
+                                value="None"
+                            )
+                            i2i_lora_scale = gr.Slider(
+                                label="LoRA Scale", minimum=0.0, maximum=2.0, step=0.1, value=1.0
+                            )
                 
                 with gr.Column(scale=1):
-                    cn_control_preview = gr.Image(label="Control Image (Preprocessed)")
-                    cn_output = gr.Image(label="Generated Image")
-                    cn_seed_output = gr.Number(label="Used Seed")
+                    i2i_output = gr.Image(label="Generated Image")
+                    i2i_seed_output = gr.Number(label="Used Seed")
+            
+            i2i_run.click(
+                fn=generate_img2img,
+                inputs=[
+                    i2i_input, i2i_prompt, i2i_negative, i2i_strength,
+                    i2i_seed, i2i_random_seed, i2i_cfg, i2i_steps,
+                    i2i_lora, i2i_lora_scale
+                ],
+                outputs=[i2i_output, i2i_seed_output],
+                api_name="img2img"
+            )
     
-    # Event handlers
-    t2i_run.click(
-        fn=generate_text2img,
-        inputs=[
-            t2i_prompt, t2i_negative, t2i_width, t2i_height,
-            t2i_seed, t2i_random_seed, t2i_cfg, t2i_steps,
-            t2i_lora, t2i_lora_scale
-        ],
-        outputs=[t2i_output, t2i_seed_output],
-        api_name="text2img"
-    )
+    gr.Markdown("""
+    ### 💡 Советы
     
-    i2i_run.click(
-        fn=generate_img2img,
-        inputs=[
-            i2i_input, i2i_prompt, i2i_negative, i2i_strength,
-            i2i_seed, i2i_random_seed, i2i_cfg, i2i_steps,
-            i2i_lora, i2i_lora_scale
-        ],
-        outputs=[i2i_output, i2i_seed_output],
-        api_name="img2img"
-    )
+    **Промпты**: Используйте префикс `SB_AI,` для лучших результатов
     
-    cn_run.click(
-        fn=generate_controlnet,
-        inputs=[
-            cn_input, cn_prompt, cn_control_type, cn_negative, cn_control_scale,
-            cn_seed, cn_random_seed, cn_cfg, cn_steps,
-            cn_lora, cn_lora_scale
-        ],
-        outputs=[cn_output, cn_control_preview, cn_seed_output],
-        api_name="controlnet"
-    )
+    **Разрешения**:
+    - 1664×928 (16:9) - широкоформатное
+    - 1328×1328 (1:1) - квадрат  
+    - 928×1664 (9:16) - портрет
+    - 1472×1140 (4:3) - стандарт
+    
+    **LoRA**: Можно комбинировать с промптом для стилизации
+    """)
 
 if __name__ == "__main__":
     demo.launch(