🎯 Add HuggingFace Cloud Benchmark for SAAP Thesis

app_hf_cloud.py

@@ -0,0 +1,281 @@
+import gradio as gr
+import time
+from datetime import datetime
+from transformers import pipeline, AutoTokenizer, AutoModelForCausalLM
+import torch
+
+class HuggingFaceCloudBenchmark:
+    def __init__(self):
+        self.models_cache = {}
+        self.available_models = [
+            "microsoft/DialoGPT-small",      # 117M - Sehr schnell
+            "gpt2",                          # 124M - Standard GPT-2
+            "distilgpt2",                    # 82M - Optimiert & schnell
+            "microsoft/DialoGPT-medium",     # 345M - Mittlere Größe
+        ]
+        
+    def load_model(self, model_name):
+        """Lädt Model mit Caching für Performance"""
+        if model_name not in self.models_cache:
+            try:
+                print(f"📥 Loading {model_name}...")
+                # Optimiert für CPU-Performance
+                self.models_cache[model_name] = pipeline(
+                    "text-generation",
+                    model=model_name,
+                    tokenizer=model_name,
+                    device=-1,  # CPU statt GPU
+                    torch_dtype=torch.float32,
+                    max_length=512
+                )
+                print(f"✅ {model_name} loaded successfully")
+            except Exception as e:
+                print(f"❌ Failed to load {model_name}: {e}")
+                return None
+        
+        return self.models_cache[model_name]
+
+    def test_agent_response(self, prompt, model_name, agent_role="General"):
+        """HuggingFace Cloud Inference Test"""
+        
+        # SAAP-spezifische Prompts
+        saap_prompts = {
+            "Jane": f"Als KI-Architektin für Multi-Agent-Systeme: {prompt}",
+            "John": f"Als Softwareentwickler für AGI-Architekturen: {prompt}",
+            "Justus": f"Als Rechtsexperte für DSGVO und KI-Compliance: {prompt}",
+            "Lara": f"Als medizinische KI-Expertin: {prompt}",
+            "General": prompt
+        }
+        
+        final_prompt = saap_prompts.get(agent_role, prompt)
+        
+        # Model laden
+        generator = self.load_model(model_name)
+        if not generator:
+            return {
+                "status": f"❌ Model {model_name} konnte nicht geladen werden",
+                "time": "0.00s",
+                "environment": "☁️ HuggingFace Transformers"
+            }
+        
+        start_time = time.time()
+        
+        try:
+            # Inference mit optimierten Parametern
+            result = generator(
+                final_prompt,
+                max_new_tokens=128,         # Begrenzt für Performance
+                temperature=0.7,
+                do_sample=True,
+                top_p=0.9,
+                pad_token_id=generator.tokenizer.eos_token_id,
+                num_return_sequences=1,
+                truncation=True
+            )
+            
+            end_time = time.time()
+            response_time = end_time - start_time
+            
+            # Response extrahieren
+            generated_text = result[0]['generated_text']
+            # Original Prompt entfernen
+            response_text = generated_text.replace(final_prompt, "").strip()
+            
+            return {
+                "response": response_text,
+                "time": f"{response_time:.2f}s",
+                "model": model_name,
+                "agent_role": agent_role,
+                "tokens": len(response_text.split()),
+                "status": "✅ Success (HuggingFace Cloud)",
+                "environment": "☁️ HuggingFace Transformers",
+                "model_size": self.get_model_size(model_name)
+            }
+            
+        except Exception as e:
+            end_time = time.time()
+            return {
+                "status": f"❌ Inference Error: {str(e)[:50]}...",
+                "time": f"{end_time - start_time:.2f}s",
+                "environment": "☁️ HuggingFace Transformers"
+            }
+
+    def get_model_size(self, model_name):
+        """Model-Größe für Vergleiche"""
+        sizes = {
+            "distilgpt2": "82M Parameter",
+            "gpt2": "124M Parameter", 
+            "microsoft/DialoGPT-small": "117M Parameter",
+            "microsoft/DialoGPT-medium": "345M Parameter"
+        }
+        return sizes.get(model_name, "Unknown Size")
+
+# Global benchmark instance
+print("☁️ Initializing HuggingFace Cloud Benchmark...")
+benchmark = HuggingFaceCloudBenchmark()
+
+def run_cloud_benchmark(prompt, selected_models, agent_role):
+    """Cloud Performance Benchmark mit HuggingFace Models"""
+    if not prompt.strip():
+        return "⚠️ **Bitte Test-Prompt eingeben**"
+    
+    if not selected_models:
+        return "⚠️ **Bitte mindestens ein Model auswählen**"
+    
+    results = []
+    results.append("# ☁️ SAAP Cloud Performance Benchmark")
+    results.append("**Platform:** HuggingFace Transformers | **Environment:** Cloud GPU/CPU")
+    results.append(f"**🤖 Agent Role:** {agent_role}")
+    results.append(f"**📝 Test Prompt:** {prompt}")
+    results.append(f"**🔧 Models:** {', '.join(selected_models)}")
+    results.append(f"**⏰ Timestamp:** {datetime.now().strftime('%H:%M:%S')}")
+    results.append("---")
+    
+    total_time = 0
+    successful_tests = 0
+    
+    for model_name in selected_models:
+        result = benchmark.test_agent_response(prompt, model_name, agent_role)
+        
+        results.append(f"## ☁️ {model_name.upper()}")
+        results.append(f"**Status:** {result.get('status', '❌ Error')}")
+        results.append(f"**Response Time:** {result.get('time', 'N/A')}")
+        results.append(f"**Model Size:** {result.get('model_size', 'Unknown')}")
+        results.append(f"**Environment:** {result.get('environment', '☁️ HuggingFace')}")
+        results.append(f"**Tokens Generated:** {result.get('tokens', 0)}")
+        
+        if 'response' in result and result['response']:
+            preview = result['response'][:120].replace('\n', ' ')
+            results.append(f"**Response Preview:** {preview}...")
+        
+        results.append("---")
+        
+        # Statistics
+        if result.get('status', '').startswith('✅'):
+            successful_tests += 1
+            try:
+                time_val = float(result.get('time', '0').rstrip('s'))
+                total_time += time_val
+            except:
+                pass
+    
+    # Performance Summary
+    if successful_tests > 0:
+        avg_time = total_time / successful_tests
+        results.append(f"## 📊 Cloud Performance Summary")
+        results.append(f"**Average Response Time:** {avg_time:.2f}s")
+        results.append(f"**Successful Tests:** {successful_tests}/{len(selected_models)}")
+        results.append(f"**Infrastructure:** ☁️ HuggingFace Spaces (Shared CPU/GPU)")
+        
+        # SAAP Cloud Assessment
+        if avg_time < 3.0:
+            results.append(f"**☁️ Cloud Rating:** 🚀 Exzellent für Cloud-basierte Multi-Agent Systeme")
+        elif avg_time < 8.0:
+            results.append(f"**☁️ Cloud Rating:** ⚡ Gut für interaktive Cloud-Anwendungen")
+        elif avg_time < 15.0:
+            results.append(f"**☁️ Cloud Rating:** ⚠️ Akzeptabel für Batch Cloud-Processing")
+        else:
+            results.append(f"**☁️ Cloud Rating:** 🐌 Optimierung erforderlich")
+        
+        # Thesis Integration - Vergleich mit lokalen Daten
+        results.append(f"\n## 🆚 On-Premise vs. Cloud Comparison")
+        results.append(f"**🏠 On-Premise (CachyOS + Ollama):**")
+        results.append(f"- qwen2:1.5b: 25.94s")
+        results.append(f"- tinyllama: 17.96s")
+        results.append(f"- Hardware: Intel i7-5600U, 16GB RAM")
+        results.append(f"- Kosten: 0€ pro Request ✅")
+        results.append(f"- DSGVO: Vollständig konform ✅")
+        results.append(f"- Offline: Funktioniert ohne Internet ✅")
+        
+        results.append(f"\n**☁️ Cloud (HuggingFace):**")
+        results.append(f"- Average: {avg_time:.2f}s")
+        results.append(f"- Hardware: Shared Cloud Infrastructure")
+        results.append(f"- Kosten: API-Gebühren pro Request 💰")
+        results.append(f"- DSGVO: Abhängig von Provider ⚠️")
+        results.append(f"- Offline: Internetverbindung erforderlich ❌")
+        
+        # Fazit für Thesis
+        if avg_time < 18:
+            results.append(f"\n**🎓 Thesis-Fazit:** ☁️ Cloud hat Performance-Vorteil, aber On-Premise bietet Datenschutz und Kostenkontrolle")
+        else:
+            results.append(f"\n**🎓 Thesis-Fazit:** 🏠 On-Premise ist konkurrenzfähig und bietet zusätzlich Datenschutz-Compliance")
+    
+    return "\n".join(results)
+
+# Gradio Interface
+with gr.Blocks(title="SAAP Cloud Benchmark", theme=gr.themes.Soft()) as demo:
+    gr.Markdown("# ☁️ SAAP Cloud Performance Benchmark")
+    gr.Markdown("**Master Thesis:** Hanan Wandji Danga | **HuggingFace Transformers** | **Cloud vs. On-Premise**")
+    
+    with gr.Row():
+        with gr.Column(scale=2):
+            prompt_input = gr.Textbox(
+                label="SAAP Test Prompt",
+                placeholder="Test-Prompt für Agent Performance...",
+                lines=3,
+                value="Erkläre die Vorteile einer On-Premise Multi-Agent-Plattform gegenüber Cloud-Lösungen."
+            )
+            
+            agent_role = gr.Dropdown(
+                choices=["General", "Jane", "John", "Justus", "Lara"],
+                label="Agent Role Simulation",
+                value="Jane"
+            )
+            
+        with gr.Column(scale=1):
+            model_selection = gr.CheckboxGroup(
+                choices=benchmark.available_models,
+                label="Cloud Models to Benchmark",
+                value=["distilgpt2", "gpt2"]
+            )
+            
+            benchmark_btn = gr.Button("☁️ Run Cloud Benchmark", variant="primary", size="lg")
+    
+    # Results
+    results_output = gr.Markdown(label="Cloud Benchmark Results")
+    
+    # Event handler
+    benchmark_btn.click(
+        run_cloud_benchmark,
+        inputs=[prompt_input, model_selection, agent_role],
+        outputs=results_output
+    )
+    
+    # System Info
+    with gr.Accordion("ℹ️ Cloud vs. On-Premise Vergleich", open=False):
+        gr.Markdown("""
+        ### 🎓 SAAP Thesis Integration
+        
+        #### 🏠 On-Premise Vorteile (Ihre CachyOS Daten):
+        - **Datenschutz:** ✅ 100% DSGVO-konform, keine Datenübertragung
+        - **Kosten:** ✅ 0€ pro Request nach Initial-Setup
+        - **Kontrolle:** ✅ Volle Kontrolle über Models und Daten
+        - **Offline:** ✅ Funktioniert ohne Internetverbindung
+        - **Sicherheit:** ✅ Keine Abhängigkeit von externen Services
+        
+        #### ☁️ Cloud Vorteile (Diese HuggingFace Daten):
+        - **Performance:** ⚡ Möglicherweise schneller durch GPU-Cluster
+        - **Skalierung:** 📈 Automatische Skalierung bei Last
+        - **Wartung:** 🔧 Keine lokale Infrastruktur-Wartung
+        - **Updates:** 🚀 Automatische Model-Updates verfügbar
+        
+        #### 🎯 Für SAAP Multi-Agent Platform:
+        **On-Premise ist ideal für:**
+        - Krankenhäuser, Behörden, Finanzsektor
+        - Datenschutz-kritische Anwendungen
+        - Kostenkontrolle bei hohem Durchsatz
+        
+        **Cloud ist geeignet für:**
+        - Prototyping und Entwicklung
+        - Variable Workloads
+        - Schnelle Experimente
+        
+        ### 📊 Ihre Thesis-Daten:
+        Sammeln Sie beide Datensätze für aussagekräftige Vergleiche!
+        
+        **Lokale App:** http://127.0.0.1:7860 (CachyOS)
+        **Cloud App:** Diese HuggingFace Space
+        """)
+
+if __name__ == "__main__":
+    demo.launch()

requirements.txt

@@ -1,2 +1,5 @@
 gradio>=4.0.0
 requests>=2.31.0
+accelerate>=0.20.0
+torch>=2.0.0
+transformers>=4.30.0