Update app.py

app.py

@@ -1,13 +1,14 @@
+import gradio as gr
 from transformers import FlaxAutoModelForSeq2SeqLM, AutoTokenizer, AutoModel
 import torch
 import numpy as np
 import random
 import json
-from fastapi import FastAPI
+from fastapi import FastAPI, Request
 from fastapi.responses import JSONResponse
 from pydantic import BaseModel
 
-# Lade RecipeBERT Modell
+# Lade RecipeBERT Modell (für semantische Zutat-Kombination)
 bert_model_name = "alexdseo/RecipeBERT"
 bert_tokenizer = AutoTokenizer.from_pretrained(bert_model_name)
 bert_model = AutoModel.from_pretrained(bert_model_name)
@@ -16,7 +17,7 @@ bert_model.eval() # Setze das Modell in den Evaluationsmodus
 # Lade T5 Rezeptgenerierungsmodell
 MODEL_NAME_OR_PATH = "flax-community/t5-recipe-generation"
 t5_tokenizer = AutoTokenizer.from_pretrained(MODEL_NAME_OR_PATH, use_fast=True)
-t5_model = FlaxAutoModelForSeq2SeqLM.from_pretrained(MODEL_NAME_OR_PATH) # Modell wird jetzt auch geladen
+t5_model = FlaxAutoModelForSeq2SeqLM.from_pretrained(MODEL_NAME_OR_PATH)
 
 # Token Mapping für die T5 Modell-Ausgabe
 special_tokens = t5_tokenizer.all_special_tokens
@@ -25,83 +26,138 @@ tokens_map = {
     "<section>": "\n"
 }
 
-# --- RecipeBERT-spezifische Funktionen (unverändert) ---
 def get_embedding(text):
-    """Berechnet das Embedding für einen Text mit Mean Pooling über alle Tokens."""
+    """Berechnet das Embedding für einen Text mit Mean Pooling über alle Tokens"""
     inputs = bert_tokenizer(text, return_tensors="pt", truncation=True, padding=True)
     with torch.no_grad():
         outputs = bert_model(**inputs)
+
+    # Mean Pooling - Mittelwert aller Token-Embeddings
     attention_mask = inputs['attention_mask']
     token_embeddings = outputs.last_hidden_state
     input_mask_expanded = attention_mask.unsqueeze(-1).expand(token_embeddings.size()).float()
     sum_embeddings = torch.sum(token_embeddings * input_mask_expanded, 1)
     sum_mask = torch.clamp(input_mask_expanded.sum(1), min=1e-9)
+
     return (sum_embeddings / sum_mask).squeeze(0)
 
 def average_embedding(embedding_list):
-    """Berechnet den Durchschnitt einer Liste von Embeddings."""
-    tensors = torch.stack(embedding_list)
+    """Berechnet den Durchschnitt einer Liste von Embeddings"""
+    # Sicherstellen, dass embedding_list Tupel von (Name, Embedding) enthält
+    tensors = torch.stack([emb for _, emb in embedding_list])
     return tensors.mean(dim=0)
 
 def get_cosine_similarity(vec1, vec2):
-    """Berechnet die Cosinus-Ähnlichkeit zwischen zwei Vektoren."""
-    if torch.is_tensor(vec1): vec1 = vec1.detach().numpy()
-    if torch.is_tensor(vec2): vec2 = vec2.detach().numpy()
+    """Berechnet die Cosinus-Ähnlichkeit zwischen zwei Vektoren"""
+    if torch.is_tensor(vec1):
+        vec1 = vec1.detach().numpy()
+    if torch.is_tensor(vec2):
+        vec2 = vec2.detach().numpy()
+
+    # Stelle sicher, dass die Vektoren die richtige Form haben (flachen sie bei Bedarf ab)
     vec1 = vec1.flatten()
     vec2 = vec2.flatten()
+
     dot_product = np.dot(vec1, vec2)
     norm_a = np.linalg.norm(vec1)
     norm_b = np.linalg.norm(vec2)
-    if norm_a == 0 or norm_b == 0: return 0
+
+    # Division durch Null vermeiden
+    if norm_a == 0 or norm_b == 0:
+        return 0
+
     return dot_product / (norm_a * norm_b)
 
-# find_best_ingredients (unverändert, nutzt RecipeBERT für eine ähnlichste Zutat)
-def find_best_ingredients(required_ingredients, available_ingredients, max_ingredients=6):
+def get_combined_scores(query_vector, embedding_list, all_good_embeddings, avg_weight=0.6):
+    """Berechnet einen kombinierten Score unter Berücksichtigung der Ähnlichkeit zum Durchschnitt und zu einzelnen Zutaten"""
+    results = []
+
+    for name, emb in embedding_list:
+        # Ähnlichkeit zum Durchschnittsvektor
+        avg_similarity = get_cosine_similarity(query_vector, emb)
+
+        # Durchschnittliche Ähnlichkeit zu individuellen Zutaten
+        individual_similarities = [get_cosine_similarity(good_emb, emb)
+                                   for _, good_emb in all_good_embeddings]
+        # Vermeide Division durch Null, falls all_good_embeddings leer ist
+        avg_individual_similarity = sum(individual_similarities) / len(individual_similarities) if individual_similarities else 0
+
+        # Kombinierter Score (gewichteter Durchschnitt)
+        combined_score = avg_weight * avg_similarity + (1 - avg_weight) * avg_individual_similarity
+
+        results.append((name, emb, combined_score))
+
+    # Sortiere nach kombiniertem Score (absteigend)
+    results.sort(key=lambda x: x[2], reverse=True)
+    return results
+
+# Die von dir bereitgestellte, korrigierte find_best_ingredients Funktion
+def find_best_ingredients(required_ingredients, available_ingredients, max_ingredients=6, avg_weight=0.6):
     """
-    Findet die besten Zutaten: Alle benötigten + EINE ähnlichste aus den verfügbaren Zutaten.
+    Findet die besten Zutaten basierend auf RecipeBERT Embeddings.
     """
+    # Ensure no duplicates in lists
     required_ingredients = list(set(required_ingredients))
     available_ingredients = list(set([i for i in available_ingredients if i not in required_ingredients]))
-
-    final_ingredients = required_ingredients.copy()
-
-    # Nur wenn wir noch Platz haben und zusätzliche Zutaten verfügbar sind
-    if len(final_ingredients) < max_ingredients and len(available_ingredients) > 0:
-        if final_ingredients:
-            required_embeddings = [get_embedding(ing) for ing in required_ingredients]
-            avg_required_embedding = average_embedding(required_embeddings)
-            
-            best_additional_ingredient = None
-            highest_similarity = -1.0
-
-            for avail_ing in available_ingredients:
-                avail_embedding = get_embedding(avail_ing)
-                similarity = get_cosine_similarity(avg_required_embedding, avail_embedding)
-                if similarity > highest_similarity:
-                    highest_similarity = similarity
-                    best_additional_ingredient = avail_ing
+    
+    # Special case: If no required ingredients, randomly select one from available ingredients
+    if not required_ingredients and available_ingredients:
+        # Randomly select 1 ingredient as starting point
+        random_ingredient = random.choice(available_ingredients)
+        required_ingredients = [random_ingredient]
+        available_ingredients = [i for i in available_ingredients if i != random_ingredient]
+        print(f"No required ingredients provided. Randomly selected: {random_ingredient}")
+    
+    # If still no ingredients or already at max capacity
+    if not required_ingredients or len(required_ingredients) >= max_ingredients:
+        return required_ingredients[:max_ingredients]
+    
+    # If no additional ingredients available
+    if not available_ingredients:
+        return required_ingredients
+    
+    # Calculate embeddings for all ingredients
+    embed_required = [(e, get_embedding(e)) for e in required_ingredients]
+    embed_available = [(e, get_embedding(e)) for e in available_ingredients]
+    
+    # Number of ingredients to add
+    num_to_add = min(max_ingredients - len(required_ingredients), len(available_ingredients))
+    
+    # Copy required ingredients to final list
+    final_ingredients = embed_required.copy()
+    
+    # Add best ingredients
+    for _ in range(num_to_add):
+        # Calculate average vector of current combination
+        avg = average_embedding(final_ingredients)
+        
+        # Calculate combined scores for all candidates
+        candidates = get_combined_scores(avg, embed_available, final_ingredients, avg_weight)
+        
+        # If no candidates left, break
+        if not candidates:
+            break
             
-            if best_additional_ingredient:
-                final_ingredients.append(best_additional_ingredient)
-                print(f"INFO: Added '{best_additional_ingredient}' (similarity: {highest_similarity:.2f}) as most similar.")
-        else:
-            random_ingredient = random.choice(available_ingredients)
-            final_ingredients.append(random_ingredient)
-            print(f"INFO: No required ingredients. Added random available ingredient: '{random_ingredient}'.")
+        # Choose best ingredient
+        best_name, best_embedding, _ = candidates[0]
+        
+        # Add best ingredient to final list
+        final_ingredients.append((best_name, best_embedding))
+        
+        # Remove ingredient from available ingredients
+        embed_available = [item for item in embed_available if item[0] != best_name]
+    
+    # Extract only ingredient names
+    return [name for name, _ in final_ingredients]
 
-    return final_ingredients[:max_ingredients]
-
-
-# skip_special_tokens (unverändert, wird von generate_recipe_with_t5 genutzt)
 def skip_special_tokens(text, special_tokens):
-    """Entfernt spezielle Tokens aus dem Text"""
+    """Removes special tokens from text"""
     for token in special_tokens:
         text = text.replace(token, "")
     return text
 
-# target_postprocessing (unverändert, wird von generate_recipe_with_t5 genutzt)
 def target_postprocessing(texts, special_tokens):
-    """Post-processed generierten Text"""
+    """Post-processes generated text"""
     if not isinstance(texts, list):
         texts = [texts]
 
@@ -116,17 +172,14 @@ def target_postprocessing(texts, special_tokens):
 
     return new_texts
 
-# validate_recipe_ingredients (unverändert, wird von generate_recipe_with_t5 genutzt)
 def validate_recipe_ingredients(recipe_ingredients, expected_ingredients, tolerance=0):
     """
-    Validiert, ob das Rezept ungefähr die erwarteten Zutaten enthält.
+    Validates if the recipe contains approximately the expected ingredients.
     """
     recipe_count = len([ing for ing in recipe_ingredients if ing and ing.strip()])
     expected_count = len(expected_ingredients)
     return abs(recipe_count - expected_count) == tolerance
 
-
-# generate_recipe_with_t5 (jetzt AKTIVIERT)
 def generate_recipe_with_t5(ingredients_list, max_retries=5):
     """Generiert ein Rezept mit dem T5 Rezeptgenerierungsmodell mit Validierung."""
     original_ingredients = ingredients_list.copy()
@@ -227,8 +280,8 @@ def generate_recipe_with_t5(ingredients_list, max_retries=5):
         "directions": ["Fehler beim Generieren der Rezeptanweisungen"]
     }
 
-
-# process_recipe_request_logic (JETZT RUFT generate_recipe_with_t5 auf)
+# Diese Funktion wird von der Gradio-UI und der FastAPI-Route aufgerufen.
+# Sie ist für die Kernlogik zuständig.
 def process_recipe_request_logic(required_ingredients, available_ingredients, max_ingredients, max_retries):
     """
     Kernlogik zur Verarbeitung einer Rezeptgenerierungsanfrage.
@@ -238,14 +291,14 @@ def process_recipe_request_logic(required_ingredients, available_ingredients, ma
         return {"error": "Keine Zutaten angegeben"}
 
     try:
-        # Optimale Zutaten finden (mit RecipeBERT)
+        # Optimale Zutaten finden
         optimized_ingredients = find_best_ingredients(
             required_ingredients,
             available_ingredients,
             max_ingredients
         )
 
-        # Rezept mit optimierten Zutaten generieren (JETZT MIT T5!)
+        # Rezept mit optimierten Zutaten generieren
         recipe = generate_recipe_with_t5(optimized_ingredients, max_retries)
 
         # Ergebnis formatieren
@@ -260,33 +313,161 @@ def process_recipe_request_logic(required_ingredients, available_ingredients, ma
     except Exception as e:
         return {"error": f"Fehler bei der Rezeptgenerierung: {str(e)}"}
 
+# Diese Funktion ist für den internen Gradio 'API-Test'-Tab gedacht,
+# der einen JSON-String als Eingabe erwartet und einen JSON-String zurückgibt.
+# Sie wird NICHT von deiner Flutter-App direkt aufgerufen, da die Flutter-App
+# die /api/generate_recipe_rest FastAPI-Route direkt nutzt.
+def flutter_api_generate_recipe(ingredients_data: str): # Typ-Hint für Klarheit
+    """
+    Flutter-freundliche API-Funktion für den Gradio-API-Test-Tab.
+    Verarbeitet JSON-String-Eingabe und gibt JSON-String-Ausgabe zurück.
+    """
+    try:
+        data = json.loads(ingredients_data) # Muss ein JSON-String sein
 
-# --- FastAPI-Implementierung ---
-app = FastAPI(title="AI Recipe Generator API (Full Functionality)")
+        required_ingredients = data.get('required_ingredients', [])
+        available_ingredients = data.get('available_ingredients', [])
+        max_ingredients = data.get('max_ingredients', 7)
+        max_retries = data.get('max_retries', 5)
+
+        # Rufe die Kernlogik auf
+        result_dict = process_recipe_request_logic(
+            required_ingredients, available_ingredients, max_ingredients, max_retries
+        )
+        return json.dumps(result_dict) # Gibt einen JSON-STRING zurück
+
+    except Exception as e:
+        # Logge den Fehler für Debugging im Space-Log
+        print(f"Error in flutter_api_generate_recipe: {str(e)}")
+        return json.dumps({"error": f"Internal API Error: {str(e)}"})
+
+def gradio_ui_generate_recipe(required_ingredients_text, available_ingredients_text, max_ingredients_val, max_retries_val):
+    """Gradio UI Funktion für die Web-Oberfläche"""
+    try:
+        required_ingredients = [ing.strip() for ing in required_ingredients_text.split(',') if ing.strip()]
+        available_ingredients = [ing.strip() for ing in available_ingredients_text.split(',') if ing.strip()]
+
+        # Rufe die Kernlogik auf
+        result = process_recipe_request_logic(
+            required_ingredients, available_ingredients, max_ingredients_val, max_retries_val
+        )
+
+        if 'error' in result:
+            return result['error'], "", "", ""
+
+        ingredients_list = '\n'.join([f"• {ing}" for ing in result['ingredients']])
+        directions_list = '\n'.join([f"{i+1}. {dir}" for i, dir in enumerate(result['directions'])])
+        used_ingredients = ', '.join(result['used_ingredients'])
+
+        return (
+            result['title'],
+            ingredients_list,
+            directions_list,
+            used_ingredients
+        )
+
+    except Exception as e:
+        # Fehlermeldung für die Gradio UI
+        return f"Fehler: {str(e)}", "", "", ""
+
+# Erstelle die Gradio Oberfläche
+with gr.Blocks(title="AI Rezept Generator") as demo:
+    gr.Markdown("# 🍳 AI Rezept Generator")
+    gr.Markdown("Generiere Rezepte mit KI und intelligenter Zutat-Kombination!")
+
+    with gr.Tab("Web-Oberfläche"):
+        with gr.Row():
+            with gr.Column():
+                required_ing = gr.Textbox(
+                    label="Benötigte Zutaten (kommasepariert)",
+                    placeholder="Hähnchen, Reis, Zwiebel",
+                    lines=2
+                )
+                available_ing = gr.Textbox(
+                    label="Verfügbare Zutaten (kommasepariert, optional)",
+                    placeholder="Knoblauch, Tomate, Pfeffer, Kräuter",
+                    lines=2
+                )
+                max_ing = gr.Slider(3, 10, value=7, step=1, label="Maximale Zutaten")
+                max_retries = gr.Slider(1, 10, value=5, step=1, label="Max. Wiederholungsversuche")
+
+                generate_btn = gr.Button("Rezept generieren", variant="primary")
+
+            with gr.Column():
+                title_output = gr.Textbox(label="Rezepttitel", interactive=False)
+                ingredients_output = gr.Textbox(label="Zutaten", lines=8, interactive=False)
+                directions_output = gr.Textbox(label="Anweisungen", lines=10, interactive=False)
+                used_ingredients_output = gr.Textbox(label="Verwendete Zutaten", interactive=False)
+
+                generate_btn.click(
+                    fn=gradio_ui_generate_recipe,
+                    inputs=[required_ing, available_ing, max_ing, max_retries],
+                    outputs=[title_output, ingredients_output, directions_output, used_ingredients_output]
+                )
+
+    with gr.Tab("API-Test"):
+        gr.Markdown("### Teste die Flutter API (via 'hugging_face_chat_gradio' Client)")
+        gr.Markdown("Dieser Tab zeigt, wie die Eingabe für die 'generate_recipe_for_flutter'-API aussehen sollte.")
+
+        api_input = gr.Textbox(
+            label="JSON-Eingabe (für API-Aufruf)",
+            placeholder='{"required_ingredients": ["chicken", "rice"], "available_ingredients": ["onion", "garlic"], "max_ingredients": 6}',
+            lines=4
+        )
+        api_output = gr.Textbox(label="JSON-Ausgabe", lines=15, interactive=False)
+        api_test_btn = gr.Button("API testen", variant="secondary")
+
+        # Hier wird die Funktion weiterhin für den Gradio-eigenen API-Test-Tab verwendet.
+        api_test_btn.click(
+            fn=flutter_api_generate_recipe,
+            inputs=[api_input],
+            outputs=[api_output],
+            api_name="generate_recipe_for_flutter" # Dies ist der api_name, den das Flutter-Paket verwendet
+        )
+
+        gr.Examples(
+            examples=[
+                ['{"required_ingredients": ["chicken", "rice"], "available_ingredients": ["onion", "garlic", "tomato"], "max_ingredients": 6}'],
+                ['{"ingredients": ["pasta"], "available_ingredients": ["cheese", "mushrooms", "cream"], "max_ingredients": 5}']
+            ],
+            inputs=[api_input]
+        )
+
+# --- FastAPI-Integration ---
+app = FastAPI()
 
 class RecipeRequest(BaseModel):
     required_ingredients: list[str] = []
     available_ingredients: list[str] = []
     max_ingredients: int = 7
     max_retries: int = 5
-    ingredients: list[str] = [] # Für Abwärtskompatibilität
 
-@app.post("/generate_recipe") # Der API-Endpunkt für Flutter
-async def generate_recipe_api(request_data: RecipeRequest):
-    final_required_ingredients = request_data.required_ingredients
-    if not final_required_ingredients and request_data.ingredients:
-        final_required_ingredients = request_data.ingredients
+@app.post("/generate_recipe") # KORRIGIERT: Der Endpunkt ist jetzt /generate_recipe
+async def generate_recipe_rest_api(request_data: RecipeRequest):
+    """
+    Standard-REST-API-Endpunkt für die Flutter-App.
+    Nimmt direkt JSON-Daten an und gibt direkt JSON zurück.
+    """
+    required_ingredients = request_data.required_ingredients
+    available_ingredients = request_data.available_ingredients
+    max_ingredients = request_data.max_ingredients
+    max_retries = request_data.max_retries
 
     result_dict = process_recipe_request_logic(
-        final_required_ingredients,
-        request_data.available_ingredients,
-        request_data.max_ingredients,
-        request_data.max_retries
+        required_ingredients, available_ingredients, max_ingredients, max_retries
     )
+
     return JSONResponse(content=result_dict)
 
-@app.get("/")
-async def read_root():
-    return {"message": "AI Recipe Generator API is running (Full functionality activated)!"} # Angepasste Nachricht
+# Gradio-App als Sub-App in die FastAPI-App mounten
+# Dies ist der Standardweg, um Gradio in eine FastAPI-Anwendung einzubetten.
+# Der Gradio-Teil wird dann unter dem Wurzelpfad '/'.
+app = gr.mount_gradio_app(app, demo, path="/") # Gradio unter dem Wurzelpfad mounten
+
+# Wenn du deine App lokal ausführst, kannst du FastAPI mit Uvicorn starten:
+# if __name__ == "__main__":
+#    import uvicorn
+#    uvicorn.run(app, host="0.0.0.0", port=8000)
 
-print("INFO: FastAPI application script finished execution and defined 'app' variable.")
+# Für Hugging Face Spaces ist der if __name__ == "__main__": Block nicht nötig,
+# da Spaces Uvicorn automatisch startet und die "app"-Variable sucht.