Update app.py

app.py

@@ -1,24 +1,83 @@
 import gradio as gr
+import torch
 from transformers import AutoTokenizer, AutoModelForCausalLM, pipeline
 import re
+import os
 
-# 1. KONFIGURATION
+# --- 1. KONFIGURATION ---
 # Ersetzen Sie dies durch den tatsächlichen Pfad oder Namen Ihres Modells auf Hugging Face
 MODEL_NAME = "CocoEntertainment/CocoAi-1PTE" 
+
+# Setzt den Datentyp auf float16 (halbe Präzision), um den Speicherbedarf beim Laden zu minimieren.
+DTYPE = torch.float16
+
 DESCRIPTION_TEXT = """
-Willkommen bei CocoAi.
-Hier kannst du auf Deutsch mir CocoAi chatten.
-CocoAi ist ein Mistral 7B Modell (finegetuned)
+# 🤖 Willkommen bei CocoAi
+
+## Ein Chatbot von CocoEntertainment
+
+Hier kannst du auf Deutsch mit **CocoAi** chatten.
+
+CocoAi ist ein **Mistral 7B** Modell, das spezifisch für Unterhaltung und kreative Inhalte feingetuned und quantisiert wurde, um eine effiziente Nutzung zu ermöglichen.
+
+### 💡 CocoAi Markdown Syntax (wie die Antworten formatiert werden)
+Das Modell antwortet unter Verwendung der folgenden speziellen Formatierungsregeln. Das Interface konvertiert diese in Standard-Markdown zur Anzeige:
+
+* **\*Text example\*** = Fett (**Bold**)
+* **\*\*Text example\*\* ** = Kursiv (*Italic*)
+* **\*\*\*Text example\*\*\* ** = Fett und Kursiv (***Bold and Italic***)
+* **#Text example** = Haupttitel (Sehr groß)
+* **/n** = Zeilenumbruch
+* **'Text example'** = Inline-Text/Code (Monospace)
+* **'''Text example'''** = Code-Block (Block Monospace)
+
 """
 
-# 2. MODELL LADEN (WICHTIG: ANPASSEN)
-# Dies ist der Teil, den Sie möglicherweise anpassen müssen, 
-# abhängig davon, wie Ihr Modell geladen wird (z.B. mit vordefiniertem Prompt-Template).
+# --- 2. HILFSFUNKTION ZUR ANPASSUNG DER SYNTAX ---
+def convert_to_gradio_markdown(text):
+    """Konvertiert die CocoAi-Markdown-Syntax in Gradio-kompatibles Standard-Markdown."""
+    
+    # 1. Code-Block ('''Text example''' -> ```Text example```)
+    # Re.DOTALL erlaubt es, über Zeilenumbrüche hinweg zu matchen
+    text = re.sub(r"'''(.*?)'''", r"```\1```", text, flags=re.DOTALL) 
+    
+    # 2. Inline Text ('Text example' -> `Text example`)
+    text = re.sub(r"'(.*?)'", r"`\1`", text) 
+
+    # 3. Fett und Kursiv (***Text example*** -> ***Text example***)
+    # Standard-Markdown wird hier beibehalten.
+    
+    # 4. Kursiv (**Text example** -> *Text example*)
+    # Wenn **Ihr** Modell **kursiv** mit **zwei** Sternen markiert (Abweichung vom Standard).
+    # Hier nehmen wir an, dass Sie die Standard-Logik von *fett* (CocoAi:*) und *kursiv* (CocoAi:**) invertieren wollen.
+    text = re.sub(r"\*\*(.*?)\*\*", r"*\1*", text)
+    
+    # 5. Fett (*Text example* -> **Text example**)
+    # Wenn **Ihr** Modell **fett** mit **einem** Stern markiert.
+    text = re.sub(r"\*(.*?)\*", r"**\1**", text)
+
+    # 6. Zeilenumbruch (/n -> \n)
+    text = text.replace("/n", "\n")
+    
+    return text
+
+# --- 3. MODELL LADEN (SPEICHEROPTIMIERT) ---
+# Führen Sie den Ladevorgang nur einmal durch
 try:
-    # Versucht, das Modell zu laden. Dies könnte fehlschlagen, wenn das Modell sehr groß ist oder 
-    # nicht auf der kostenlosen CPU-Hardware läuft.
+    print(f"--- Starte Ladevorgang für {MODEL_NAME} ---")
+    
     tokenizer = AutoTokenizer.from_pretrained(MODEL_NAME)
-    model = AutoModelForCausalLM.from_pretrained(MODEL_NAME)
+    
+    # Lädt das Modell:
+    # - device_map="auto": Essentiell, um das Modell automatisch auf den begrenzten RAM aufzuteilen.
+    # - torch_dtype=DTYPE: Erzwingt das Laden mit halber Präzision (Float16) zur Speichereinsparung.
+    model = AutoModelForCausalLM.from_pretrained(
+        MODEL_NAME,
+        torch_dtype=DTYPE,
+        device_map="auto",
+        # Falls Ihr Modell spezifische Konfigurationsdateien enthält
+        trust_remote_code=True, 
+    )
     
     # Erstellt eine Pipeline für die Textgenerierung
     coco_pipe = pipeline(
@@ -26,102 +85,77 @@ try:
         model=model,
         tokenizer=tokenizer,
         max_new_tokens=256,
-        # Weitere Parameter nach Bedarf
+        model_kwargs={"torch_dtype": DTYPE, "device_map": "auto"}
     )
     
-    print(f"Modell '{MODEL_NAME}' erfolgreich geladen.")
+    print(f"Modell '{MODEL_NAME}' erfolgreich geladen und Pipeline erstellt.")
 
 except Exception as e:
-    # Platzhalter, wenn das Laden des Modells fehlschlägt (z.B. Modell ist nicht öffentlich oder zu groß)
-    print(f"Fehler beim Laden des Modells {MODEL_NAME}: {e}. Verwende GPT-2 als Platzhalter.")
-    coco_pipe = pipeline("text-generation", model="gpt2")
-
-
-# 3. HILFSFUNKTION ZUR ANPASSUNG DER SYNTAX
-# Diese Funktion konvertiert die von Ihnen definierte Syntax in Standard-Markdown, 
-# damit Gradio sie korrekt darstellen kann.
-def convert_to_gradio_markdown(text):
-    # 1. Inline-Code/Monospace (sehr spezifische Behandlung, da es die anderen Syntaxen stören kann)
-    text = re.sub(r"'''(.*?)'''", r"`\1`", text, flags=re.DOTALL) # Code-Block (Gradio nutzt ```)
-    text = re.sub(r"'(.*?)'", r"`\1`", text) # Inline Text (Gradio nutzt `)
-    
-    # 2. Fett und Kursiv (***Text example***)
-    text = re.sub(r"\*\*\*(.*?)\*\*\*", r"***\1***", text) 
-    
-    # 3. Kursiv (**Text example**) -> Gradio/Standard Markdown nutzt *...* oder _..._ für Kursiv
-    # Hier nehmen wir an, dass **Text example** in IHRER Syntax Kursiv ist
-    text = re.sub(r"\*\*(.*?)\*\*", r"*\1*", text)
-    
-    # 4. Fett (*Text example*) -> Gradio/Standard Markdown nutzt **...** für Fett
-    # Hier nehmen wir an, dass *Text example* in IHRER Syntax Fett ist
-    text = re.sub(r"\*(.*?)\*", r"**\1**", text)
+    # DIESER BLOCK WIRD BEI SPEICHERFEHLERN AUSGELÖST
+    print(f"FATALER FEHLER beim Laden des Modells {MODEL_NAME}: {e}")
+    print("--- Verwende GPT-2 als langsamen Platzhalter ---")
     
-    # 5. Header (Wird 1:1 übernommen, da #Header Standard ist)
-    # 6. Zeilenumbruch ( /n )
-    text = text.replace("/n", "\n")
-    
-    return text
+    # Sicherstellung eines funktionierenden Platzhalters
+    coco_pipe = pipeline("text-generation", model="gpt2")
 
-# 4. CHAT-LOGIK
+# --- 4. CHAT-LOGIK ---
 def generate_response(message, chat_history):
-    # 1. Konvertiere die Historie in ein Format, das Ihr Modell versteht (optional)
-    # In diesem Beispiel verwenden wir einfach nur die aktuelle Nachricht.
-    
-    # 2. Generiere die Antwort
-    # Führen Sie hier IHR Modell aus. Die generierte Antwort sollte IHRER CocoAi-Markdown-Syntax folgen!
+    """Generiert die Antwort des Chatbots."""
     
-    # Beispiel-Antwort (Bitte ersetzen Sie dies durch die ECHTE Ausgabe Ihres Modells)
-    if "hallo" in message.lower():
-        raw_response = "*Hallo!* Ich bin CocoAi-1PT. Wie kann ich dir behilflich sein?"
-    elif "syntax" in message.lower():
-        raw_response = "Gerne erkläre ich die Formatierung! /n *Fett* mit einem Stern. **Kursiv** mit zwei Sternen. /n Ich kann auch Code wie 'print('Hello')' darstellen."
-    elif "code" in message.lower():
-        raw_response = "Hier ist ein Beispiel für einen Code-Block: '''def meine_funktion():/n    return 'Success' '''"
-    else:
-        # Führen Sie die eigentliche Modell-Pipeline aus
-        # Sie müssen das Prompt-Format Ihres Modells anpassen (z.B. ChatML, Alpaca, etc.)
-        prompt = f"User: {message}\nCocoAi:"
+    # Hier müssten Sie das Prompt-Template Ihres Mistral-Modells anwenden (z.B. ChatML, Alpaca, etc.)
+    # Dies ist ein generisches Beispiel:
+    prompt = f"### Instruction: Beantworte die folgende Frage als CocoAi und verwende die CocoAi Markdown Syntax. ###\n\nUser: {message}\n\nCocoAi:"
+
+    try:
+        # Generierung mit der Pipeline
+        model_output = coco_pipe(
+            prompt, 
+            num_return_sequences=1, 
+            do_sample=True,
+            temperature=0.7,
+            top_p=0.9
+        )
         
-        try:
-            # Beispiel für Pipeline-Ausführung
-            model_output = coco_pipe(prompt, num_return_sequences=1, do_sample=True)[0]['generated_text']
-            
-            # Entferne den eingegebenen Prompt-Teil aus der Ausgabe
-            raw_response = model_output.replace(prompt, "", 1).strip()
-            
-        except Exception as e:
-            raw_response = f"Entschuldigung, beim Generieren der Antwort ist ein Fehler aufgetreten: {e}"
-
-
-    # 3. Konvertiere die rohe Antwort in Gradio-kompatibles Markdown
+        # Extrahieren des Texts und Entfernen des Prompts
+        raw_response = model_output[0]['generated_text']
+        
+        # WICHTIG: Nur der Teil nach "CocoAi:" ist die eigentliche Antwort
+        if "CocoAi:" in raw_response:
+            raw_response = raw_response.split("CocoAi:", 1)[-1].strip()
+        
+    except Exception as e:
+        raw_response = f"Entschuldigung, beim Generieren der Antwort ist ein technischer Fehler aufgetreten: /n'Fehler: {e}'"
+
+
+    # 2. Konvertiere die rohe Antwort in Gradio-kompatibles Markdown
     formatted_response = convert_to_gradio_markdown(raw_response)
 
-    # 4. Füge die Nachricht zur Historie hinzu
+    # 3. Füge die Nachricht zur Historie hinzu
     chat_history.append((message, formatted_response))
     return chat_history, ""
 
-# 5. GRADIO OBERFLÄCHE
+# --- 5. GRADIO OBERFLÄCHE ---
+
 # Der Tab für die Beschreibung
 description_tab = gr.Markdown(DESCRIPTION_TEXT)
 
 # Der Tab für den Chat
 with gr.Blocks() as chat_tab:
-    gr.Markdown("# 💬 Chat mit CocoAi-1PT")
+    gr.Markdown(f"# 💬 Chat mit CocoAi ({MODEL_NAME})")
     
-    # Die Haupt-Chat-Komponente von Gradio
     chatbot = gr.Chatbot(
         label="CocoAi Chat",
         height=500,
+        # Wenn Sie die Syntax-Regeln im Chat sehen wollen, lassen Sie die Markdown-Verarbeitung zu:
+        render_markdown=True 
     )
     
-    # Das Eingabefeld
     msg = gr.Textbox(
         show_label=False, 
         placeholder="Geben Sie Ihre Nachricht hier ein...", 
         lines=1
     )
     
-    # Buttons
     with gr.Row():
         submit_btn = gr.Button("Senden", variant="primary", scale=2)
         clear_btn = gr.Button("Chat leeren", scale=1)