adaptation for huggingface.

app.py

@@ -1,85 +1,67 @@
 import gradio as gr
+import requests
 import time
+import os
 from datetime import datetime
-from transformers import pipeline, AutoTokenizer, AutoModelForCausalLM
-import torch
+from huggingface_hub import InferenceClient
 
-class HuggingFaceCloudBenchmark:
+class HuggingFaceInferenceBenchmark:
     def __init__(self):
-        self.models_cache = {}
+        # HuggingFace Inference API Client
+        self.client = InferenceClient()
+        
+        # Verfügbare Models über Inference API
         self.available_models = [
             "microsoft/DialoGPT-small",      # 117M - Sehr schnell
-            "gpt2",                          # 124M - Standard GPT-2
-            "distilgpt2",                    # 82M - Optimiert & schnell
+            "gpt2",                          # 124M - Standard GPT-2  
+            "distilgpt2",                    # 82M - Optimiert
             "microsoft/DialoGPT-medium",     # 345M - Mittlere Größe
+            "google/flan-t5-small",          # 80M - Instruction-tuned
+            "google/flan-t5-base",           # 250M - Bessere Performance
         ]
         
-    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]
+        # Model-Informationen für bessere Vergleiche
+        self.model_info = {
+            "distilgpt2": {"size": "82M", "type": "GPT-2 optimiert", "speed": "Sehr schnell"},
+            "gpt2": {"size": "124M", "type": "GPT-2 Standard", "speed": "Schnell"},
+            "microsoft/DialoGPT-small": {"size": "117M", "type": "Dialog-optimiert", "speed": "Schnell"},
+            "microsoft/DialoGPT-medium": {"size": "345M", "type": "Dialog-optimiert", "speed": "Mittel"},
+            "google/flan-t5-small": {"size": "80M", "type": "Instruction-tuned", "speed": "Sehr schnell"},
+            "google/flan-t5-base": {"size": "250M", "type": "Instruction-tuned", "speed": "Mittel"},
+        }
 
     def test_agent_response(self, prompt, model_name, agent_role="General"):
-        """HuggingFace Cloud Inference Test"""
+        """HuggingFace Inference API 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
+            "Jane": f"Als KI-Architektin für Multi-Agent-Systeme: {prompt}\n\nAntwort:",
+            "John": f"Als Softwareentwickler für AGI-Architekturen: {prompt}\n\nAntwort:",
+            "Justus": f"Als Rechtsexperte für DSGVO und KI-Compliance: {prompt}\n\nAntwort:",
+            "Lara": f"Als medizinische KI-Expertin: {prompt}\n\nAntwort:",
+            "General": f"{prompt}\n\nAntwort:"
         }
         
         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
+            # HuggingFace Inference API Call
+            response = self.client.text_generation(
+                prompt=final_prompt,
+                model=model_name,
+                max_new_tokens=150,          # Optimiert für Vergleichbarkeit
                 temperature=0.7,
-                do_sample=True,
                 top_p=0.9,
-                pad_token_id=generator.tokenizer.eos_token_id,
-                num_return_sequences=1,
-                truncation=True
+                do_sample=True,
+                return_full_text=False,      # Nur neue Tokens zurückgeben
             )
             
             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()
+            # Response bereinigen
+            response_text = response.strip() if isinstance(response, str) else str(response).strip()
             
             return {
                 "response": response_text,
@@ -87,35 +69,28 @@ class HuggingFaceCloudBenchmark:
                 "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)
+                "status": "✅ Success (HuggingFace Inference API)",
+                "environment": "☁️ HuggingFace Cloud Inference",
+                "model_info": self.model_info.get(model_name, {"size": "Unknown", "type": "Unknown", "speed": "Unknown"})
             }
             
         except Exception as e:
             end_time = time.time()
+            response_time = end_time - start_time
+            
             return {
-                "status": f"❌ Inference Error: {str(e)[:50]}...",
-                "time": f"{end_time - start_time:.2f}s",
-                "environment": "☁️ HuggingFace Transformers"
+                "status": f"❌ API Error: {str(e)[:60]}...",
+                "time": f"{response_time:.2f}s",
+                "environment": "☁️ HuggingFace Cloud Inference",
+                "error_details": str(e) if len(str(e)) < 200 else str(e)[:200] + "..."
             }
 
-    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()
+print("☁️ Initializing HuggingFace Inference API Benchmark...")
+benchmark = HuggingFaceInferenceBenchmark()
 
 def run_cloud_benchmark(prompt, selected_models, agent_role):
-    """Cloud Performance Benchmark mit HuggingFace Models"""
+    """Cloud Performance Benchmark mit HuggingFace Inference API"""
     if not prompt.strip():
         return "⚠️ **Bitte Test-Prompt eingeben**"
     
@@ -124,7 +99,7 @@ def run_cloud_benchmark(prompt, selected_models, agent_role):
     
     results = []
     results.append("# ☁️ SAAP Cloud Performance Benchmark")
-    results.append("**Platform:** HuggingFace Transformers | **Environment:** Cloud GPU/CPU")
+    results.append("**Platform:** HuggingFace Inference API | **Environment:** Cloud GPU Cluster")
     results.append(f"**🤖 Agent Role:** {agent_role}")
     results.append(f"**📝 Test Prompt:** {prompt}")
     results.append(f"**🔧 Models:** {', '.join(selected_models)}")
@@ -137,16 +112,23 @@ def run_cloud_benchmark(prompt, selected_models, agent_role):
     for model_name in selected_models:
         result = benchmark.test_agent_response(prompt, model_name, agent_role)
         
+        model_info = result.get('model_info', {})
+        
         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"**Model Size:** {model_info.get('size', 'Unknown')}")
+        results.append(f"**Model Type:** {model_info.get('type', 'Unknown')}")
+        results.append(f"**Expected Speed:** {model_info.get('speed', '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}...")
+            
+        if 'error_details' in result:
+            results.append(f"**Debug Info:** {result['error_details']}")
         
         results.append("---")
         
@@ -165,53 +147,81 @@ def run_cloud_benchmark(prompt, selected_models, agent_role):
         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)")
+        results.append(f"**Infrastructure:** ☁️ HuggingFace Inference API (Managed GPU Cluster)")
         
         # 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")
+        if avg_time < 2.0:
+            results.append(f"**☁️ Cloud Rating:** 🚀 Exzellent - Übertrifft lokale Hardware deutlich")
+        elif avg_time < 5.0:
+            results.append(f"**☁️ Cloud Rating:** ⚡ Sehr gut - Konkurrenzfähig mit lokaler Hardware")
+        elif avg_time < 10.0:
+            results.append(f"**☁️ Cloud Rating:** ✅ Gut - Ähnlich wie lokale Performance")
+        elif avg_time < 20.0:
+            results.append(f"**☁️ Cloud Rating:** ⚠️ Akzeptabel - Lokale Hardware möglicherweise besser")
         else:
-            results.append(f"**☁️ Cloud Rating:** 🐌 Optimierung erforderlich")
+            results.append(f"**☁️ Cloud Rating:** 🐌 Langsam - On-Premise deutlich überlegen")
         
-        # 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 ✅")
+        # Thesis Integration - Direkter Vergleich mit deinen lokalen Daten
+        results.append(f"\n## 🆚 **SAAP Thesis: Cloud vs. On-Premise Benchmark**")
         
-        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 ❌")
+        results.append(f"\n### 🏠 **On-Premise (Deine CachyOS Daten):**")
+        results.append(f"- **qwen2:1.5b:** 25.94s (1.5B Parameter)")
+        results.append(f"- **tinyllama:** 17.96s (1B Parameter)")
+        results.append(f"- **Hardware:** Intel i7-5600U, 16GB RAM, keine GPU")
+        results.append(f"- **Kosten:** 0€ pro Request ✅")
+        results.append(f"- **DSGVO:** 100% konform, keine Datenübertragung ✅")
+        results.append(f"- **Verfügbarkeit:** Offline-fähig ✅")
+        results.append(f"- **Kontrolle:** Vollständige Datenkontrolle ✅")
         
-        # 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")
+        results.append(f"\n### ☁️ **Cloud (HuggingFace Inference API):**")
+        results.append(f"- **Average Response Time:** {avg_time:.2f}s")
+        results.append(f"- **Hardware:** GPU-Cluster, optimierte Infrastruktur")
+        results.append(f"- **Kosten:** API-Gebühren pro Request 💰")
+        results.append(f"- **DSGVO:** Abhängig von Anbieter, Datenübertragung ⚠️")
+        results.append(f"- **Verfügbarkeit:** Internetverbindung erforderlich ❌")
+        results.append(f"- **Kontrolle:** Limitierte Kontrolle über Verarbeitung ⚠️")
+        
+        # Dynamisches Fazit basierend auf Performance
+        performance_ratio = avg_time / 21.95  # Average deiner lokalen Tests
+        
+        results.append(f"\n### 🎓 **SAAP Thesis-Fazit:**")
+        
+        if performance_ratio < 0.3:  # Cloud >3x schneller
+            results.append(f"**Performance-Vorteil Cloud:** ☁️ {1/performance_ratio:.1f}x schneller als On-Premise")
+            results.append(f"**Empfehlung:** Cloud für Performance-kritische Anwendungen, On-Premise für Datenschutz")
+        elif performance_ratio < 0.7:  # Cloud schneller
+            results.append(f"**Performance-Vorteil Cloud:** ☁️ {1/performance_ratio:.1f}x schneller als On-Premise")
+            results.append(f"**Empfehlung:** Balanced Approach - je nach Priorität Performance vs. Datenschutz")
+        elif performance_ratio < 1.3:  # Ähnliche Performance
+            results.append(f"**Performance:** Ähnlich (Cloud {performance_ratio:.1f}x vs. On-Premise)")
+            results.append(f"**Empfehlung:** 🏠 On-Premise vorzuziehen - gleiche Performance + besserer Datenschutz + keine Kosten")
+        else:  # On-Premise schneller
+            results.append(f"**Performance-Vorteil On-Premise:** 🏠 {performance_ratio:.1f}x schneller als Cloud")
+            results.append(f"**Empfehlung:** 🏠 On-Premise deutlich überlegen - bessere Performance + Datenschutz + Kosteneffizienz")
+            
+        results.append(f"\n**🎯 SAAP Multi-Agent Platform Strategie:**")
+        results.append(f"- **Entwicklung/Prototyping:** ☁️ Cloud für Flexibilität")
+        results.append(f"- **Produktion (DSGVO-kritisch):** 🏠 On-Premise für Compliance")
+        results.append(f"- **Hybrid-Ansatz:** Kritische Agenten On-Premise, Skalierung Cloud")
+    
+    else:
+        results.append(f"## ❌ Cloud Performance Issues")
+        results.append(f"**Problem:** Keine erfolgreichen Tests")
+        results.append(f"**Mögliche Ursachen:** API-Limits, Model-Verfügbarkeit, Netzwerk")
+        results.append(f"\n**🎓 Thesis-Implikation:** On-Premise bietet höhere Zuverlässigkeit")
     
     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**")
+    gr.Markdown("**Master Thesis:** Hanan Wandji Danga | **HuggingFace Inference API** | **Cloud vs. On-Premise Vergleich**")
     
     with gr.Row():
         with gr.Column(scale=2):
             prompt_input = gr.Textbox(
                 label="SAAP Test Prompt",
-                placeholder="Test-Prompt für Agent Performance...",
+                placeholder="Test-Prompt für Agent Performance-Vergleich...",
                 lines=3,
                 value="Erkläre die Vorteile einer On-Premise Multi-Agent-Plattform gegenüber Cloud-Lösungen."
             )
@@ -241,40 +251,51 @@ with gr.Blocks(title="SAAP Cloud Benchmark", theme=gr.themes.Soft()) as demo:
         outputs=results_output
     )
     
-    # System Info
-    with gr.Accordion("ℹ️ Cloud vs. On-Premise Vergleich", open=False):
+    # Enhanced System Info
+    with gr.Accordion("🎓 SAAP Thesis: Cloud vs. On-Premise Analyse", open=False):
         gr.Markdown("""
-        ### 🎓 SAAP Thesis Integration
+        ### 📊 Benchmark-Strategie für Master-Thesis
+        
+        #### 🏠 On-Premise Baseline (Ihre CachyOS Daten):
+        - **qwen2:1.5b:** 25.94s | **tinyllama:** 17.96s
+        - **Hardware:** Intel i7-5600U, 16GB RAM, keine GPU
+        - **Durchschnitt:** ~22s für komplexe Multi-Agent Prompts
+        
+        #### ☁️ Cloud Vergleich (Diese App):
+        - **Direkte HuggingFace Inference API Calls**
+        - **GPU-optimierte Inferenz auf professioneller Cloud-Infrastruktur**
+        - **Verschiedene Model-Größen für faire Vergleiche**
         
-        #### 🏠 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
+        ### 🎯 Thesis-Relevante Metriken:
+        1. **Performance-Ratio:** Cloud-Zeit vs. On-Premise-Zeit
+        2. **Kosteneffizienz:** 0€ (On-Premise) vs. API-Kosten (Cloud)
+        3. **DSGVO-Compliance:** 100% (On-Premise) vs. Abhängig (Cloud)
+        4. **Verfügbarkeit:** Offline (On-Premise) vs. Online-abhängig (Cloud)
+        5. **Kontrolle:** Vollständig (On-Premise) vs. Limitiert (Cloud)
         
-        #### ☁️ 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:
         
-        #### 🎯 Für SAAP Multi-Agent Platform:
-        **On-Premise ist ideal für:**
-        - Krankenhäuser, Behörden, Finanzsektor
-        - Datenschutz-kritische Anwendungen
-        - Kostenkontrolle bei hohem Durchsatz
+        **On-Premise Ideal für:**
+        - 🏥 Krankenhäuser (Patientendaten)
+        - 🏛️ Behörden (Bürgerdaten) 
+        - 🏦 Finanzsektor (Transaktionsdaten)
+        - 🏭 Industrie 4.0 (Betriebsgeheimnisse)
         
-        **Cloud ist geeignet für:**
-        - Prototyping und Entwicklung
-        - Variable Workloads
-        - Schnelle Experimente
+        **Cloud Geeignet für:**
+        - 🔬 Prototyping und Entwicklung
+        - 📈 Variable Workloads
+        - 🌐 Globale Skalierung
+        - ⚡ Performance-kritische Anwendungen
         
-        ### 📊 Ihre Thesis-Daten:
-        Sammeln Sie beide Datensätze für aussagekräftige Vergleiche!
+        ### 📈 Erwartete Thesis-Ergebnisse:
+        - **Cloud:** Möglicherweise 2-10x schneller (GPU-Vorteil)
+        - **On-Premise:** Kosteneffizienter bei hohem Durchsatz
+        - **Hybrid-Ansatz:** Optimale Lösung für SAAP-Platform
         
-        **Lokale App:** http://127.0.0.1:7860 (CachyOS)
-        **Cloud App:** Diese HuggingFace Space
+        ---
+        **🔬 Dual-Benchmark Setup:**
+        - **Lokale App:** http://127.0.0.1:7860 (On-Premise Daten sammeln)
+        - **Cloud App:** Diese HuggingFace Space (Cloud-Performance testen)
         """)
 
 if __name__ == "__main__":