Update app.py

app.py

@@ -9,6 +9,9 @@ import time
 import os
 import tempfile
 import random
+import threading
+from queue import Queue, Empty
+import warnings
 
 # === OPTIMIERTE EINSTELLUNGEN ===
 device = "cuda" if torch.cuda.is_available() else "cpu"
@@ -41,8 +44,11 @@ MODEL_CONFIGS = {
 # === SAFETENSORS KONFIGURATION ===
 SAFETENSORS_MODELS = ["runwayml/stable-diffusion-v1-5"]
 
-# Aktuell ausgewähltes Modell (wird vom User gesetzt)
-current_model_id = "runwayml/stable-diffusion-v1-5"
+# === GLOBALE CACHE FÜR MODELLE ===
+_model_cache = {}
+_model_cache_lock = threading.Lock()
+_current_loading_model = None
+_loading_lock = threading.Lock()
 
 # === AUTOMATISCHE NEGATIVE PROMPT GENERIERUNG ===
 def auto_negative_prompt(positive_prompt):
@@ -139,28 +145,34 @@ def auto_detect_face_area(image):
     print(f"Geschätzte Gesichtskoordinaten: [{x1}, {y1}, {x2}, {y2}]")
     return [x1, y1, x2, y2]
 
-# === PIPELINES ===
-pipe_txt2img = None
-current_pipe_model_id = None
-pipe_img2img = None
-
-def load_txt2img(model_id):
-    """Lädt das Text-to-Image Modell basierend auf der Auswahl"""
-    global pipe_txt2img, current_pipe_model_id
+# === MODELL-LADEN MIT CACHING UND LOAD-BALANCING ===
+def load_model_with_cache(model_id, force_reload=False):
+    """Lädt Modelle mit Caching und Thread-Sicherheit"""
+    global _model_cache, _current_loading_model
     
-    # Wenn bereits das richtige Modell geladen ist, nichts tun
-    if pipe_txt2img is not None and current_pipe_model_id == model_id:
-        print(f"✅ Modell {model_id} bereits geladen")
-        return pipe_txt2img
+    # Prüfe Cache
+    with _model_cache_lock:
+        if model_id in _model_cache and not force_reload:
+            print(f"✅ Modell {model_id} aus Cache geladen")
+            return _model_cache[model_id]
     
-    print(f"🔄 Lade Modell: {model_id}")
-    
-    config = MODEL_CONFIGS.get(model_id, MODEL_CONFIGS["runwayml/stable-diffusion-v1-5"])
-    print(f"📋 Modell-Konfiguration: {config['name']}")
-    print(f"📝 Beschreibung: {config['description']}")
+    # Verhindere paralleles Laden desselben Modells
+    with _loading_lock:
+        if _current_loading_model == model_id:
+            print(f"⏳ Modell {model_id} wird bereits geladen, warte...")
+            while model_id not in _model_cache:
+                time.sleep(0.1)
+            return _model_cache.get(model_id)
+        
+        _current_loading_model = model_id
     
     try:
-        # VAE-Handling basierend auf Modellkonfiguration
+        print(f"🔄 Lade Modell: {model_id}")
+        
+        config = MODEL_CONFIGS.get(model_id, MODEL_CONFIGS["runwayml/stable-diffusion-v1-5"])
+        print(f"📋 Modell-Konfiguration: {config['name']}")
+        
+        # VAE-Handling
         vae = None
         if config.get("requires_vae", False):
             print(f"🔧 Lade externe VAE: {config['vae_model']}")
@@ -172,16 +184,15 @@ def load_txt2img(model_id):
                 print("✅ VAE erfolgreich geladen")
             except Exception as vae_error:
                 print(f"⚠️ Fehler beim Laden der VAE: {vae_error}")
-                print("ℹ️ Versuche ohne VAE weiter...")
                 vae = None
         
-        # Modellparameter basierend auf Modelltyp
+        # Modellparameter
         model_params = {
             "torch_dtype": torch_dtype,
             "safety_checker": None,
             "requires_safety_checker": False,
             "add_watermarker": False,
-            "allow_pickle": True,  # Für .bin Modelle wichtig
+            "allow_pickle": True,
         }
         
         # SAFETENSORS LOGIK
@@ -192,136 +203,179 @@ def load_txt2img(model_id):
             model_params["use_safetensors"] = False
             print(f"ℹ️ Verwende .bin weights für {model_id}")
         
-        # FP16 Variante nur wenn Modell sie unterstützt UND wir auf GPU sind
+        # FP16 nur wenn unterstützt
         if config.get("supports_fp16", False) and torch_dtype == torch.float16:
             model_params["variant"] = "fp16"
             print("ℹ️ Verwende FP16 Variante")
-        else:
-            print("ℹ️ Verwende Standard Variante (kein FP16)")
         
-        # VAE nur wenn nicht None
+        # VAE hinzufügen
         if vae is not None:
             model_params["vae"] = vae
         
-        print(f"📥 Lade Hauptmodell von Hugging Face...")
-        pipe_txt2img = StableDiffusionPipeline.from_pretrained(
+        print(f"📥 Lade Hauptmodell...")
+        pipe = StableDiffusionPipeline.from_pretrained(
             model_id,
             **model_params
         ).to(device)
         
-        # SICHERER SCHEDULER-HANDLING
-        print("⚙️ Konfiguriere Scheduler...")
-        
-        # Prüfe ob Scheduler existiert
-        if pipe_txt2img.scheduler is None:
+        # Scheduler-Konfiguration
+        if pipe.scheduler is None:
             print("⚠️ Scheduler ist None, setze Standard-Scheduler")
-            pipe_txt2img.scheduler = PNDMScheduler.from_pretrained(
+            pipe.scheduler = PNDMScheduler.from_pretrained(
                 model_id,
                 subfolder="scheduler"
             )
         
-        # Versuche DPM-Solver zu verwenden (bessere Ergebnisse)
+        # Optimierungen
         try:
-            # Hole die Scheduler-Konfiguration
-            if hasattr(pipe_txt2img.scheduler, 'config'):
-                scheduler_config = pipe_txt2img.scheduler.config
-            else:
-                # Fallback-Konfiguration für Scheduler
-                scheduler_config = {
-                    "beta_start": 0.00085,
-                    "beta_end": 0.012,
-                    "beta_schedule": "scaled_linear",
-                    "num_train_timesteps": 1000,
-                    "prediction_type": "epsilon",
-                    "steps_offset": 1
-                }
-                print("⚠️ Keine Scheduler-Konfig gefunden, verwende Standard")
+            # Versuche DPM-Solver
+            scheduler_config = pipe.scheduler.config if hasattr(pipe.scheduler, 'config') else {
+                "beta_start": 0.00085,
+                "beta_end": 0.012,
+                "beta_schedule": "scaled_linear",
+                "num_train_timesteps": 1000,
+                "prediction_type": "epsilon",
+                "steps_offset": 1
+            }
             
-            # Setze DPM-Solver Scheduler
-            pipe_txt2img.scheduler = DPMSolverMultistepScheduler.from_config(
+            pipe.scheduler = DPMSolverMultistepScheduler.from_config(
                 scheduler_config,
                 use_karras_sigmas=True,
                 algorithm_type="sde-dpmsolver++"
             )
             print("✅ DPM-Solver Multistep Scheduler konfiguriert")
-            
-        except Exception as scheduler_error:
-            print(f"⚠️ Konnte DPM-Scheduler nicht setzen: {scheduler_error}")
-            print("ℹ️ Verwende Standard-Scheduler weiter")
+        except Exception:
+            print("ℹ️ Verwende Standard-Scheduler")
         
-        # Optimierungen
-        pipe_txt2img.enable_attention_slicing()
-        print("✅ Attention Slicing aktiviert")
+        pipe.enable_attention_slicing()
         
-        # VAE Slicing nur wenn VAE existiert
-        if hasattr(pipe_txt2img, 'vae') and pipe_txt2img.vae is not None:
+        if hasattr(pipe, 'vae') and pipe.vae is not None:
             try:
-                pipe_txt2img.enable_vae_slicing()
-                if hasattr(pipe_txt2img.vae, 'enable_slicing'):
-                    pipe_txt2img.vae.enable_slicing()
+                pipe.enable_vae_slicing()
                 print("✅ VAE Slicing aktiviert")
-            except Exception as vae_slice_error:
-                print(f"⚠️ VAE Slicing nicht möglich: {vae_slice_error}")
+            except Exception:
+                pass
+        
+        # In Cache speichern
+        with _model_cache_lock:
+            _model_cache[model_id] = pipe
         
-        current_pipe_model_id = model_id
-        print(f"✅ {config['name']} erfolgreich geladen")
-        print(f"📊 Modell-Dtype: {pipe_txt2img.dtype}")
-        print(f"📊 Scheduler: {type(pipe_txt2img.scheduler).__name__}")
-        print(f"⚙️ Empfohlene Einstellungen: Steps={config['recommended_steps']}, CFG={config['recommended_cfg']}")
+        print(f"✅ {config['name']} erfolgreich geladen und gecached")
         
-        return pipe_txt2img
+        return pipe
         
     except Exception as e:
-        print(f"❌ Fehler beim Laden von {model_id}: {str(e)[:200]}...")
+        print(f"❌ Fehler beim Laden von {model_id}: {str(e)[:200]}")
         import traceback
         traceback.print_exc()
-        print("🔄 Fallback auf SD 1.5...")
         
-        # Fallback auf Standard SD 1.5
+        # Fallback auf SD 1.5
         try:
-            pipe_txt2img = StableDiffusionPipeline.from_pretrained(
+            print("🔄 Fallback auf SD 1.5...")
+            pipe = StableDiffusionPipeline.from_pretrained(
                 "runwayml/stable-diffusion-v1-5",
                 torch_dtype=torch_dtype,
-                use_safetensors=True,
+                safety_checker=None,
             ).to(device)
-            pipe_txt2img.enable_attention_slicing()
-            current_pipe_model_id = "runwayml/stable-diffusion-v1-5"
-            print("✅ Fallback auf SD 1.5 erfolgreich")
+            pipe.enable_attention_slicing()
             
-            return pipe_txt2img
+            with _model_cache_lock:
+                _model_cache["runwayml/stable-diffusion-v1-5"] = pipe
+            
+            return pipe
         except Exception as fallback_error:
             print(f"❌ Auch Fallback fehlgeschlagen: {fallback_error}")
             raise
+    finally:
+        with _loading_lock:
+            _current_loading_model = None
 
-def load_img2img():
-    global pipe_img2img
-    if pipe_img2img is None:
-        print("Loading Inpainting model...")
+# === LAZY LOADING FÜR IMG2IMG ===
+_img2img_pipe = None
+_img2img_lock = threading.Lock()
+
+def get_img2img_pipe():
+    """Lazy Loading für Img2Img Pipeline mit Thread-Sicherheit"""
+    global _img2img_pipe
+    
+    if _img2img_pipe is not None:
+        return _img2img_pipe
+    
+    with _img2img_lock:
+        if _img2img_pipe is not None:  # Double-check locking
+            return _img2img_pipe
+        
+        print("🔄 Lade Inpainting-Modell...")
         try:
-            pipe_img2img = StableDiffusionInpaintPipeline.from_pretrained(
+            _img2img_pipe = StableDiffusionInpaintPipeline.from_pretrained(
                 "runwayml/stable-diffusion-inpainting",
                 torch_dtype=torch_dtype,
-                allow_pickle=False,
                 safety_checker=None,
             ).to(device)
+            
+            _img2img_pipe.enable_attention_slicing()
+            _img2img_pipe.enable_vae_tiling()
+            
+            print("✅ Inpainting-Modell geladen")
         except Exception as e:
-            print(f"Fehler beim Laden des Inpainting-Modells: {e}")
+            print(f"❌ Fehler beim Laden des Inpainting-Modells: {e}")
             raise
+    
+    return _img2img_pipe
 
-        from diffusers import DPMSolverMultistepScheduler
-        pipe_img2img.scheduler = DPMSolverMultistepScheduler.from_config(
-            pipe_img2img.scheduler.config,
-            algorithm_type="sde-dpmsolver++",
-            use_karras_sigmas=True,
-            timestep_spacing="trailing"
-        )
+# === OPTIMIERTE PIPELINE FUNKTIONEN ===
+def load_txt2img(model_id):
+    """Lädt das Text-to-Image Modell aus Cache oder neu"""
+    return load_model_with_cache(model_id)
+
+def load_img2img():
+    """Lädt Img2Img Pipeline mit Lazy Loading"""
+    return get_img2img_pipe()
+
+# === ASYNCHRONE MODELL-VORLADUNG BEI TAB-WECHSEL ===
+class ModelPreloader:
+    """Asynchrones Vorladen von Modellen bei Tab-Aktivierung"""
+    def __init__(self):
+        self.queue = Queue()
+        self.worker_thread = None
+        self.stop_flag = False
         
-        pipe_img2img.enable_attention_slicing()
-        pipe_img2img.enable_vae_tiling()
-        if hasattr(pipe_img2img, 'vae_slicing'):
-            pipe_img2img.vae_slicing = True
+    def start(self):
+        """Startet den Worker-Thread"""
+        self.worker_thread = threading.Thread(target=self._worker, daemon=True)
+        self.worker_thread.start()
+        print("✅ ModelPreloader gestartet")
+    
+    def stop(self):
+        """Stoppt den Worker-Thread"""
+        self.stop_flag = True
+        if self.worker_thread:
+            self.worker_thread.join(timeout=1.0)
+    
+    def schedule_preload(self, model_id):
+        """Plant das Vorladen eines Modells"""
+        if model_id not in _model_cache:
+            self.queue.put(model_id)
+    
+    def _worker(self):
+        """Worker-Thread für asynchrones Laden"""
+        while not self.stop_flag:
+            try:
+                model_id = self.queue.get(timeout=0.5)
+                if model_id:
+                    try:
+                        print(f"⚡ Vorlade Modell: {model_id}")
+                        load_model_with_cache(model_id)
+                    except Exception as e:
+                        print(f"⚠️ Vorladen von {model_id} fehlgeschlagen: {e}")
+            except Empty:
+                continue
+            except Exception as e:
+                print(f"⚠️ Fehler im Preloader: {e}")
 
-    return pipe_img2img
+# Preloader initialisieren
+model_preloader = ModelPreloader()
+model_preloader.start()
 
 # === NEUE CALLBACK-FUNKTIONEN FÜR FORTSCHRITT ===
 class TextToImageProgressCallback:
@@ -596,9 +650,25 @@ def update_model_settings(model_id):
     return (
         config["recommended_steps"],  # steps
         config["recommended_cfg"],    # guidance_scale
-        f"📊 Empfohlene Einstellungen: {config['steps']} Steps, CFG {config['cfg']}"
+        f"📊 Empfohlene Einstellungen: {config['recommended_steps']} Steps, CFG {config['recommended_cfg']}"
     )
 
+# === TAB-WECHSEL HANDLER ===
+def on_tab_change(tab_name):
+    """Wird aufgerufen wenn Tab gewechselt wird"""
+    print(f"📌 Tab gewechselt zu: {tab_name}")
+    
+    if tab_name == "Text zu Bild":
+        # Vorlade das aktuell ausgewählte Modell
+        model_id = "runwayml/stable-diffusion-v1-5"  # Standardmodell
+        model_preloader.schedule_preload(model_id)
+    
+    elif tab_name == "Bild zu Bild":
+        # Img2Img Modell im Hintergrund laden
+        threading.Thread(target=get_img2img_pipe, daemon=True).start()
+    
+    return tab_name
+
 def main_ui():
     with gr.Blocks(
         title="AI Image Generator", 
@@ -693,253 +763,311 @@ def main_ui():
             color: #721c24;
             border: 1px solid #f5c6cb;
         }
+        .tab-nav {
+            padding: 10px 0;
+        }
+        .tab-nav button {
+            transition: all 0.3s ease;
+        }
+        .tab-nav button:hover {
+            transform: translateY(-2px);
+        }
         """
     ) as demo:
 
-        with gr.Column(visible=True) as content_area:
-            with gr.Tab("Text zu Bild"):
-                gr.Markdown("## 🎨 Text zu Bild Generator")
-                
-                with gr.Row():
-                    with gr.Column(scale=2):
-                        # Modellauswahl Dropdown (NUR 2 MODELLE)
-                        model_dropdown = gr.Dropdown(
-                            choices=[
-                                (config["name"], model_id) 
-                                for model_id, config in MODEL_CONFIGS.items()
-                            ],
-                            value="runwayml/stable-diffusion-v1-5",
-                            label="📁 Modellauswahl",
-                            info="🏠 Universal vs 👤 Portraits"
-                        )
-                        
-                        # Modellinformationen Box
-                        model_info_box = gr.Markdown(
-                            value="<div class='model-info-box'>"
-                                  "**🏠 Stable Diffusion 1.5 (Universal)**<br>"
-                                  "Universal model, good all-rounder, reliable results<br>"
-                                  "Empfohlene Einstellungen: 35 Steps, CFG 7.5"
-                                  "</div>",
-                            label="Modellinformationen"
-                        )
-                        
-                    with gr.Column(scale=3):
-                        txt_input = gr.Textbox(
-                            placeholder="z.B. ultra realistic mountain landscape at sunrise, soft mist over the valley, detailed foliage, crisp textures, depth of field, sunlight rays through clouds, shot on medium format camera, 8k, HDR, hyper-detailed, natural lighting, masterpiece",
-                            lines=3,
-                            label="🎯 Prompt (Englisch)",
-                            info="Beschreibe detailliert, was du sehen möchtest. Negative Prompts werden automatisch generiert."
-                        )
-                
-                with gr.Row():
-                    with gr.Column():
-                        txt_steps = gr.Slider(
-                            minimum=10, maximum=100, value=35, step=1,
-                            label="⚙️ Inferenz-Schritte",
-                            info="Mehr Schritte = bessere Qualität, aber langsamer (20-50 empfohlen)"
-                        )
-                    with gr.Column():
-                        txt_guidance = gr.Slider(
-                            minimum=1.0, maximum=20.0, value=7.5, step=0.5,
-                            label="🎛️ Prompt-Stärke (CFG Scale)",
-                            info="Wie stark der Prompt befolgt wird (7-12 für gute Balance)"
-                        )
-                
-                # Status-Nachricht
-                status_output = gr.Markdown(
-                    value="",
-                    elem_classes="status-message"
-                )
-                
-                generate_btn = gr.Button("🚀 Bild generieren", variant="primary", elem_id="generate-button")
-                
-                with gr.Row():
-                    txt_output = gr.Image(
-                        label="🖼️ Generiertes Bild", 
-                        show_download_button=True,
-                        type="pil",
-                        height=400
+        # Tab-Status Tracking
+        current_tab = gr.State(value="Text zu Bild")
+        
+        with gr.Tab("Text zu Bild") as txt_tab:
+            gr.Markdown("## 🎨 Text zu Bild Generator")
+            
+            with gr.Row():
+                with gr.Column(scale=2):
+                    # Modellauswahl Dropdown (NUR 2 MODELLE)
+                    model_dropdown = gr.Dropdown(
+                        choices=[
+                            (config["name"], model_id) 
+                            for model_id, config in MODEL_CONFIGS.items()
+                        ],
+                        value="runwayml/stable-diffusion-v1-5",
+                        label="📁 Modellauswahl",
+                        info="🏠 Universal vs 👤 Portraits"
                     )
-                
-                # Event-Handler für Modelländerung
-                def update_model_info(model_id):
-                    config = MODEL_CONFIGS.get(model_id, MODEL_CONFIGS["runwayml/stable-diffusion-v1-5"])
-                    info_html = f"""
-                    <div class='model-info-box'>
-                    <strong>{config['name']}</strong><br>
-                    {config['description']}<br>
-                    <em>Empfohlene Einstellungen: {config['recommended_steps']} Steps, CFG {config['recommended_cfg']}</em>
-                    </div>
-                    """
-                    return info_html, config["recommended_steps"], config["recommended_cfg"]
-                
-                model_dropdown.change(
-                    fn=update_model_info,
-                    inputs=[model_dropdown],
-                    outputs=[model_info_box, txt_steps, txt_guidance]
-                )
-                
-                generate_btn.click(
-                    fn=text_to_image,
-                    inputs=[txt_input, model_dropdown, txt_steps, txt_guidance],
-                    outputs=[txt_output, status_output],
-                    concurrency_limit=1
+                    
+                    # Modellinformationen Box
+                    model_info_box = gr.Markdown(
+                        value="<div class='model-info-box'>"
+                              "**🏠 Stable Diffusion 1.5 (Universal)**<br>"
+                              "Universal model, good all-rounder, reliable results<br>"
+                              "Empfohlene Einstellungen: 35 Steps, CFG 7.5"
+                              "</div>",
+                        label="Modellinformationen"
+                    )
+                    
+                with gr.Column(scale=3):
+                    txt_input = gr.Textbox(
+                        placeholder="z.B. ultra realistic mountain landscape at sunrise, soft mist over the valley, detailed foliage, crisp textures, depth of field, sunlight rays through clouds, shot on medium format camera, 8k, HDR, hyper-detailed, natural lighting, masterpiece",
+                        lines=3,
+                        label="🎯 Prompt (Englisch)",
+                        info="Beschreibe detailliert, was du sehen möchtest. Negative Prompts werden automatisch generiert."
+                    )
+            
+            with gr.Row():
+                with gr.Column():
+                    txt_steps = gr.Slider(
+                        minimum=10, maximum=100, value=35, step=1,
+                        label="⚙️ Inferenz-Schritte",
+                        info="Mehr Schritte = bessere Qualität, aber langsamer (20-50 empfohlen)"
+                    )
+                with gr.Column():
+                    txt_guidance = gr.Slider(
+                        minimum=1.0, maximum=20.0, value=7.5, step=0.5,
+                        label="🎛️ Prompt-Stärke (CFG Scale)",
+                        info="Wie stark der Prompt befolgt wird (7-12 für gute Balance)"
+                    )
+            
+            # Status-Nachricht
+            status_output = gr.Markdown(
+                value="",
+                elem_classes="status-message"
+            )
+            
+            generate_btn = gr.Button("🚀 Bild generieren", variant="primary", elem_id="generate-button")
+            
+            with gr.Row():
+                txt_output = gr.Image(
+                    label="🖼️ Generiertes Bild", 
+                    show_download_button=True,
+                    type="pil",
+                    height=400
                 )
+            
+            # Event-Handler für Modelländerung mit Vorladen
+            def on_model_select(model_id):
+                # Vorlade das ausgewählte Modell im Hintergrund
+                model_preloader.schedule_preload(model_id)
+                config = MODEL_CONFIGS.get(model_id, MODEL_CONFIGS["runwayml/stable-diffusion-v1-5"])
+                info_html = f"""
+                <div class='model-info-box'>
+                <strong>{config['name']}</strong><br>
+                {config['description']}<br>
+                <em>Empfohlene Einstellungen: {config['recommended_steps']} Steps, CFG {config['recommended_cfg']}</em>
+                </div>
+                """
+                return info_html, config["recommended_steps"], config["recommended_cfg"]
+            
+            model_dropdown.change(
+                fn=on_model_select,
+                inputs=[model_dropdown],
+                outputs=[model_info_box, txt_steps, txt_guidance],
+                queue=False  # Wichtig: Keine Warteschlange für dieses Event
+            )
+            
+            generate_btn.click(
+                fn=text_to_image,
+                inputs=[txt_input, model_dropdown, txt_steps, txt_guidance],
+                outputs=[txt_output, status_output],
+                concurrency_limit=1
+            )
 
-            with gr.Tab("Bild zu Bild"):
-                gr.Markdown("## 🖼️ Bild zu Bild Transformation")
-                
-                with gr.Row():
-                    with gr.Column():
-                        img_input = gr.Image(
-                            type="pil", 
-                            label="📤 Eingabebild",
-                            height=300,
-                            sources=["upload"],
-                            elem_id="image-upload"
-                        )
-                    with gr.Column():
-                        preview_output = gr.Image(
-                            label="🎯 Live-Vorschau mit Maske",
-                            height=300,
-                            interactive=False,
-                            show_download_button=False
-                        )
-                
-                with gr.Row():
-                    face_preserve = gr.Checkbox(
-                        label="🛡️ Schutzmodus", 
-                        value=True,
-                        info="🟢 AN: Alles AUSSERHALB des gelben Rahmens verändern | 🔴 AUS: Nur INNERHALB des gelben Rahmens verändern"
-                    )
-                
-                with gr.Row():
-                    gr.Markdown("### 📐 Bildelementbereich anpassen")
-                
-                with gr.Row():
-                    with gr.Column():
-                        bbox_x1 = gr.Slider(
-                            label="← Links (x1)", 
-                            minimum=0, maximum=512, value=100, step=1,
-                            info="Linke Kante des Bildelementbereichs"
-                        )
-                    with gr.Column():
-                        bbox_y1 = gr.Slider(
-                            label="↑ Oben (y1)", 
-                            minimum=0, maximum=512, value=100, step=1,
-                            info="Obere Kante des Bildelementbereichs"
-                        )
-                with gr.Row():
-                    with gr.Column():
-                        bbox_x2 = gr.Slider(
-                            label="→ Rechts (x2)", 
-                            minimum=0, maximum=512, value=300, step=1,
-                            info="Rechte Kante des Bildelementbereichs"
-                        )
-                    with gr.Column():
-                        bbox_y2 = gr.Slider(
-                            label="↓ Unten (y2)", 
-                            minimum=0, maximum=512, value=300, step=1,
-                            info="Untere Kante des Bildelementbereichs"
-                        )
-                
-                with gr.Row():
-                    with gr.Column():
-                        img_prompt = gr.Textbox(
-                            placeholder="change background to beach with palm trees, keep person unchanged, sunny day",
-                            lines=2,
-                            label="🎯 Transformations-Prompt (Englisch)",
-                            info="Was soll verändert werden? Sei spezifisch."
-                        )
-                    with gr.Column():
-                        img_neg_prompt = gr.Textbox(
-                            placeholder="blurry, deformed, ugly, bad anatomy, extra limbs, poorly drawn hands",
-                            lines=2,
-                            label="🚫 Negativ-Prompt (Englisch)",
-                            info="Was soll vermieden werden? Unerwünschte Elemente auflisten."
-                        )
-                
-                with gr.Row():
-                    with gr.Column():
-                        strength_slider = gr.Slider(
-                            minimum=0.1, maximum=0.9, value=0.4, step=0.05,
-                            label="💪 Veränderungs-Stärke",
-                            info="0.1-0.3: Leichte Anpassungen, 0.4-0.6: Mittlere Veränderungen, 0.7-0.9: Starke Umgestaltung"
-                        )
-                    with gr.Column():
-                        img_steps = gr.Slider(
-                            minimum=10, maximum=100, value=35, step=1,
-                            label="⚙️ Inferenz-Schritte",
-                            info="Anzahl der Verarbeitungsschritte (25-45 für gute Ergebnisse)"
-                        )
-                    with gr.Column():
-                        img_guidance = gr.Slider(
-                            minimum=1.0, maximum=20.0, value=7.5, step=0.5,
-                            label="🎛️ Prompt-Stärke",
-                            info="Einfluss des Prompts auf das Ergebnis (6-10 für natürliche Ergebnisse)"
-                        )
-
-                with gr.Row():
-                   gr.Markdown(
-                     "### 📋 Hinweise:\n"
-                     "• **🆕 Automatische Bildelementerkennung** setzt Koordinaten beim Upload\n"  
-                     "• **🆕 Live-Vorschau** zeigt farbige Rahmen je nach Modus (🔴 Rot / 🟢 Grün)\n"
-                     "• **🆕 Koordinaten-Schieberegler** für präzise Anpassung mit Live-Update\n"
-                     "• **Koordinaten nur bei erkennbaren Verzerrungen anpassen** (Bereiche leicht verschieben)"
+        with gr.Tab("Bild zu Bild") as img_tab:
+            gr.Markdown("## 🖼️ Bild zu Bild Transformation")
+            
+            with gr.Row():
+                with gr.Column():
+                    img_input = gr.Image(
+                        type="pil", 
+                        label="📤 Eingabebild",
+                        height=300,
+                        sources=["upload"],
+                        elem_id="image-upload"
                     )
-                
-                transform_btn = gr.Button("🔄 Bild transformieren", variant="primary")
-                
-                with gr.Row():
-                    img_output = gr.Image(
-                        label="✨ Transformiertes Bild",
-                        show_download_button=True,
-                        type="pil",
-                        height=400
+                with gr.Column():
+                    preview_output = gr.Image(
+                        label="��� Live-Vorschau mit Maske",
+                        height=300,
+                        interactive=False,
+                        show_download_button=False
                     )
-                
-                img_input.change(
-                    fn=process_image_upload,
-                    inputs=[img_input],
-                    outputs=[preview_output, bbox_x1, bbox_y1, bbox_x2, bbox_y2]
+            
+            with gr.Row():
+                face_preserve = gr.Checkbox(
+                    label="🛡️ Schutzmodus", 
+                    value=True,
+                    info="🟢 AN: Alles AUSSERHALB des gelben Rahmens verändern | 🔴 AUS: Nur INNERHALB des gelben Rahmens verändern"
                 )
-                
-                coordinate_inputs = [img_input, bbox_x1, bbox_y1, bbox_x2, bbox_y2, face_preserve]
-                
-                for slider in [bbox_x1, bbox_y1, bbox_x2, bbox_y2]:
-                    slider.change(
-                        fn=update_live_preview,
-                        inputs=coordinate_inputs,
-                        outputs=preview_output
+            
+            with gr.Row():
+                gr.Markdown("### 📐 Bildelementbereich anpassen")
+            
+            with gr.Row():
+                with gr.Column():
+                    bbox_x1 = gr.Slider(
+                        label="← Links (x1)", 
+                        minimum=0, maximum=512, value=100, step=1,
+                        info="Linke Kante des Bildelementbereichs"
+                    )
+                with gr.Column():
+                    bbox_y1 = gr.Slider(
+                        label="↑ Oben (y1)", 
+                        minimum=0, maximum=512, value=100, step=1,
+                        info="Obere Kante des Bildelementbereichs"
+                    )
+            with gr.Row():
+                with gr.Column():
+                    bbox_x2 = gr.Slider(
+                        label="→ Rechts (x2)", 
+                        minimum=0, maximum=512, value=300, step=1,
+                        info="Rechte Kante des Bildelementbereichs"
+                    )
+                with gr.Column():
+                    bbox_y2 = gr.Slider(
+                        label="↓ Unten (y2)", 
+                        minimum=0, maximum=512, value=300, step=1,
+                        info="Untere Kante des Bildelementbereichs"
+                    )
+            
+            with gr.Row():
+                with gr.Column():
+                    img_prompt = gr.Textbox(
+                        placeholder="change background to beach with palm trees, keep person unchanged, sunny day",
+                        lines=2,
+                        label="🎯 Transformations-Prompt (Englisch)",
+                        info="Was soll verändert werden? Sei spezifisch."
                     )
-                
-                face_preserve.change(
+                with gr.Column():
+                    img_neg_prompt = gr.Textbox(
+                        placeholder="blurry, deformed, ugly, bad anatomy, extra limbs, poorly drawn hands",
+                        lines=2,
+                        label="🚫 Negativ-Prompt (Englisch)",
+                        info="Was soll vermieden werden? Unerwünschte Elemente auflisten."
+                    )
+            
+            with gr.Row():
+                with gr.Column():
+                    strength_slider = gr.Slider(
+                        minimum=0.1, maximum=0.9, value=0.4, step=0.05,
+                        label="💪 Veränderungs-Stärke",
+                        info="0.1-0.3: Leichte Anpassungen, 0.4-0.6: Mittlere Veränderungen, 0.7-0.9: Starke Umgestaltung"
+                    )
+                with gr.Column():
+                    img_steps = gr.Slider(
+                        minimum=10, maximum=100, value=35, step=1,
+                        label="⚙️ Inferenz-Schritte",
+                        info="Anzahl der Verarbeitungsschritte (25-45 für gute Ergebnisse)"
+                    )
+                with gr.Column():
+                    img_guidance = gr.Slider(
+                        minimum=1.0, maximum=20.0, value=7.5, step=0.5,
+                        label="🎛️ Prompt-Stärke",
+                        info="Einfluss des Prompts auf das Ergebnis (6-10 für natürliche Ergebnisse)"
+                    )
+
+            with gr.Row():
+               gr.Markdown(
+                 "### 📋 Hinweise:\n"
+                 "• **🆕 Automatische Bildelementerkennung** setzt Koordinaten beim Upload\n"  
+                 "• **🆕 Live-Vorschau** zeigt farbige Rahmen je nach Modus (🔴 Rot / 🟢 Grün)\n"
+                 "• **🆕 Koordinaten-Schieberegler** für präzise Anpassung mit Live-Update\n"
+                 "• **Koordinaten nur bei erkennbaren Verzerrungen anpassen** (Bereiche leicht verschieben)"
+                )
+            
+            transform_btn = gr.Button("🔄 Bild transformieren", variant="primary")
+            
+            with gr.Row():
+                img_output = gr.Image(
+                    label="✨ Transformiertes Bild",
+                    show_download_button=True,
+                    type="pil",
+                    height=400
+                )
+            
+            img_input.change(
+                fn=process_image_upload,
+                inputs=[img_input],
+                outputs=[preview_output, bbox_x1, bbox_y1, bbox_x2, bbox_y2]
+            )
+            
+            coordinate_inputs = [img_input, bbox_x1, bbox_y1, bbox_x2, bbox_y2, face_preserve]
+            
+            for slider in [bbox_x1, bbox_y1, bbox_x2, bbox_y2]:
+                slider.change(
                     fn=update_live_preview,
                     inputs=coordinate_inputs,
                     outputs=preview_output
                 )
-                
-                transform_btn.click(
-                    fn=img_to_image,
-                    inputs=[
-                        img_input, img_prompt, img_neg_prompt, 
-                        strength_slider, img_steps, img_guidance, 
-                        face_preserve, bbox_x1, bbox_y1, bbox_x2, bbox_y2
-                    ],
-                    outputs=img_output,
-                    concurrency_limit=1
-                )
+            
+            face_preserve.change(
+                fn=update_live_preview,
+                inputs=coordinate_inputs,
+                outputs=preview_output
+            )
+            
+            transform_btn.click(
+                fn=img_to_image,
+                inputs=[
+                    img_input, img_prompt, img_neg_prompt, 
+                    strength_slider, img_steps, img_guidance, 
+                    face_preserve, bbox_x1, bbox_y1, bbox_x2, bbox_y2
+                ],
+                outputs=img_output,
+                concurrency_limit=1
+            )
 
+        # Tab-Wechsel Event-Handler
+        def update_current_tab(selected_tab):
+            # Konvertiere Tab-Objekt zu Namen
+            tab_name = "Text zu Bild" if selected_tab == 0 else "Bild zu Bild"
+            on_tab_change(tab_name)
+            return tab_name
+        
+        # Event für Tab-Wechsel
+        demo.load(
+            fn=lambda: "Text zu Bild",
+            outputs=current_tab
+        )
+        
+        # Tab-Wechsel verfolgen
+        txt_tab.select(
+            fn=lambda: update_current_tab(0),
+            outputs=current_tab,
+            queue=False
+        )
+        
+        img_tab.select(
+            fn=lambda: update_current_tab(1),
+            outputs=current_tab,
+            queue=False
+        )
+        
+        # Queue mit Load-Balancing konfigurieren
+        demo.queue(
+            max_size=2,  # Reduziere max_size für besseres Load-Balancing
+            default_concurrency_limit=1,
+            api_open=False
+        )
+    
     return demo
 
 if __name__ == "__main__":
+    import atexit
+    
+    # Cleanup-Handler
+    @atexit.register
+    def cleanup():
+        model_preloader.stop()
+        torch.cuda.empty_cache() if torch.cuda.is_available() else None
+        print("🧹 Cleanup durchgeführt")
+    
     demo = main_ui()
-    demo.queue(max_size=3)
     demo.launch(
         server_name="0.0.0.0", 
         server_port=7860,
         max_file_size="10MB",
         show_error=True,
         share=False,
-        ssr_mode=False  # SSR deaktivieren für Stabilität
+        # Wichtig für T4 Optimierungen
+        enable_queue=True,
+        prevent_thread_lock=True,
+        ssl_verify=False
     )