Update app.py

app.py

@@ -1,39 +1,27 @@
 import gradio as gr
+from transformers import pipeline, AutoTokenizer, AutoModelForCausalLM
 import torch
-from transformers import (
-    AutoTokenizer, 
-    AutoModelForCausalLM,
-    pipeline,
-    BitsAndBytesConfig
-)
 import time
 import re
 
-# ================== НАСТРОЙКА МОДЕЛЕЙ ==================
-# Выбор: загружать обе модели сразу или только выбранную
-# Для экономии памяти на CPU можно грузить только активную модель
+# ================== НАСТРОЙКА МОДЕЛЕЙ (ИСПРАВЛЕННАЯ) ==================
+# Используем только открытые и легкие модели
 MODEL_CONFIGS = {
-    "gemma": {
-        "name": "google/gemma-2b-it",
-        "quantized": False,  # Можно использовать 4-битную версию если найдете
-        "requires_auth": False  # Gemma требует принятия лицензии
+    "qwen": {
+        "name": "Qwen/Qwen2.5-0.5B-Instruct",
+        "size": "0.5B",
+        "description": "Быстрая и умная, отлично понимает русский",
+        "requires_auth": False
     },
-    "phi2": {
-        "name": "microsoft/phi-2",
-        "quantized": False,
+    "tinyllama": {
+        "name": "TinyLlama/TinyLlama-1.1B-Chat-v1.0",
+        "size": "1.1B", 
+        "description": "Очень быстрая, хорошо для простых промтов",
         "requires_auth": False
     }
 }
 
-# Конфигурация для экономии памяти (4-битное квантование)
-bnb_config = BitsAndBytesConfig(
-    load_in_4bit=True,
-    bnb_4bit_compute_dtype=torch.float16,
-    bnb_4bit_quant_type="nf4",
-    bnb_4bit_use_double_quant=True
-)
-
-# Инициализация переменных
+# Инициализация
 models = {}
 tokenizers = {}
 
@@ -50,85 +38,113 @@ def load_model(model_key):
         # Загружаем токенизатор
         tokenizer = AutoTokenizer.from_pretrained(
             config["name"],
-            trust_remote_code=config.get("trust_remote_code", False)
+            trust_remote_code=True
         )
         
-        # Конфигурация для модели
-        model_kwargs = {
-            "torch_dtype": torch.float16,
-            "device_map": "auto",
-            "trust_remote_code": config.get("trust_remote_code", False),
-        }
-        
-        if config["quantized"]:
-            model_kwargs["quantization_config"] = bnb_config
-        
-        # Особые настройки для каждой модели
-        if model_key == "gemma":
+        # Для TinyLlama добавляем pad_token
+        if model_key == "tinyllama":
             tokenizer.pad_token = tokenizer.eos_token
-            tokenizer.padding_side = "left"
-        elif model_key == "phi2":
-            tokenizer.pad_token = tokenizer.eos_token
-            
-        # Загружаем модель
+        
+        # Загружаем модель с квантованием для CPU
         model = AutoModelForCausalLM.from_pretrained(
             config["name"],
-            **model_kwargs
+            torch_dtype=torch.float16 if torch.cuda.is_available() else torch.float32,
+            device_map="auto",
+            trust_remote_code=True,
+            low_cpu_mem_usage=True  # Экономим память
         )
         
         models[model_key] = model
         tokenizers[model_key] = tokenizer
         
-        print(f"Модель {model_key} загружена успешно!")
+        print(f"✅ Модель {model_key} загружена успешно!")
         return model, tokenizer
         
     except Exception as e:
-        print(f"Ошибка загрузки модели {model_key}: {str(e)}")
-        # Fallback на простую логику
+        print(f"❌ Ошибка загрузки модели {model_key}: {str(e)}")
         return None, None
 
 # Загружаем переводчик (он всегда нужен)
 print("Загрузка переводчика...")
-translator = pipeline(
-    "translation_ru_to_en", 
-    model="Helsinki-NLP/opus-mt-ru-en",
-    device_map="auto"
-)
-print("Переводчик загружен!")
+try:
+    translator = pipeline(
+        "translation_ru_to_en", 
+        model="Helsinki-NLP/opus-mt-ru-en",
+        device="cpu"
+    )
+    print("✅ Переводчик загружен!")
+except:
+    print("⚠️ Переводчик не загрузился, используем fallback")
+    translator = None
+
+# ================== ПРОМТ-ШАБЛОНЫ ==================
+PROMPT_TEMPLATES = {
+    "qwen": """<|im_start|>system
+Ты эксперт по созданию промтов для AI-генерации изображений в Dreamlike Photoreal 2.0.
+Твоя задача:
+1. Улучшить и детализировать русский п��омт (добавить описание освещения, времени года, стиля, деталей)
+2. Перевести улучшенный промт на английский для AI-генератора
+3. Создать негативный промт на английском для исключения артефактов
+
+Формат ответа:
+Улучшенный промт: [текст]
+Английский промт: [текст]
+Негативный промт: [текст]<|im_end|>
+<|im_start|>user
+{user_prompt}<|im_end|>
+<|im_start|>assistant""",
+    
+    "tinyllama": """<|system|>
+Ты помощник для создания промтов к генератору изображений. Улучши промт, переведи на английский и создай негативный промт.</s>
+<|user|>
+{user_prompt}</s>
+<|assistant|>"""
+}
 
 # ================== ОСНОВНАЯ ЛОГИКА ==================
-def extract_from_response(response, prompt_type="gemma"):
+def extract_from_response(response):
     """Извлекает структурированные данные из ответа модели"""
-    # Удаляем исходный промт и инструкции
-    lines = response.split('\n')
-    
     result = {"enhanced_ru": "", "optimized_en": "", "negative": ""}
     
     # Паттерны для поиска
     patterns = {
-        "enhanced_ru": [r"Улучшенный[:\s]*(.+)", r"Enhanced.*RU[:\s]*(.+)", r"Улучшенный промт[:\s]*(.+)"],
-        "optimized_en": [r"Английский[:\s]*(.+)", r"English[:\s]*(.+)", r"Optimized[:\s]*(.+)", r"Перевод[:\s]*(.+)"],
-        "negative": [r"Негативный[:\s]*(.+)", r"Negative[:\s]*(.+)", r"Negative prompt[:\s]*(.+)"]
+        "enhanced_ru": [
+            r"Улучшенный промт[:\s]*(.+)",
+            r"Улучшенный[:\s]*(.+)", 
+            r"Enhanced[:\s]*(.+)"
+        ],
+        "optimized_en": [
+            r"Английский промт[:\s]*(.+)",
+            r"Английский[:\s]*(.+)",
+            r"English[:\s]*(.+)",
+            r"Перевод[:\s]*(.+)"
+        ],
+        "negative": [
+            r"Негативный промт[:\s]*(.+)",
+            r"Негативный[:\s]*(.+)",
+            r"Negative[:\s]*(.+)"
+        ]
     }
     
+    # Разделяем на строки и ищем
+    lines = [line.strip() for line in response.split('\n') if line.strip()]
+    
     for line in lines:
-        line_lower = line.lower()
-        
-        for key in patterns:
+        for key, key_patterns in patterns.items():
             if not result[key]:  # Если еще не нашли
-                for pattern in patterns[key]:
+                for pattern in key_patterns:
                     match = re.search(pattern, line, re.IGNORECASE)
                     if match:
-                        result[key] = match.group(1).strip()
+                        result[key] = match.group(1).strip(' :')
                         break
     
-    # Если не нашли через паттерны, берем первые 3 строки
-    if not result["enhanced_ru"] and len(lines) > 1:
-        result["enhanced_ru"] = lines[1].strip()
-    if not result["optimized_en"] and len(lines) > 2:
-        result["optimized_en"] = lines[2].strip()
-    if not result["negative"] and len(lines) > 3:
-        result["negative"] = lines[3].strip()
+    # Fallback: если не нашли паттернами, берем первые строки
+    if not result["enhanced_ru"] and len(lines) > 0:
+        result["enhanced_ru"] = lines[0]
+    if not result["optimized_en"] and len(lines) > 1:
+        result["optimized_en"] = lines[1]
+    if not result["negative"] and len(lines) > 2:
+        result["negative"] = lines[2]
     
     return result
 
@@ -136,91 +152,63 @@ def generate_with_model(prompt_ru, model_key):
     """Генерация улучшенного промта с помощью выбранной модели"""
     model, tokenizer = load_model(model_key)
     
-    if model is None:
-        return "Ошибка загрузки модели", "", ""
-    
-    # Промты для разных моделей
-    templates = {
-        "gemma": f"""<start_of_turn>user
-Ты эксперт по созданию промтов для AI-генерации изображений в Dreamlike Photoreal 2.0.
-
-ВХОДНОЙ ПРОМТ: "{prompt_ru}"
-
-ВЫПОЛНИ 3 ЗАДАЧИ:
-1. УЛУЧШЕННЫЙ ПРОМТ (русский): Детализируй, добавь описания освещения, времени года, стиля, деталей
-2. ОПТИМИЗИРОВАННЫЙ ПРОМТ (английский): Переведи улучшенный промт на английский для AI-генератора
-3. НЕГАТИВНЫЙ ПРОМТ (английский): Создай негативный промт с исключением артефактов
-
-Формат ответа:
-Улучшенный промт: [текст]
-Оптимизированный промт: [текст]
-Негативный промт: [текст]<end_of_turn>
-<start_of_turn>model""",
-        
-        "phi2": f"""Instruct: Ты - AI ассистент для создания промтов к генератору изображений Dreamlike Photoreal 2.0.
-
-Запрос пользователя: {prompt_ru}
-
-Выполни следующие шаги:
-
-1. Улучши и детализируй промт на русском языке, добавь фотографические детали:
-2. Переведи улучшенный промт на английский язык для AI-генератора:
-3. Создай негативный промт (negative prompt) на английском для исключения нежелательных элементов:
-
-Output format:
-Улучшенный промт: [здесь детализированный русский промт]
-Оптимизированный промт: [здесь английский промт для генератора]
-Негативный промт: [здесь негативный промт на английском]"""
-    }
-    
-    prompt_template = templates[model_key]
+    if model is None or tokenizer is None:
+        # Fallback: базовая обработка
+        enhanced = prompt_ru + ", детализировано, высокое качество"
+        if translator:
+            translated = translator(prompt_ru)[0]['translation_text'] + ", detailed, high quality"
+        else:
+            translated = prompt_ru + ", detailed, high quality"
+        negative = "blurry, ugly, deformed, cartoon, text, watermark"
+        return enhanced, translated, negative
     
     try:
+        # Подготавливаем промт
+        template = PROMPT_TEMPLATES[model_key]
+        full_prompt = template.format(user_prompt=prompt_ru)
+        
         # Токенизация
         inputs = tokenizer(
-            prompt_template, 
+            full_prompt, 
             return_tensors="pt",
             truncation=True,
             max_length=512
         )
         
-        # Перенос на устройство модели
-        inputs = {k: v.to(model.device) for k, v in inputs.items()}
-        
         # Генерация
         with torch.no_grad():
             outputs = model.generate(
                 **inputs,
-                max_new_tokens=300,
+                max_new_tokens=256,
                 temperature=0.7,
                 do_sample=True,
                 top_p=0.9,
                 repetition_penalty=1.1,
-                pad_token_id=tokenizer.pad_token_id,
+                pad_token_id=tokenizer.pad_token_id or tokenizer.eos_token_id,
                 eos_token_id=tokenizer.eos_token_id
             )
         
         # Декодирование
         response = tokenizer.decode(outputs[0], skip_special_tokens=True)
         
-        # Извлечение структурированного ответа
-        extracted = extract_from_response(response, model_key)
+        # Удаляем исходный промт из ответа
+        response = response.replace(full_prompt, "").strip()
         
-        # Если extraction не сработал, используем fallback
-        if not extracted["enhanced_ru"]:
-            # Удаляем промт из ответа
-            response_clean = response.replace(prompt_template, "").strip()
-            lines = [line.strip() for line in response_clean.split('\n') if line.strip()]
-            
-            extracted["enhanced_ru"] = lines[0] if len(lines) > 0 else prompt_ru
-            extracted["optimized_en"] = lines[1] if len(lines) > 1 else ""
-            extracted["negative"] = lines[2] if len(lines) > 2 else ""
+        # Извлекаем структурированные данные
+        extracted = extract_from_response(response)
         
         return extracted["enhanced_ru"], extracted["optimized_en"], extracted["negative"]
         
     except Exception as e:
         print(f"Ошибка генерации: {str(e)}")
-        return f"Ошибка: {str(e)}", "", ""
+        # Fallback
+        enhanced = prompt_ru
+        if translator:
+            translated = translator(prompt_ru)[0]['translation_text']
+        else:
+            translated = prompt_ru
+        negative = "blurry, ugly, deformed, cartoon, text"
+        return enhanced, translated, negative
 
 def process_prompt(prompt_ru, model_choice):
     """Основная функция обработки промта"""
@@ -230,44 +218,51 @@ def process_prompt(prompt_ru, model_choice):
         return "Введите промт", "", "", "0.0s"
     
     # Выбор модели
-    model_key = "gemma" if "gemma" in model_choice.lower() else "phi2"
+    if "qwen" in model_choice.lower():
+        model_key = "qwen"
+        model_name = "Qwen2.5-0.5B"
+    else:
+        model_key = "tinyllama" 
+        model_name = "TinyLlama-1.1B"
     
     # 1. Генерация с выбранной LLM
     enhanced_ru, optimized_en, negative_en = generate_with_model(prompt_ru, model_key)
     
     # 2. Если LLM не сгенерировала английский, используем переводчик
-    if not optimized_en or len(optimized_en.split()) < 3:
+    if (not optimized_en or len(optimized_en.split()) < 3) and translator:
         try:
             translated = translator(prompt_ru)[0]['translation_text']
-            if not optimized_en:
+            if not optimized_en or optimized_en == prompt_ru:
                 optimized_en = translated
-            elif "Ошибка" in enhanced_ru:
-                # Fallback: если LLM дала ошибку, используем простую логику
-                enhanced_ru = prompt_ru + ", фотографично, высокое качество, детализировано"
-                optimized_en = translated + ", photorealistic, high quality, detailed, 8k"
         except:
-            optimized_en = prompt_ru + ", photorealistic, high quality"
+            pass
+    
+    # 3. Дополняем если пусто
+    if not enhanced_ru or enhanced_ru == prompt_ru:
+        enhanced_ru = prompt_ru + ", фотографично, высокое качество, детализировано"
     
-    # 3. Дополняем негативный промт если он короткий
-    base_negative = "blurry, ugly, deformed, cartoon, painting, anime, text, watermark, signature, bad quality, worst quality, low quality, jpeg artifacts"
+    if not optimized_en or optimized_en == prompt_ru:
+        optimized_en = enhanced_ru + ", photorealistic, high quality, detailed"
+    
+    # 4. Базовая негативная строка
+    base_negative = "blurry, ugly, deformed, cartoon, painting, anime, text, watermark, signature, bad quality"
     
     if not negative_en or len(negative_en.split(',')) < 3:
         negative_en = base_negative
     else:
         negative_en = base_negative + ", " + negative_en
     
-    # 4. Добавляем контекстные исключения
-    ru_text_lower = enhanced_ru.lower()
-    en_text_lower = optimized_en.lower()
+    # 5. Контекстные улучшения
+    text_for_analysis = (enhanced_ru + " " + optimized_en).lower()
     
-    if any(word in ru_text_lower for word in ["реалистич", "фото", "photoreal"]):
-        negative_en += ", abstract, drawing, sketch, illustration, stylized"
+    if any(word in text_for_analysis for word in ["реалистич", "фото", "photoreal", "realistic"]):
+        negative_en += ", abstract, drawing, sketch, illustration, stylized, painting"
     
-    if any(word in ru_text_lower for word in ["ярк", "солн", "bright"]):
-        negative_en += ", dark, dull, underexposed, gloomy"
+    if any(word in text_for_analysis for word in ["ярк", "солн", "bright", "sunny", "light"]):
+        negative_en += ", dark, dull, underexposed, gloomy, shadow"
     
-    if any(word in ru_text_lower for word in ["портрет", "лицо", "portrait", "face"]):
-        negative_en += ", deformed face, asymmetric eyes, bad anatomy, extra limbs"
+    if any(word in text_for_analysis for word in ["портрет", "лицо", "человек", "portrait", "face", "person"]):
+        negative_en += ", deformed face, asymmetric eyes, bad anatomy, extra limbs, mutated hands"
     
     # Время выполнения
     processing_time = time.time() - start_time
@@ -276,16 +271,18 @@ def process_prompt(prompt_ru, model_choice):
         enhanced_ru, 
         optimized_en, 
         negative_en, 
-        f"⏱️ {processing_time:.1f} сек | Модель: {'Gemma-2B' if model_key == 'gemma' else 'Phi-2'}"
+        f"⏱️ {processing_time:.1f} сек | Модель: {model_name} | Токенов: ~{len(optimized_en.split())}"
     )
 
 # ================== GRADIO ИНТЕРФЕЙС ==================
 css = """
-.gradio-container {max-width: 900px !important;}
-h1 {text-align: center; color: #4f46e5;}
-.model-info {background: #f0f9ff; padding: 10px; border-radius: 10px; margin: 10px 0;}
-.result-box {background: #f8fafc; padding: 15px; border-radius: 8px; border-left: 4px solid #4f46e5;}
-.negative-box {background: #fef2f2; padding: 15px; border-radius: 8px; border-left: 4px solid #dc2626;}
+.gradio-container {max-width: 900px !important; margin: auto;}
+h1 {text-align: center; color: #4f46e5; margin-bottom: 10px;}
+.model-info {background: linear-gradient(135deg, #667eea 0%, #764ba2 100%); color: white; padding: 15px; border-radius: 12px; margin: 10px 0;}
+.result-box {background: #f8fafc; padding: 15px; border-radius: 10px; border-left: 5px solid #4f46e5; margin: 5px 0;}
+.negative-box {background: #fef2f2; padding: 15px; border-radius: 10px; border-left: 5px solid #dc2626; margin: 5px 0;}
+.example-box {background: #f0f9ff; padding: 8px 12px; border-radius: 8px; margin: 3px; cursor: pointer; border: 1px solid #bae6fd;}
+.example-box:hover {background: #e0f2fe;}
 """
 
 with gr.Blocks(css=css, theme=gr.themes.Soft()) as demo:
@@ -295,86 +292,98 @@ with gr.Blocks(css=css, theme=gr.themes.Soft()) as demo:
     """)
     
     with gr.Row():
-        with gr.Column(scale=3):
+        with gr.Column(scale=2):
             input_prompt = gr.Textbox(
-                label="✏️ Ваш промт на русском",
-                placeholder="Например: красивый пейзаж с горами и озером на закате",
-                lines=3
+                label="✏️ **Ваш промт на русском**",
+                placeholder="Например: кот в шляпе читает газету в уютном кафе утром",
+                lines=3,
+                elem_id="input_prompt"
             )
             
             with gr.Row():
                 model_choice = gr.Radio(
-                    choices=["🚀 Gemma-2B (быстрее, проще)", "🎨 Phi-2 (качественнее, умнее)"],
-                    value="🚀 Gemma-2B (быстрее, проще)",
-                    label="Выберите модель для обработки"
+                    choices=["🧠 Qwen2.5-0.5B (умнее, лучше русский)", "⚡ TinyLlama-1.1B (быстрее)"],
+                    value="🧠 Qwen2.5-0.5B (умнее, лучше русский)",
+                    label="**Выберите модель для обработки**",
+                    elem_id="model_choice"
                 )
                 
-                submit_btn = gr.Button("✨ Оптимизировать промт", variant="primary", size="lg")
+            submit_btn = gr.Button("🚀 **Оптимизировать промт**", variant="primary", size="lg", scale=1)
         
-        with gr.Column(scale=2):
+        with gr.Column(scale=1):
             gr.Markdown("""
             <div class="model-info">
-            <h3>🤖 О моделях:</h3>
-            <b>Gemma-2B:</b> Быстрая, хорошо понимает инструкции<br>
-            <b>Phi-2:</b> Качественнее обрабатывает сложные запросы<br><br>
+            <h3>🤖 **Доступные модели:**</h3>
             
-            <b>⚠️ Первый запуск:</b> Загрузка моделей займет 1-2 минуты<br>
-            <b>📦 Память:</b> Используется 4-битное квантование для экономии
-            </div>
+            <b>🧠 Qwen2.5-0.5B</b><br>
+            • Лучшее понимание русского<br>
+            • Качественные улучшения<br>
+            • ~2-4 секунды на CPU<br><br>
+            
+            <b>⚡ TinyLlama-1.1B</b><br>
+            • Максимальная скорость<br>
+            • Хорошо для простых промтов<br>
+            • ~1-2 секунды на CPU<br><br>
             
-            <h3>🎯 Примеры промтов:</h3>
-            • Кот в шляпе читает газету в кафе<br>
-            • Футуристический город ночью с неоновыми огнями<br>
-            • Портрет женщины с рыжими волосами в стиле ретро<br>
-            • Магический лес с светящимися грибами
+            <b>⚠️ Все модели загружены и готовы!</b>
+            </div>
             """)
     
     with gr.Row():
         with gr.Column():
-            gr.Markdown("### 📝 Улучшенный промт (русский)")
+            gr.Markdown("### 📝 **Улучшенный промт (русский)**")
             output_ru = gr.Textbox(
                 label="",
                 lines=3,
-                interactive=False,
-                elem_classes="result-box"
+                interactive=True,
+                elem_classes="result-box",
+                show_copy_button=True
             )
         
         with gr.Column():
-            gr.Markdown("### 🌐 Промт для генератора (английский)")
+            gr.Markdown("### 🌐 **Промт для генератора (английский)**")
             output_en = gr.Textbox(
                 label="",
                 lines=3,
-                interactive=False,
-                elem_classes="result-box"
+                interactive=True, 
+                elem_classes="result-box",
+                show_copy_button=True
             )
     
-    gr.Markdown("### 🚫 Негативный промт (английский)")
+    gr.Markdown("### 🚫 **Негативный промт (английский)**")
+    gr.Markdown("*Скопируйте это в поле 'Negative Prompt' в Dreamlike*")
     output_negative = gr.Textbox(
-        label="Используйте в negative prompt в Dreamlike",
+        label="",
         lines=2,
-        interactive=False,
-        elem_classes="negative-box"
+        interactive=True,
+        elem_classes="negative-box",
+        show_copy_button=True
     )
     
     info_text = gr.Textbox(
-        label="Информация",
+        label="**Информация о выполнении**",
         interactive=False
     )
     
-    # Примеры для быстрого тестирования
-    gr.Markdown("### 🧪 Быстрые примеры (кликните для теста):")
+    # Примеры
+    gr.Markdown("### 🧪 **Быстрые примеры (кликните для теста):**")
     with gr.Row():
         examples = [
-            ["Космонавт играет на гитаре на луне, земля на горизонте"],
-            ["Стимпанк лаборатория с летающими механическими птицами"],
-            ["Магический портал в лесу, светящиеся руны, ночное небо"],
-            ["Киберпанк улица под дождем, неоновые вывески, отражения в лужах"]
+            ["Космонавт играет на гитаре на луне, земля видна на горизонте"],
+            ["Стимпанк лаборатория с летающими механическими птицами и шестеренками"],
+            ["Магический портал в древнем лесу, светящиеся руны, ночное небо с двумя лунами"],
+            ["Киберпанк улица Токио под кислотным дождем, неоновые вывески, отражения"]
         ]
-        gr.Examples(
-            examples=examples,
-            inputs=[input_prompt],
-            label=""
-        )
+        example_components = []
+        for ex in examples:
+            btn = gr.Button(
+                ex[0][:40] + "...",
+                size="sm",
+                variant="secondary",
+                elem_classes="example-box"
+            )
+            btn.click(lambda x=ex[0]: x, outputs=[input_prompt])
+            example_components.append(btn)
     
     # Обработка
     submit_btn.click(
@@ -383,21 +392,30 @@ with gr.Blocks(css=css, theme=gr.themes.Soft()) as demo:
         outputs=[output_ru, output_en, output_negative, info_text]
     )
     
-    # Авто-отправка при нажатии Enter
     input_prompt.submit(
         fn=process_prompt,
         inputs=[input_prompt, model_choice],
         outputs=[output_ru, output_en, output_negative, info_text]
     )
+    
+    # Предзагрузка моделей при старте
+    def preload_models():
+        print("🔧 Предзагрузка моделей...")
+        load_model("qwen")
+        load_model("tinyllama")
+        print("✅ Все модели готовы!")
+        return "Система готова к работе! Выберите модель и введите промт."
+    
+    demo.load(
+        fn=preload_models,
+        outputs=[info_text]
+    )
 
 # ================== ЗАПУСК ==================
 if __name__ == "__main__":
-    # Предзагрузка Gemma для быстрого старта
-    print("Предзагрузка Gemma-2B...")
-    load_model("gemma")
-    
     demo.launch(
         server_name="0.0.0.0",
-        share=False,  # Поставьте True если хотите публичную ссылку
-        debug=True
+        share=True,  # Публичная ссылка
+        debug=False,
+        show_error=True
     )