Update app.py

app.py

@@ -2,59 +2,75 @@ import gradio as gr
 import torch
 from diffusers import StableDiffusionPipeline
 from PIL import Image
+import time # Um die Generierungszeit zu messen
 
 # --- Globale Konfiguration und Modellladung ---
-MODEL_ID = "runwayml/stable-diffusion-v1-5"
-DEVICE = "cuda" if torch.cuda.is_available() else "cpu"
+# Verwende das Modell aus deinem Textausschnitt
+MODEL_ID = "sd-legacy/stable-diffusion-v1-5"
+DEVICE = "cpu" # Explizit CPU verwenden
 print(f"Verwende Gerät: {DEVICE}")
 
 # Lade das Modell nur einmal beim Start der App
-# Für GPU: torch_dtype=torch.float16 spart VRAM und ist schneller
-# Für CPU: torch_dtype=torch.float32 (float16 wird auf CPU nicht gut unterstützt)
-dtype = torch.float16 if DEVICE == "cuda" else torch.float32
+# Für CPU: torch_dtype=torch.float32
+dtype = torch.float32
 
-print(f"Lade Modell '{MODEL_ID}'... Dies kann einige Minuten dauern.")
+print(f"Lade Modell '{MODEL_ID}' für CPU-Nutzung... Dies kann einige Minuten dauern und benötigt viel RAM.")
+print("Stelle sicher, dass du eine stabile Internetverbindung hast.")
+
+pipe = None # Initialisiere pipe als None
 try:
     pipe = StableDiffusionPipeline.from_pretrained(MODEL_ID, torch_dtype=dtype)
-    pipe = pipe.to(DEVICE)
+    pipe = pipe.to(DEVICE) # Auf CPU verschieben
     print("Modell erfolgreich geladen!")
 except Exception as e:
     print(f"Fehler beim Laden des Modells: {e}")
-    print("Stelle sicher, dass du eine Internetverbindung hast und der Modellname korrekt ist.")
-    print("Wenn du wenig VRAM hast, versuche ein kleineres Modell oder Einstellungen zur Speicheroptimierung.")
-    pipe = None # Signalisiert, dass das Modell nicht geladen werden konnte
+    print("Mögliche Ursachen:")
+    print("- Keine Internetverbindung oder Hugging Face Hub nicht erreichbar.")
+    print("- Nicht genügend RAM verfügbar. Versuche, andere speicherintensive Anwendungen zu schließen.")
+    print("- Falsche Modell-ID (sollte hier aber korrekt sein).")
+    # pipe bleibt None, was in generate_image abgefangen wird
 
 # --- Bildgenerierungsfunktion ---
 def generate_image(
     prompt: str,
     negative_prompt: str = "",
-    num_inference_steps: int = 50,
+    num_inference_steps: int = 20, # Reduziert für schnellere CPU-Tests, erhöhe für bessere Qualität
     guidance_scale: float = 7.5,
-    height: int = 512,
-    width: int = 512,
+    height: int = 512, # Standardauflösung für SD v1.5
+    width: int = 512,  # Standardauflösung für SD v1.5
     seed: int = -1 # -1 für zufälligen Seed
 ) -> Image.Image:
     """
     Generiert ein Bild basierend auf dem Prompt und anderen Parametern.
     """
     if pipe is None:
-        raise gr.Error("Modell konnte nicht geladen werden. Bitte überprüfe die Konsolenausgabe.")
+        raise gr.Error(
+            "Modell konnte nicht geladen werden. Bitte überprüfe die Konsolenausgabe "
+            "beim Start der App und starte die App ggf. neu, nachdem die Probleme behoben wurden."
+        )
 
-    print(f"Generiere Bild für Prompt: '{prompt}'")
+    print(f"\nStarte Bildgenerierung auf CPU für Prompt: '{prompt}'")
     print(f"  Negative Prompt: '{negative_prompt}'")
     print(f"  Schritte: {num_inference_steps}, Guidance: {guidance_scale}")
     print(f"  Dimensionen: {width}x{height}, Seed: {seed}")
+    print("  Dies kann auf der CPU einige Minuten dauern...")
+
+    start_time = time.time()
 
     # Seed Handling
     generator = None
-    if seed != -1:
-        generator = torch.Generator(device=DEVICE).manual_seed(seed)
+    if seed != -1 and seed is not None: # Stelle sicher, dass seed nicht None ist
+        generator = torch.Generator(device=DEVICE).manual_seed(int(seed))
+    else: # Zufälliger Seed
+        # Generiere einen zufälligen Seed, um ihn später ggf. anzuzeigen oder zu verwenden
+        current_seed = torch.seed()
+        generator = torch.Generator(device=DEVICE).manual_seed(current_seed)
+        print(f"  Verwende zufälligen Seed: {current_seed}")
+
 
-    # Bild generieren
-    # safety_checker=None kann verwendet werden, um den NSFW-Filter zu deaktivieren,
-    # sei dir aber der Implikationen bewusst. Standardmäßig ist er aktiv.
     try:
-        with torch.inference_mode(): # Wichtig für geringeren Speicherverbrauch bei Inferenz
+        # torch.inference_mode() ist gut für geringeren Speicherverbrauch und Geschwindigkeit
+        with torch.inference_mode():
             result = pipe(
                 prompt,
                 negative_prompt=negative_prompt if negative_prompt else None,
@@ -65,26 +81,22 @@ def generate_image(
                 generator=generator
             )
         image = result.images[0]
-        print("Bild erfolgreich generiert.")
+        end_time = time.time()
+        duration = end_time - start_time
+        print(f"Bild erfolgreich generiert in {duration:.2f} Sekunden.")
         return image
     except Exception as e:
         print(f"Fehler bei der Bildgenerierung: {e}")
-        # Versuche, eine spezifischere Fehlermeldung für OOM-Fehler (Out Of Memory) zu geben
-        if "CUDA out of memory" in str(e):
-            raise gr.Error(
-                "CUDA out of memory. Versuche, die Bildgröße zu verringern, "
-                "weniger Inferenzschritte zu verwenden oder ein kleineres Modell zu laden."
-            )
-        raise gr.Error(f"Fehler bei der Bildgenerierung: {e}")
-
+        raise gr.Error(f"Fehler bei der Bildgenerierung auf CPU: {e}")
 
 # --- Gradio Interface Definition ---
 with gr.Blocks(theme=gr.themes.Soft()) as app:
     gr.Markdown(
         """
-        # 🖼️ Bildgenerator mit Stable Diffusion
+        # 🖼️ CPU Bildgenerator mit Stable Diffusion v1.5
         Gib einen Text-Prompt ein, um ein Bild zu generieren.
-        Das Laden des Modells beim ersten Start kann einige Minuten dauern.
+        **Achtung:** Die Generierung auf der **CPU ist langsam** und kann mehrere Minuten pro Bild dauern!
+        Das Laden des Modells beim ersten Start benötigt ebenfalls Zeit und RAM.
         """
     )
 
@@ -97,42 +109,44 @@ with gr.Blocks(theme=gr.themes.Soft()) as app:
             )
             negative_prompt_input = gr.Textbox(
                 label="Negativer Prompt (was vermieden werden soll)",
-                placeholder="z.B. schlecht gezeichnet, unscharf, Text, Wasserzeichen",
+                placeholder="z.B. schlecht gezeichnet, unscharf, Text, Wasserzeichen, mutierte Hände",
                 lines=2
             )
             with gr.Row():
+                # Reduzierte Standard-Schritte für CPU, da es sonst zu lange dauert
                 steps_slider = gr.Slider(
-                    minimum=10, maximum=150, value=50, step=1, label="Inferenzschritte"
+                    minimum=5, maximum=50, value=20, step=1,
+                    label="Inferenzschritte (weniger = schneller, aber ggf. schlechtere Qualität)"
                 )
                 guidance_slider = gr.Slider(
                     minimum=1, maximum=20, value=7.5, step=0.1, label="Guidance Scale (CFG)"
                 )
             with gr.Row():
+                # Standardauflösung für v1.5 ist 512x512. Kleinere Auflösungen sind schneller auf CPU.
                 height_slider = gr.Slider(
-                    minimum=256, maximum=1024, value=512, step=64, label="Höhe"
+                    minimum=256, maximum=512, value=512, step=64, label="Höhe"
                 )
                 width_slider = gr.Slider(
-                    minimum=256, maximum=1024, value=512, step=64, label="Breite"
+                    minimum=256, maximum=512, value=512, step=64, label="Breite"
                 )
             seed_input = gr.Number(
-                label="Seed (-1 für zufällig)", value=-1, precision=0
+                label="Seed (-1 oder leer für zufällig)", value=-1, precision=0
             )
-            generate_button = gr.Button("Bild generieren", variant="primary")
+            generate_button = gr.Button("Bild generieren (langsam auf CPU!)", variant="primary")
 
         with gr.Column(scale=1):
             image_output = gr.Image(label="Generiertes Bild", type="pil")
             gr.Markdown("### Beispiel-Prompts:")
             gr.Examples(
                 examples=[
-                    ["Ein Astronaut reitet ein Pferd auf dem Mond, digitale Kunst", "", 50, 7.5, 512, 512, -1],
-                    ["Ein impressionistisches Gemälde eines Sonnenuntergangs über einem Lavendelfeld", "Menschen, Gebäude", 40, 8.0, 512, 768, -1],
-                    ["Ein niedlicher Corgi-Hund als Pixel-Art-Charakter", "fotorealistisch", 30, 7.0, 512, 512, 12345],
-                    ["Eine surreale Landschaft mit schwebenden Inseln und Wasserfällen aus Licht", "dunkel, düster", 60, 9.0, 768, 512, -1],
+                    ["Ein Astronaut reitet ein Pferd auf dem Mars, digitale Kunst", "", 20, 7.5, 512, 512, -1],
+                    ["Ein impressionistisches Gemälde eines Sonnenuntergangs über einem Lavendelfeld", "Menschen, Gebäude", 15, 8.0, 512, 512, -1],
+                    ["Ein niedlicher Corgi-Hund als Pixel-Art-Charakter", "fotorealistisch", 25, 7.0, 512, 512, 12345],
                 ],
                 inputs=[prompt_input, negative_prompt_input, steps_slider, guidance_slider, height_slider, width_slider, seed_input],
                 outputs=image_output,
-                fn=generate_image, # Die Funktion, die bei Klick auf ein Beispiel ausgeführt wird
-                cache_examples=False # Oder True, wenn du die Ergebnisse cachen willst
+                fn=generate_image,
+                cache_examples=False # CPU-Generierung ist zu langsam zum Cachen während des Tests
             )
 
     generate_button.click(
@@ -147,13 +161,14 @@ with gr.Blocks(theme=gr.themes.Soft()) as app:
             seed_input
         ],
         outputs=image_output,
-        api_name="generate_image" # Für API-Zugriff
+        api_name="generate_image_cpu"
     )
 
 # --- App starten ---
 if __name__ == "__main__":
     if pipe is None:
-        print("Das Modell konnte nicht geladen werden. Die Gradio-App wird nicht gestartet.")
-        print("Bitte behebe die Fehler und versuche es erneut.")
+        print("\nDas Modell konnte nicht geladen werden. Die Gradio-App wird nicht gestartet.")
+        print("Bitte behebe die in der Konsole angezeigten Fehler und versuche es erneut.")
     else:
-        app.launch(share=False) # Setze share=True, um einen öffentlichen Link zu erhalten (erfordert `gradio-client`)
+        print("\nStarte Gradio App. Öffne die angezeigte URL in deinem Browser.")
+        app.launch(share=False) # share=False für lokale Nutzung