added gpt2 fallback

app.py

@@ -1,36 +1,57 @@
 import streamlit as st
-from transformers import AutoModelForCausalLM, AutoTokenizer
+from transformers import pipeline, AutoModelForCausalLM, AutoTokenizer
 import torch
 
-st.title("🚀 Marketing Text Generator mit Falcon")
-st.markdown("*Generiere kreative Marketing-Texte mit dem Falcon-7B Modell*")
+st.title("🚀 Marketing Text Generator mit KI")
+st.markdown("*Generiere kreative Marketing-Texte für deine Produkte*")
 
 @st.cache_resource
-def load_falcon_model():
+def load_model():
     """
-    Lädt das Falcon Modell in einer CPU-freundlichen Konfiguration.
-    Diese Version verwendet weniger Speicher und läuft auf allen Systemen.
+    Versucht zuerst das Falcon-Modell zu laden. Falls dies nicht möglich ist,
+    wird automatisch auf das kleinere GPT-2 Modell zurückgegriffen.
     """
     try:
-        model_name = "tiiuae/falcon-7b"
-        
-        # Tokenizer bleibt unverändert
-        tokenizer = AutoTokenizer.from_pretrained(model_name)
-        
-        # Angepasste Modellkonfiguration für CPU-Systeme
+        # Erster Versuch: Optimiertes Falcon
+        tokenizer = AutoTokenizer.from_pretrained("tiiuae/falcon-7b")
         model = AutoModelForCausalLM.from_pretrained(
-            model_name,
+            "tiiuae/falcon-7b",
             trust_remote_code=True,
             device_map="auto",
-            torch_dtype=torch.float32,  # Standard-Datentyp statt 8-bit
-            low_cpu_mem_usage=True      # Speicheroptimierung für CPU
+            torch_dtype=torch.float32,
+            low_cpu_mem_usage=True,
+            max_memory={0: "4GB"}  # Begrenzt den Speicherverbrauch
         )
-        
-        return model, tokenizer
-    
+        return ("falcon", model, tokenizer)
+    except Exception as e:
+        st.warning("Falcon konnte nicht geladen werden. Verwende GPT-2 als Alternative.")
+        # Fallback: GPT-2
+        generator = pipeline('text-generation', model='gpt2', device=-1)
+        return ("gpt2", generator, None)
+
+def generate_text(model_type, model, tokenizer, prompt, max_length):
+    """
+    Generiert Text abhängig vom geladenen Modelltyp.
+    """
+    try:
+        if model_type == "gpt2":
+            response = model(prompt, max_length=max_length, num_return_sequences=1)
+            return response[0]['generated_text']
+        else:
+            inputs = tokenizer(prompt, return_tensors="pt").to(model.device)
+            with torch.no_grad():
+                outputs = model.generate(
+                    **inputs,
+                    max_length=max_length,
+                    temperature=0.7,
+                    top_p=0.9,
+                    num_return_sequences=1,
+                    pad_token_id=tokenizer.eos_token_id
+                )
+            return tokenizer.decode(outputs[0], skip_special_tokens=True)
     except Exception as e:
-        st.error(f"Fehler beim Laden des Modells: {str(e)}")
-        return None, None
+        st.error(f"Fehler bei der Textgenerierung: {str(e)}")
+        return None
 
 # Hauptbereich für die Eingabe
 with st.form("marketing_form"):
@@ -41,48 +62,34 @@ with st.form("marketing_form"):
     
     key_features = st.text_area(
         "Produktmerkmale",
-        help="Beschreiben Sie die wichtigsten Eigenschaften (durch Kommas getrennt)"
+        help="Beschreiben Sie die wichtigsten Eigenschaften"
     )
     
-    # Zusätzliche Kontrolle über die Textlänge
     max_length = st.slider(
         "Maximale Textlänge",
         min_value=50,
         max_value=200,
-        value=100,
-        help="Längere Texte benötigen mehr Verarbeitungszeit"
+        value=100
     )
     
     submit = st.form_submit_button("Marketing-Text generieren")
 
 if submit and product_name and key_features:
-    with st.spinner("Lade Falcon Modell... (Dies kann einige Minuten dauern)"):
-        model, tokenizer = load_falcon_model()
+    with st.spinner("Lade KI-Modell..."):
+        model_type, model, tokenizer = load_model()
     
-    if model and tokenizer:
-        prompt = f"""
-        Erstelle einen kurzen, überzeugenden Marketing-Text für folgendes Produkt:
-        Produkt: {product_name}
-        Merkmale: {key_features}
-        
-        Der Text sollte professionell und ansprechend sein.
-        """
+    prompt = f"""
+    Erstelle einen überzeugenden Marketing-Text auf Deutsch für folgendes Produkt:
+    Produkt: {product_name}
+    Merkmale: {key_features}
+    
+    Der Text sollte professionell, kreativ und verkaufsfördernd sein.
+    """
+    
+    with st.spinner("Generiere Marketing-Text..."):
+        generated_text = generate_text(model_type, model, tokenizer, prompt, max_length)
         
-        with st.spinner("Generiere Marketing-Text..."):
-            inputs = tokenizer(prompt, return_tensors="pt").to(model.device)
-            
-            with torch.no_grad():
-                outputs = model.generate(
-                    **inputs,
-                    max_length=max_length,    
-                    temperature=0.7,        
-                    top_p=0.9,             
-                    num_return_sequences=1,
-                    pad_token_id=tokenizer.eos_token_id  # Verbesserte Token-Handhabung
-                )
-            
-            generated_text = tokenizer.decode(outputs[0], skip_special_tokens=True)
-            
+        if generated_text:
             st.success("Text wurde erfolgreich generiert!")
             st.markdown("### Ihr Marketing-Text:")
             st.markdown(generated_text)
@@ -92,13 +99,14 @@ if submit and product_name and key_features:
                 generated_text,
                 file_name="marketing_text.txt"
             )
+
 elif submit:
     st.warning("Bitte füllen Sie alle Felder aus.")
 
 st.markdown("---")
 st.markdown("""
 **Wichtige Hinweise:**
-- Die erste Generierung dauert länger, da das Modell geladen werden muss
-- Auf Systemen ohne GPU kann die Verarbeitung mehrere Minuten in Anspruch nehmen
+- Die erste Generierung dauert länger (Modell-Ladezeit)
+- Bei Speicherproblemen wird automatisch ein kleineres Modell verwendet
 - Kürzere Texte werden schneller generiert
 """)

app_model_picker.py

@@ -1,157 +0,0 @@
-import streamlit as st
-from transformers import AutoModelForCausalLM, AutoTokenizer, pipeline
-import torch
-
-# Titel der Anwendung mit erklärender Unterzeile
-st.title("🤖 Marketing Text Generator")
-st.markdown("*Ein KI-Tool für kreative Marketing-Texte mit verschiedenen Sprachmodellen*")
-
-# Konfiguration der verfügbaren Modelle
-MODELS = {
-    "GPT-2 (schnell & ressourcensparend)": "gpt2",
-    "Mistral-7B (ausgewogen)": "mistralai/Mistral-7B-v0.1",
-    "LLAMA-2 (leistungsstark)": "meta-llama/Llama-2-7b-hf",
-    "Falcon (kreativ)": "tiiuae/falcon-7b"
-}
-
-@st.cache_resource
-def load_model(model_name):
-    """
-    Lädt das ausgewählte Modell und den zugehörigen Tokenizer.
-    Verwendet Caching für bessere Performance.
-    """
-    try:
-        if model_name == "gpt2":
-            # GPT-2 ist einfacher zu laden und benötigt weniger Ressourcen
-            return pipeline('text-generation', model=model_name, device=-1)
-        else:
-            # Fortgeschrittene Modelle benötigen spezielle Konfiguration
-            tokenizer = AutoTokenizer.from_pretrained(model_name)
-            model = AutoModelForCausalLM.from_pretrained(
-                model_name,
-                device_map="auto",
-                trust_remote_code=True,
-                load_in_8bit=True  # Speicheroptimierung
-            )
-            return (model, tokenizer)
-    except Exception as e:
-        st.error(f"Fehler beim Laden des Modells: {str(e)}")
-        return None
-
-def generate_text(model_name, prompt, max_length=200):
-    """
-    Generiert Text basierend auf dem ausgewählten Modell und Prompt.
-    Behandelt verschiedene Modelltypen unterschiedlich.
-    """
-    try:
-        if model_name == "gpt2":
-            generator = load_model(model_name)
-            response = generator(prompt, max_length=max_length, num_return_sequences=1)
-            return response[0]['generated_text']
-        else:
-            model, tokenizer = load_model(model_name)
-            inputs = tokenizer(prompt, return_tensors="pt").to(model.device)
-            
-            with torch.no_grad():
-                outputs = model.generate(
-                    **inputs,
-                    max_length=max_length,
-                    num_return_sequences=1,
-                    temperature=0.7,  # Kreativität kontrollieren
-                    top_p=0.9        # Vielfalt der Ausgabe steuern
-                )
-            
-            return tokenizer.decode(outputs[0], skip_special_tokens=True)
-    except Exception as e:
-        st.error(f"Fehler bei der Textgenerierung: {str(e)}")
-        return None
-
-def main():
-    # Seitenleiste für Modellauswahl und Erklärungen
-    with st.sidebar:
-        st.header("Modell-Einstellungen")
-        selected_model = st.selectbox(
-            "Wählen Sie ein Sprachmodell:",
-            list(MODELS.keys()),
-            help="Verschiedene Modelle haben unterschiedliche Stärken und Performance-Eigenschaften"
-        )
-        
-        st.markdown("---")
-        st.markdown("""
-        **Modell-Informationen:**
-        - GPT-2: Schnell, aber basic
-        - Mistral: Guter Allrounder
-        - LLAMA-2: Sehr leistungsfähig
-        - Falcon: Besonders kreativ
-        """)
-
-    # Hauptbereich für Eingabe und Generierung
-    with st.form("text_generation_form"):
-        # Strukturierte Eingabefelder
-        col1, col2 = st.columns(2)
-        with col1:
-            product_name = st.text_input(
-                "Produktname",
-                help="Name des Produkts, für das Text generiert werden soll"
-            )
-        with col2:
-            target_audience = st.text_input(
-                "Zielgruppe",
-                help="Beschreiben Sie Ihre Zielgruppe"
-            )
-        
-        key_features = st.text_area(
-            "Hauptmerkmale",
-            help="Listen Sie die wichtigsten Eigenschaften des Produkts auf (durch Kommas getrennt)"
-        )
-        
-        tone_options = ["Professionell", "Casual", "Luxuriös", "Jugendlich", "Technisch"]
-        tone = st.select_slider(
-            "Tonalität",
-            options=tone_options,
-            value="Professionell"
-        )
-        
-        submit_button = st.form_submit_button("Text generieren")
-
-    if submit_button:
-        if not product_name or not key_features:
-            st.warning("Bitte füllen Sie mindestens Produktname und Hauptmerkmale aus.")
-            return
-
-        # Fortschrittsanzeige
-        with st.spinner(f'Generiere Text mit {selected_model.split(" ")[0]}...'):
-            # Marketing-spezifischer Prompt
-            prompt = f"""
-            Erstelle einen überzeugenden Marketing-Text mit folgendem Kontext:
-            Produkt: {product_name}
-            Zielgruppe: {target_audience}
-            Hauptmerkmale: {key_features}
-            Tonalität: {tone}
-            
-            Der Text sollte die USPs hervorheben und die Zielgruppe direkt ansprechen.
-            """
-            
-            # Modellname aus dem Dictionary abrufen
-            model_name = MODELS[selected_model]
-            response = generate_text(model_name, prompt)
-            
-            if response:
-                st.success("Text wurde generiert!")
-                st.markdown("### Generierter Marketing-Text:")
-                st.markdown(response)
-                
-                # Zusätzliche Aktionen anbieten
-                col1, col2 = st.columns(2)
-                with col1:
-                    if st.button("Text kopieren"):
-                        st.text_area("Kopieren Sie den Text:", value=response)
-                with col2:
-                    st.download_button(
-                        "Als TXT herunterladen",
-                        response,
-                        file_name="marketing_text.txt"
-                    )
-
-if __name__ == "__main__":
-    main()

requirements.txt

@@ -1,4 +1,5 @@
 streamlit
 transformers
 torch
-accelerate
+accelerate
+protobuf