Update app.py

app.py

@@ -1,174 +1,140 @@
 import gradio as gr
 import torch
-from diffusers import StableDiffusionPipeline
-from PIL import Image
-import time # Um die Generierungszeit zu messen
+from transformers import AutoModelForCausalLM, AutoTokenizer
+import os
 
-# --- Globale Konfiguration und Modellladung ---
-# 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}")
+# --- Konfiguration ---
+MODEL_ID = "deepseek-ai/DeepSeek-R1-0528-Qwen3-8B"
+HF_TOKEN = os.getenv("HF_TOKEN") # Optional: Für private Modelle oder Zugriffsbeschränkungen
 
-# Lade das Modell nur einmal beim Start der App
-# Für CPU: torch_dtype=torch.float32
-dtype = torch.float32
+# --- Lade Modell und Tokenizer (explizit auf CPU) ---
+print(f"Lade Tokenizer: {MODEL_ID}")
+# Stelle sicher, dass trust_remote_code=True gesetzt ist, da Qwen3 dies oft benötigt
+tokenizer = AutoTokenizer.from_pretrained(MODEL_ID, trust_remote_code=True, token=HF_TOKEN)
 
-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.")
+if tokenizer.pad_token is None:
+    print("pad_token nicht gesetzt, verwende eos_token als pad_token.")
+    tokenizer.pad_token = tokenizer.eos_token # Wichtig für Batched Inference oder Padding
 
-pipe = None # Initialisiere pipe als None
+print(f"Lade Modell: {MODEL_ID} auf CPU. Dies kann einige Zeit dauern...")
+# Versuche, das Modell in bfloat16 zu laden, um RAM zu sparen, wie auf dem Screenshot angedeutet.
+# Wenn die CPU bfloat16 nicht gut unterstützt, könnte float32 stabiler, aber speicherintensiver sein.
 try:
-    pipe = StableDiffusionPipeline.from_pretrained(MODEL_ID, torch_dtype=dtype)
-    pipe = pipe.to(DEVICE) # Auf CPU verschieben
-    print("Modell erfolgreich geladen!")
+    model = AutoModelForCausalLM.from_pretrained(
+        MODEL_ID,
+        torch_dtype=torch.bfloat16, # Versuche bfloat16 für geringeren RAM-Bedarf
+        device_map="cpu",           # Explizit auf CPU laden
+        trust_remote_code=True,
+        token=HF_TOKEN
+    )
 except Exception as e:
-    print(f"Fehler beim Laden des Modells: {e}")
-    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 = 20, # Reduziert für schnellere CPU-Tests, erhöhe für bessere Qualität
-    guidance_scale: float = 7.5,
-    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 "
-            "beim Start der App und starte die App ggf. neu, nachdem die Probleme behoben wurden."
+    print(f"Fehler beim Laden mit bfloat16 ({e}), versuche float32...")
+    model = AutoModelForCausalLM.from_pretrained(
+        MODEL_ID,
+        torch_dtype=torch.float32, # Fallback auf float32
+        device_map="cpu",
+        trust_remote_code=True,
+        token=HF_TOKEN
+    )
+
+model.eval() # In den Evaluationsmodus setzen (wichtig für Inferenz)
+print("Modell und Tokenizer erfolgreich geladen.")
+
+# --- Vorhersagefunktion für das ChatInterface ---
+def predict(message, history):
+    # Formatieren der History und der aktuellen Nachricht für das Modell
+    # Qwen3 verwendet ein spezifisches Chat-Template
+    messages_for_template = []
+    for user_msg, ai_msg in history:
+        messages_for_template.append({"role": "user", "content": user_msg})
+        messages_for_template.append({"role": "assistant", "content": ai_msg})
+    messages_for_template.append({"role": "user", "content": message})
+
+    try:
+        # Anwenden des Chat-Templates
+        prompt = tokenizer.apply_chat_template(
+            messages_for_template,
+            tokenize=False,
+            add_generation_prompt=True # Wichtig für viele Modelle, um die AI-Antwort zu initiieren
         )
+    except Exception as e:
+        print(f"Fehler beim Anwenden des Chat-Templates: {e}")
+        # Fallback, falls apply_chat_template Probleme macht (sollte bei Qwen3 aber gehen)
+        prompt_parts = []
+        for turn in messages_for_template:
+            prompt_parts.append(f"<|im_start|>{turn['role']}\n{turn['content']}<|im_end|>")
+        prompt = "\n".join(prompt_parts) + "\n<|im_start|>assistant\n"
 
-    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()
+    inputs = tokenizer(prompt, return_tensors="pt", padding=True, truncation=True).to("cpu")
 
-    # Seed Handling
-    generator = None
-    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}")
+    # Generierungsparameter (kannst du anpassen)
+    generation_kwargs = {
+        "max_new_tokens": 512,
+        "temperature": 0.7,
+        "top_p": 0.9,
+        "top_k": 50,
+        "do_sample": True,
+        "pad_token_id": tokenizer.eos_token_id, # Verhindert Warnungen und Probleme
+    }
 
+    print("Generiere Antwort...")
+    # Deaktiviere Gradientenberechnung für schnellere Inferenz und weniger Speicher
+    with torch.no_grad():
+        outputs = model.generate(**inputs, **generation_kwargs)
 
-    try:
-        # 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,
-                num_inference_steps=int(num_inference_steps),
-                guidance_scale=guidance_scale,
-                height=int(height),
-                width=int(width),
-                generator=generator
-            )
-        image = result.images[0]
-        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}")
-        raise gr.Error(f"Fehler bei der Bildgenerierung auf CPU: {e}")
+    # Dekodiere nur die neu generierten Tokens
+    response_ids = outputs[0][inputs.input_ids.shape[-1]:]
+    response = tokenizer.decode(response_ids, skip_special_tokens=True)
+
+    print(f"Antwort: {response}")
 
-# --- Gradio Interface Definition ---
-with gr.Blocks(theme=gr.themes.Soft()) as app:
+    # Für ChatInterface muss die Antwort als Stream (yield) oder als ganzer String zurückgegeben werden.
+    # Für CPU ist ein Stream nicht sinnvoll, da die Generierung ohnehin blockiert.
+    return response
+
+# --- Gradio UI ---
+# Verwende gr.Blocks für mehr Kontrolle über das Layout und Theme
+with gr.Blocks(theme=gr.themes.Soft(), title="DeepSeek Qwen3 8B (CPU)") as demo:
     gr.Markdown(
         """
-        # 🖼️ CPU Bildgenerator mit Stable Diffusion v1.5
-        Gib einen Text-Prompt ein, um ein Bild zu generieren.
-        **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.
+        # DeepSeek Qwen3 8B Chat (CPU)
+        Dies ist eine Demo des `deepseek-ai/DeepSeek-R1-0528-Qwen3-8B` Modells, das auf einer CPU läuft.
+        **Achtung:** Antworten können aufgrund der CPU-Inferenz **sehr langsam** sein (mehrere Minuten pro Antwort sind möglich).
+        Bitte habe Geduld.
         """
     )
-
-    with gr.Row():
-        with gr.Column(scale=2):
-            prompt_input = gr.Textbox(
-                label="Prompt",
-                placeholder="z.B. Ein fotorealistisches Bild einer Katze, die einen Hut trägt",
-                lines=3
-            )
-            negative_prompt_input = gr.Textbox(
-                label="Negativer Prompt (was vermieden werden soll)",
-                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=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=512, value=512, step=64, label="Höhe"
-                )
-                width_slider = gr.Slider(
-                    minimum=256, maximum=512, value=512, step=64, label="Breite"
-                )
-            seed_input = gr.Number(
-                label="Seed (-1 oder leer für zufällig)", value=-1, precision=0
-            )
-            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 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,
-                cache_examples=False # CPU-Generierung ist zu langsam zum Cachen während des Tests
-            )
-
-    generate_button.click(
-        fn=generate_image,
-        inputs=[
-            prompt_input,
-            negative_prompt_input,
-            steps_slider,
-            guidance_slider,
-            height_slider,
-            width_slider,
-            seed_input
+    # ChatInterface ist ideal für eine ChatGPT-ähnliche UI
+    chatbot_interface = gr.ChatInterface(
+        fn=predict,
+        chatbot=gr.Chatbot(
+            height=600,
+            label="Chat",
+            show_label=False, # Macht es cleaner
+            bubble_full_width=False # ChatGPT-ähnlichere Bubbles
+        ),
+        textbox=gr.Textbox(
+            placeholder="Stelle mir eine Frage...",
+            container=False, # Nimmt nicht die volle Breite ein
+            scale=7 # Lässt das Textfeld im Verhältnis zu Buttons wachsen
+        ),
+        # title="DeepSeek Qwen3 8B Chat (CPU)", # Titel schon im Markdown oben
+        # description="...", # Beschreibung schon im Markdown oben
+        examples=[
+            ["Hallo, wer bist du?"],
+            ["Was ist die Hauptstadt von Frankreich?"],
+            ["Schreibe ein kurzes Gedicht über KI."]
         ],
-        outputs=image_output,
-        api_name="generate_image_cpu"
+        retry_btn="Wiederholen",
+        undo_btn="Letzte entfernen",
+        clear_btn="Chat löschen",
+        # submit_btn="Senden" # Standard-Senden-Button ist okay
     )
+    gr.Markdown("Modell von [deepseek-ai](https://huggingface.co/deepseek-ai) auf Hugging Face.")
+
 
-# --- App starten ---
+# --- Starte die App ---
 if __name__ == "__main__":
-    if pipe is None:
-        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:
-        print("\nStarte Gradio App. Öffne die angezeigte URL in deinem Browser.")
-        app.launch(share=False) # share=False für lokale Nutzung
+    # Share=True ist nicht nötig, wenn es auf HF Spaces läuft
+    # In_browser=True öffnet es lokal im Browser, wenn du es lokal testest
+    demo.launch()