Update app.py

app.py

@@ -1,103 +1,220 @@
-import os
-import time
 import gradio as gr
 import torch
 from diffusers import StableDiffusionPipeline, EulerDiscreteScheduler
+from transformers import AutoModelForCausalLM, AutoTokenizer
 from PIL import Image
+import time
 import json
-from datetime import datetime
 
-# 📦 ДВЕ МОДЕЛИ ДЛЯ ВЫБОРА
-MODELS = {
-    "dreamlike": {
-        "name": "dreamlike-art/dreamlike-photoreal-2.0",
-        "display": "✨ Dreamlike Photoreal 2.0",
-        "description": "Художественный фотореализм, яркие цвета",
-        "default_steps": 25,
-        "max_size": 768
-    },
-    "sd15": {
-        "name": "runwayml/stable-diffusion-v1-5",
-        "display": "🎨 Stable Diffusion 1.5",
-        "description": "Классическая модель, стабильная детализация",
-        "default_steps": 25,
-        "max_size": 512
-    }
-}
+# ==================== НАСТРОЙКИ ====================
+DEVICE = "cuda" if torch.cuda.is_available() else "cpu"
+logger.info(f"Using device: {DEVICE}")
 
-class SimpleGenerator:
+# ==================== ЗАГРУЗКА ДВУХ AI МОДЕЛЕЙ ====================
+
+# 1. AI ДЛЯ ОБРАБОТКИ ПРОМПТОВ (Llama или небольшая модель)
+class PromptAI:
     def __init__(self):
-        self.device = "cpu"
-        self.current_model = None
-        self.pipe = None
-        self.history = []
+        self.model = None
+        self.tokenizer = None
+        self.loaded = False
         
-        print("🤖 Инициализация генератора...")
-        print(f"💻 Устройство: {self.device}")
+    def load(self):
+        """Загружаем модель для обработки текста"""
+        try:
+            # Используем небольшую модель для промптов
+            model_name = "microsoft/DialoGPT-small"
+            logger.info(f"Loading prompt AI: {model_name}")
+            
+            self.tokenizer = AutoTokenizer.from_pretrained(model_name)
+            self.model = AutoModelForCausalLM.from_pretrained(model_name)
+            
+            if DEVICE == "cuda":
+                self.model = self.model.half().to(DEVICE)
+            else:
+                self.model = self.model.to(DEVICE)
+                
+            self.loaded = True
+            logger.info("✅ Prompt AI loaded")
+            return True
+        except Exception as e:
+            logger.error(f"Error loading prompt AI: {e}")
+            return False
+    
+    def enhance_prompt(self, russian_prompt: str) -> dict:
+        """Улучшает русский промпт"""
+        if not self.loaded:
+            return self._enhance_fallback(russian_prompt)
+        
+        try:
+            # Простая логика улучшения
+            enhanced = self._simple_enhance(russian_prompt)
+            
+            return {
+                "english_prompt": enhanced["english"],
+                "negative_prompt": enhanced["negative"],
+                "style": enhanced["style"],
+                "steps": enhanced["steps"],
+                "size": enhanced["size"],
+                "enhancements": enhanced["enhancements"]
+            }
+        except Exception as e:
+            logger.error(f"Prompt enhancement error: {e}")
+            return self._enhance_fallback(russian_prompt)
     
-    def load_model(self, model_key):
-        """Загружает выбранную модель"""
-        if model_key not in MODELS:
-            return False, f"❌ Модель {model_key} не найдена"
+    def _simple_enhance(self, prompt: str) -> dict:
+        """Простое улучшение промпта"""
+        # Перевод ключевых слов
+        translations = {
+            "кот": "cat", "кошка": "cat",
+            "собака": "dog", 
+            "девушка": "woman", "женщина": "woman",
+            "парень": "man", "мужчина": "man",
+            "красивый": "beautiful", "милый": "cute",
+            "детальный": "detailed", "яркий": "bright",
+            "лес": "forest", "море": "sea", "горы": "mountains",
+            "город": "city", "космос": "space",
+            "портрет": "portrait", "пейзаж": "landscape",
+            "аниме": "anime", "фэнтези": "fantasy",
+            "фотореалистично": "photorealistic"
+        }
+        
+        # Переводим
+        english = prompt
+        for rus, eng in translations.items():
+            if rus in prompt.lower():
+                english = english.replace(rus, eng)
+        
+        # Определяем стиль
+        prompt_lower = prompt.lower()
+        if any(word in prompt_lower for word in ["аниме", "anime"]):
+            style = "anime"
+            enhancements = "anime style, manga, Japanese animation, vibrant colors, detailed"
+            negative = "realistic, photorealistic, 3d, blurry, deformed, ugly"
+            steps, size = 22, 384
+        elif any(word in prompt_lower for word in ["фэнтези", "fantasy", "магия", "дракон"]):
+            style = "fantasy"
+            enhancements = "fantasy art, magical, epic, concept art, digital painting"
+            negative = "realistic, mundane, boring, modern, simple"
+            steps, size = 23, 384
+        elif any(word in prompt_lower for word in ["портрет", "portrait", "лицо", "человек"]):
+            style = "portrait"
+            enhancements = "portrait, beautiful face, detailed eyes, perfect skin, studio lighting"
+            negative = "ugly, deformed, bad anatomy, extra limbs, cartoon"
+            steps, size = 25, 384
+        elif any(word in prompt_lower for word in ["пейзаж", "landscape", "природа"]):
+            style = "landscape"
+            enhancements = "landscape, scenery, nature, detailed environment, beautiful view"
+            negative = "closeup, portrait, person, face, indoor"
+            steps, size = 20, 384
+        else:
+            style = "general"
+            enhancements = "masterpiece, best quality, detailed, beautiful, high resolution"
+            negative = "blurry, deformed, ugly, bad anatomy, cartoon, watermark"
+            steps, size = 22, 384
         
-        model_info = MODELS[model_key]
+        # Собираем финальный промпт
+        final_english = f"{english}, {enhancements}"
         
+        # Ограничиваем длину
+        if len(final_english.split()) > 40:
+            words = final_english.split()[:35]
+            final_english = " ".join(words) + ", detailed, high quality"
+        
+        return {
+            "english": final_english,
+            "negative": negative,
+            "style": style,
+            "steps": steps,
+            "size": size,
+            "enhancements": enhancements
+        }
+    
+    def _enhance_fallback(self, prompt: str) -> dict:
+        """Fallback если AI не работает"""
+        return {
+            "english_prompt": f"{prompt}, masterpiece, best quality, detailed",
+            "negative_prompt": "blurry, deformed, ugly, bad anatomy",
+            "style": "general",
+            "steps": 25,
+            "size": 512,
+            "enhancements": "basic enhancements"
+        }
+
+# 2. AI ДЛЯ ГЕНЕРАЦИИ ИЗОБРАЖЕНИЙ (Stable Diffusion)
+class ImageAI:
+    def __init__(self):
+        self.pipe = None
+        self.current_model = None
+        self.models = {
+            "dreamlike": {
+                "name": "dreamlike-art/dreamlike-photoreal-2.0",
+                "display": "✨ Dreamlike Photoreal 2.0",
+                "default_steps": 25,
+                "max_size": 768
+            },
+            "sd15": {
+                "name": "runwayml/stable-diffusion-v1-5",
+                "display": "🎨 Stable Diffusion 1.5",
+                "default_steps": 25,
+                "max_size": 512
+            }
+        }
+    
+    def load_model(self, model_key="dreamlike"):
+        """Загружает модель Stable Diffusion"""
         try:
-            print(f"🚀 Загружаем {model_info['display']}...")
-            start_time = time.time()
+            if model_key not in self.models:
+                return False, "Model not found"
+            
+            model_info = self.models[model_key]
             
-            # Выгружаем предыдущую модель для экономии памяти
+            # Выгружаем предыдущую модель
             if self.pipe is not None:
                 del self.pipe
                 torch.cuda.empty_cache() if torch.cuda.is_available() else None
             
+            logger.info(f"Loading image model: {model_info['display']}")
+            
             # Загружаем новую модель
             self.pipe = StableDiffusionPipeline.from_pretrained(
                 model_info["name"],
-                torch_dtype=torch.float32,
+                torch_dtype=torch.float16 if DEVICE == "cuda" else torch.float32,
                 safety_checker=None,
                 requires_safety_checker=False
             )
             
-            self.pipe = self.pipe.to(self.device)
+            self.pipe = self.pipe.to(DEVICE)
             self.pipe.scheduler = EulerDiscreteScheduler.from_config(
                 self.pipe.scheduler.config
             )
-            self.pipe.enable_attention_slicing()
             
-            load_time = time.time() - start_time
-            self.current_model = model_key
+            if DEVICE == "cuda":
+                self.pipe.enable_attention_slicing()
+                self.pipe.enable_xformers_memory_efficient_attention()
             
-            print(f"✅ {model_info['display']} загружена за {load_time:.1f} сек")
-            return True, f"✅ {model_info['display']} загружена!\n📝 {model_info['description']}"
+            self.current_model = model_key
+            logger.info(f"✅ Image model loaded: {model_info['display']}")
+            return True, f"✅ {model_info['display']} loaded"
             
         except Exception as e:
-            print(f"❌ Ошибка загрузки: {e}")
-            return False, f"❌ Ошибка загрузки: {str(e)[:100]}"
+            logger.error(f"Error loading image model: {e}")
+            return False, f"Error: {str(e)}"
     
-    def generate(self, prompt, negative_prompt="", steps=25, seed=-1, size=512):
-        """Генерация изображения"""
+    def generate_image(self, prompt, negative_prompt="", steps=25, seed=-1, size=512):
+        """Генерирует изображение"""
         if self.pipe is None:
-            return None, "❌ Модель не загружена. Выберите модель сначала."
-        
-        model_info = MODELS[self.current_model]
-        
-        # Ограничиваем размер по модели
-        if size > model_info["max_size"]:
-            size = model_info["max_size"]
-        
-        # Seed
-        if seed == -1:
-            seed = int(time.time()) % 1000000
-        generator = torch.Generator(device=self.device).manual_seed(seed)
-        
-        print(f"\n🎨 ГЕНЕРАЦИЯ [{model_info['display']}]")
-        print(f"   📝 Промпт: {prompt[:60]}...")
-        print(f"   🔢 Шаги: {steps}, Размер: {size}x{size}, Seed: {seed}")
-        
-        start_time = time.time()
+            return None, "Image model not loaded"
         
         try:
+            # Seed
+            if seed == -1:
+                seed = int(time.time()) % 1000000
+            generator = torch.Generator(device=DEVICE).manual_seed(seed)
+            
+            logger.info(f"Generating image: {prompt[:50]}...")
+            
+            # Генерация
             image = self.pipe(
                 prompt=prompt,
                 negative_prompt=negative_prompt,
@@ -108,225 +225,331 @@ class SimpleGenerator:
                 width=size
             ).images[0]
             
-            gen_time = time.time() - start_time
-            
-            # Сохраняем в историю
-            history_entry = {
-                "timestamp": datetime.now().isoformat(),
-                "model": model_info["display"],
-                "prompt": prompt,
-                "time": gen_time,
-                "steps": steps,
-                "size": size,
-                "seed": seed
-            }
-            self.history.append(history_entry)
-            
-            # Информация
             info = f"""
-            ✅ **Готово!**  
-            🎨 **Модель:** {model_info['display']}  
-            🕐 **Время:** {gen_time:.1f} секунд  
-            🔢 **Шаги:** {steps}  
-            📏 **Размер:** {size}x{size}  
+            ✅ **Generation Complete!**  
+            🎨 **Model:** {self.models[self.current_model]['display']}  
+            🔢 **Steps:** {steps}  
+            📏 **Size:** {size}x{size}  
             🎲 **Seed:** {seed}  
             
-            💡 **Совет:** Используйте этот seed ({seed}) для повторения
+            💡 **Tip:** Use seed {seed} to reproduce
             """
             
             return image, info
             
         except Exception as e:
-            print(f"💥 Ошибка генерации: {e}")
-            return None, f"❌ Ошибка генерации: {str(e)[:200]}"
+            logger.error(f"Generation error: {e}")
+            return None, f"Error: {str(e)}"
+
+# ==================== ИНИЦИАЛИЗАЦИЯ AI ====================
+logger.info("=" * 60)
+logger.info("🚀 INITIALIZING DUAL AI SYSTEM")
+logger.info("=" * 60)
+
+# Создаем обе AI
+prompt_ai = PromptAI()
+image_ai = ImageAI()
+
+# Загружаем модели
+logger.info("Loading AI models...")
+
+# Загружаем промпт AI
+prompt_loaded = prompt_ai.load()
+
+# Загружаем модель изображений по умолчанию
+image_loaded, image_msg = image_ai.load_model("dreamlike")
+
+logger.info(f"Prompt AI loaded: {prompt_loaded}")
+logger.info(f"Image AI loaded: {image_loaded}")
+
+# ==================== GRADIO ИНТЕРФЕЙС ====================
+def enhance_prompt_interface(russian_prompt):
+    """Интерфейс для улучшения промптов"""
+    if not russian_prompt or len(russian_prompt.strip()) < 2:
+        return "Please enter a prompt", "", "", 25, 512
     
-    def get_history_html(self):
-        """Получает историю в HTML формате"""
-        if not self.history:
-            return "<p style='color: #666; text-align: center;'>История пуста</p>"
-        
-        html = "<div style='max-height: 300px; overflow-y: auto; padding: 10px;'>"
-        
-        # Группируем по мо��елям для статистики
-        model_stats = {}
-        for entry in self.history:
-            model = entry["model"]
-            if model not in model_stats:
-                model_stats[model] = {"count": 0, "total_time": 0}
-            model_stats[model]["count"] += 1
-            model_stats[model]["total_time"] += entry["time"]
-        
-        # Статистика
-        html += "<div style='background: #f8f9fa; padding: 10px; border-radius: 8px; margin-bottom: 15px;'>"
-        html += "<strong>📊 Статистика:</strong><br>"
-        for model, stats in model_stats.items():
-            avg_time = stats["total_time"] / stats["count"]
-            html += f"{model}: {stats['count']} раз, среднее время: {avg_time:.1f} сек<br>"
-        html += "</div>"
-        
-        # Последние генерации
-        for entry in reversed(self.history[-5:]):
-            dt = datetime.fromisoformat(entry["timestamp"]).strftime("%H:%M")
-            
-            html += f"""
-            <div style='
-                border: 1px solid #ddd; 
-                border-radius: 8px; 
-                padding: 12px; 
-                margin-bottom: 10px;
-                background: white;
-            '>
-                <div style='display: flex; justify-content: space-between;'>
-                    <span style='font-weight: 500;'>{entry['model']}</span>
-                    <span style='color: #888; font-size: 12px;'>{dt}</span>
-                </div>
-                <div style='margin: 5px 0; color: #333;'>{entry['prompt'][:50]}...</div>
-                <div style='font-size: 12px; color: #666;'>
-                    ⏱️ {entry['time']:.1f} сек • 🔢 {entry['steps']} шагов • 📏 {entry['size']}px
-                </div>
-            </div>
-            """
-        
-        html += "</div>"
-        return html
+    result = prompt_ai.enhance_prompt(russian_prompt.strip())
+    
+    # Форматируем вывод
+    output = f"""
+    🤖 **AI ENHANCED PROMPT**
+    
+    **Original (Russian):** {russian_prompt}
+    
+    **Enhanced (English):** {result['english_prompt']}
+    
+    **Negative Prompt:** {result['negative_prompt']}
+    
+    **Style:** {result['style']}
+    **Recommended Steps:** {result['steps']}
+    **Recommended Size:** {result['size']}px
+    
+    **Enhancements:** {result['enhancements']}
+    """
+    
+    return output, result['english_prompt'], result['negative_prompt'], result['steps'], result['size']
 
-# Инициализация
-print("=" * 60)
-print("🎯 ГЕНЕРАТОР С ВЫБОРОМ МОДЕЛИ")
-print("=" * 60)
-generator = SimpleGenerator()
+def generate_image_interface(prompt, negative_prompt, steps, seed, size, model_choice):
+    """Интерфейс для генерации изображений"""
+    # Загружаем выбранную модель если нужно
+    if image_ai.current_model != model_choice:
+        success, msg = image_ai.load_model(model_choice)
+        if not success:
+            return None, f"❌ {msg}"
+    
+    # Генерация
+    image, info = image_ai.generate_image(
+        prompt=prompt,
+        negative_prompt=negative_prompt,
+        steps=steps,
+        seed=seed,
+        size=size
+    )
+    
+    return image, info
 
-# Создаем интерфейс
-with gr.Blocks() as demo:
+def dual_ai_workflow(russian_prompt, model_choice="dreamlike"):
+    """Полный workflow: улучшение промпта + генерация"""
+    # 1. Улучшаем промпт
+    if not russian_prompt:
+        return None, "Please enter a prompt", "", "", 25, 512
+    
+    logger.info(f"🤖 Step 1: Enhancing prompt: {russian_prompt[:50]}...")
+    enhanced_info, english_prompt, negative_prompt, steps, size = enhance_prompt_interface(russian_prompt)
+    
+    # 2. Генерируем изображение
+    logger.info(f"🎨 Step 2: Generating image with enhanced prompt...")
+    image, gen_info = generate_image_interface(
+        prompt=english_prompt,
+        negative_prompt=negative_prompt,
+        steps=steps,
+        seed=-1,
+        size=size,
+        model_choice=model_choice
+    )
+    
+    # 3. Объединяем информацию
+    full_info = f"""
+    {enhanced_info}
+    
+    ---
+    
+    {gen_info}
+    """
+    
+    return image, full_info, english_prompt, negative_prompt, steps, size
+
+# ==================== СОЗДАНИЕ ИНТЕРФЕЙСА ====================
+with gr.Blocks(theme=gr.themes.Soft(), title="🤖 Dual AI System") as demo:
     gr.Markdown("""
-    # 🎨 Генератор с выбором модели
-    ### Сравниваем Dreamlike Photoreal 2.0 и Stable Diffusion 1.5
+    # 🤖 DUAL AI SYSTEM
+    ## Two AI Models Working Together
+    
+    1. **🤖 Prompt AI** - Enhances and translates Russian prompts
+    2. **🎨 Image AI** - Generates high-quality images
     
-    <div style='background: #f0f7ff; padding: 20px; border-radius: 10px; border-left: 5px solid #4a6fa5;'>
-    <strong>✨ Как использовать:</strong>
-    <ol>
-        <li>Выберите модель из списка</li>
-        <li>Нажмите "Загрузить модель"</li>
-        <li>Введите промпт и настройте параметры</li>
-        <li>Нажмите "Сгенерировать"</li>
-    </ol>
-    </div>
+    **Simply enter a Russian description and get a perfect image!**
     """)
     
-    with gr.Row():
-        with gr.Column(scale=1):
-            # Выбор модели
-            gr.Markdown("### 1. 🎯 Выберите модель")
-            model_selector = gr.Radio(
-                choices=[
-                    ("✨ Dreamlike Photoreal 2.0 (художественный)", "dreamlike"),
-                    ("🎨 Stable Diffusion 1.5 (классический)", "sd15")
-                ],
-                value="dreamlike",
-                label="Модель",
-                interactive=True
-            )
+    with gr.Tabs():
+        with gr.TabItem("🚀 Full AI Workflow"):
+            with gr.Row():
+                with gr.Column(scale=1):
+                    gr.Markdown("### 1. Enter Russian Description")
+                    russian_input = gr.Textbox(
+                        label="Describe your image in Russian",
+                        value="красивый кот с зелеными глазами",
+                        lines=3
+                    )
+                    
+                    model_selector = gr.Radio(
+                        choices=[
+                            ("✨ Dreamlike Photoreal 2.0", "dreamlike"),
+                            ("🎨 Stable Diffusion 1.5", "sd15")
+                        ],
+                        value="dreamlike",
+                        label="Select Image Model"
+                    )
+                    
+                    generate_btn = gr.Button(
+                        "🤖 Process with Dual AI", 
+                        variant="primary",
+                        size="lg"
+                    )
+                    
+                    gr.Markdown("### Quick Examples:")
+                    with gr.Row():
+                        ex1 = gr.Button("🐱 Cute Cat", size="sm")
+                        ex2 = gr.Button("👩 Anime Girl", size="sm")
+                        ex3 = gr.Button("🏞️ Fantasy Landscape", size="sm")
+                
+                with gr.Column(scale=1):
+                    gr.Markdown("### 2. AI Enhanced Result")
+                    output_image = gr.Image(label="Generated Image", height=400)
+                    
+                    output_info = gr.Markdown(
+                        label="AI Processing Info",
+                        value="*AI will show processing information here*"
+                    )
+                    
+                    with gr.Accordion("📋 Enhanced Parameters", open=False):
+                        english_display = gr.Textbox(label="English Prompt", interactive=False)
+                        negative_display = gr.Textbox(label="Negative Prompt", interactive=False)
+                        steps_display = gr.Number(label="Steps", interactive=False)
+                        size_display = gr.Number(label="Size", interactive=False)
             
-            load_model_btn = gr.Button("📥 Загрузить модель", variant="secondary")
-            model_status = gr.Markdown("Выберите модель и загрузите её")
+            # Связываем кнопки
+            generate_btn.click(
+                fn=dual_ai_workflow,
+                inputs=[russian_input, model_selector],
+                outputs=[output_image, output_info, english_display, negative_display, steps_display, size_display]
+            )
             
-            gr.Markdown("---")
+            # Примеры
+            ex1.click(
+                fn=lambda: ("милый котенок с большими глазами, пушистая шерсть",),
+                inputs=[],
+                outputs=[russian_input]
+            )
+            ex2.click(
+                fn=lambda: ("аниме девушка с розовыми волосами, детальные глаза, фэнтези лес",),
+                inputs=[],
+                outputs=[russian_input]
+            )
+            ex3.click(
+                fn=lambda: ("фэнтезийный пейзаж с драконом, магия, эпичное небо, закат",),
+                inputs=[],
+                outputs=[russian_input]
+            )
+        
+        with gr.TabItem("🔧 Separate Tools"):
+            with gr.Row():
+                with gr.Column():
+                    gr.Markdown("### 🤖 Prompt Enhancer AI")
+                    prompt_input = gr.Textbox(
+                        label="Russian Prompt",
+                        value="красивая девушка с голубыми глазами",
+                        lines=3
+                    )
+                    enhance_btn = gr.Button("Enhance Prompt", variant="secondary")
+                    
+                    enhanced_output = gr.Markdown(label="Enhanced Prompt")
+                    
+                    with gr.Row():
+                        enhanced_english = gr.Textbox(label="English Prompt", interactive=True)
+                        enhanced_negative = gr.Textbox(label="Negative Prompt", interactive=True)
+                    
+                    with gr.Row():
+                        enhanced_steps = gr.Number(label="Recommended Steps", value=25)
+                        enhanced_size = gr.Number(label="Recommended Size", value=512)
+                
+                with gr.Column():
+                    gr.Markdown("### 🎨 Image Generator AI")
+                    
+                    with gr.Row():
+                        gen_prompt = gr.Textbox(label="English Prompt", value="beautiful woman with blue eyes")
+                        gen_negative = gr.Textbox(label="Negative Prompt", value="blurry, deformed, ugly")
+                    
+                    with gr.Row():
+                        gen_steps = gr.Slider(15, 50, 25, label="Steps")
+                        gen_size = gr.Slider(256, 768, 512, step=64, label="Size")
+                        gen_seed = gr.Number(-1, label="Seed (-1 for random)")
+                    
+                    gen_model = gr.Radio(
+                        choices=["dreamlike", "sd15"],
+                        value="dreamlike",
+                        label="Model"
+                    )
+                    
+                    gen_btn = gr.Button("Generate Image", variant="primary")
+                    
+                    gen_image = gr.Image(label="Generated Image", height=400)
+                    gen_info = gr.Markdown(label="Generation Info")
             
-            # Промпты
-            gr.Markdown("### 2. 📝 Описание")
-            prompt = gr.Textbox(
-                label="Что создать?",
-                value="close-up portrait of a woman with beautiful detailed eyes, photorealistic",
-                lines=3
+            # Связываем enhancer
+            enhance_btn.click(
+                fn=enhance_prompt_interface,
+                inputs=[prompt_input],
+                outputs=[enhanced_output, enhanced_english, enhanced_negative, enhanced_steps, enhanced_size]
             )
             
-            negative = gr.Textbox(
-                label="Чего избегать",
-                value="blurry, deformed, ugly, cartoon",
-                lines=2
+            # Автоматически заполняем генератор при улучшении
+            enhanced_english.change(
+                fn=lambda x: x,
+                inputs=[enhanced_english],
+                outputs=[gen_prompt]
+            )
+            enhanced_negative.change(
+                fn=lambda x: x,
+                inputs=[enhanced_negative],
+                outputs=[gen_negative]
+            )
+            enhanced_steps.change(
+                fn=lambda x: x,
+                inputs=[enhanced_steps],
+                outputs=[gen_steps]
+            )
+            enhanced_size.change(
+                fn=lambda x: x,
+                inputs=[enhanced_size],
+                outputs=[gen_size]
             )
             
-            # Настройки
-            with gr.Accordion("⚙️ Настройки генерации", open=False):
-                steps = gr.Slider(15, 35, 25, step=1, label="Количество шагов")
-                seed = gr.Number(-1, label="Seed (-1 = случайный)")
-                size = gr.Slider(384, 768, 512, step=64, label="Размер изображения")
+            # Связываем генератор
+            gen_btn.click(
+                fn=generate_image_interface,
+                inputs=[gen_prompt, gen_negative, gen_steps, gen_seed, gen_size, gen_model],
+                outputs=[gen_image, gen_info]
+            )
+        
+        with gr.TabItem("📊 System Info"):
+            gr.Markdown("""
+            ## 🤖 DUAL AI SYSTEM INFORMATION
             
-            generate_btn = gr.Button("✨ Сгенерировать изображение", variant="primary", size="lg")
+            ### AI Model 1: Prompt Enhancer
+            - **Purpose:** Translates and enhances Russian prompts
+            - **Model:** Microsoft DialoGPT-small
+            - **Features:**
+              * Russian → English translation
+              * Prompt quality enhancement
+              * Negative prompt generation
+              * Style detection
+              * Parameter recommendation
             
-            # Быстрые промпты
-            gr.Markdown("---")
-            gr.Markdown("### 🚀 Быстрые тесты:")
+            ### AI Model 2: Image Generator
+            - **Purpose:** Generates high-quality images
+            - **Models Available:**
+              1. **Dreamlike Photoreal 2.0** - Photorealistic, artistic
+              2. **Stable Diffusion 1.5** - Classic, detailed
             
-            with gr.Row():
-                test_eyes = gr.Button("👁️ Детальные глаза", size="sm")
-                test_portrait = gr.Button("👩 Художественный портрет", size="sm")
-        
-        with gr.Column(scale=1):
-            # Результат
-            gr.Markdown("### 3. 🎨 Результат")
-            output_image = gr.Image(
-                label="Сгенерированное изображение",
-                height=500
-            )
+            ### Workflow:
+            1. User inputs Russian description
+            2. Prompt AI enhances and translates
+            3. Image AI generates the image
+            4. User gets perfect result
             
-            output_info = gr.Markdown(
-                label="Информация о генерации",
-                value="Здесь появится информация..."
-            )
+            ### System Status:
+            - Prompt AI: **Loaded**
+            - Image AI: **Loaded**
+            - Device: **{device}**
             
-            # История
-            with gr.Accordion("📖 История генераций", open=True):
-                history_display = gr.HTML(
-                    value="<p style='color: #666; text-align: center;'>История пуста</p>"
-                )
+            ### Requirements:
+            - GPU recommended for faster generation
+            - 8GB+ VRAM for best performance
+            - Hugging Face token for models
+            """.format(device=DEVICE.upper()))
     
-    # Обработчики событий
-    def load_model_handler(model_key):
-        success, message = generator.load_model(model_key)
-        return message
-    
-    def generate_handler(prompt, negative, steps, seed, size):
-        return generator.generate(prompt, negative, steps, seed, size)
-    
-    def update_history():
-        return generator.get_history_html()
-    
-    # Привязка кнопок
-    load_model_btn.click(
-        fn=load_model_handler,
-        inputs=[model_selector],
-        outputs=[model_status]
-    )
-    
-    generate_btn.click(
-        fn=generate_handler,
-        inputs=[prompt, negative, steps, seed, size],
-        outputs=[output_image, output_info]
-    ).then(
-        fn=update_history,
-        inputs=None,
-        outputs=[history_display]
-    )
-    
-    # Быстрые промпты
-    test_eyes.click(
-        fn=lambda: ("macro photography of stunning blue eyes with water droplets, detailed iris, eyelashes, extreme close-up, photorealistic, 8k resolution", "blurry, makeup, photoshop"),
-        inputs=None,
-        outputs=[prompt, negative]
-    )
-    
-    test_portrait.click(
-        fn=lambda: ("beautiful woman in traditional dress, intricate jewelry, soft natural lighting, detailed fabric texture, portrait photography, professional", "cartoon, 3d, cgi, blurry"),
-        inputs=None,
-        outputs=[prompt, negative]
-    )
+    # Footer
+    gr.Markdown("""
+    ---
+    *Powered by 🤖 Dual AI System | Made with Gradio & Hugging Face*
+    """)
 
-# Запуск
+# ==================== ЗАПУСК ====================
 if __name__ == "__main__":
     demo.launch(
         server_name="0.0.0.0",
         server_port=7860,
-        share=False,
-        show_error=True
+        share=True,
+        debug=True
     )