Update app.py

app.py

@@ -8,18 +8,16 @@ from fastapi.responses import JSONResponse
 from pydantic import BaseModel
 from datetime import datetime, timedelta
 
-# 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)
-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)
 
-# Token Mapping für die T5 Modell-Ausgabe
 special_tokens = t5_tokenizer.all_special_tokens
 tokens_map = {
     "<sep>": "--",
@@ -39,10 +37,10 @@ def get_embedding(text):
     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([emb for _, emb in embedding_list])
-    return tensors.mean(dim=0)
+def format_ingredients_for_bert(ingredients_list):
+    """Formatiert Zutatenliste für BERT"""
+    return f"Ingredients: {', '.join(ingredients_list)}"
+
 
 def get_cosine_similarity(vec1, vec2):
     """Berechnet die Cosinus-Ähnlichkeit zwischen zwei Vektoren"""
@@ -86,52 +84,31 @@ def calculate_age_bonus(date_added_str: str, category: str) -> float:
     bonus = days_since_added * daily_bonus
     return min(bonus, 0.10) # Max 10% (0.10)
 
-def get_combined_scores(query_vector, embedding_list_with_details, all_good_embeddings, avg_weight=0.6):
-    """
-    Berechnet einen kombinierten Score unter Berücksichtigung der Ähnlichkeit zum Durchschnitt und zu einzelnen Zutaten.
-    Jetzt inklusive Altersbonus.
-    embedding_list_with_details: Liste von Tupeln (Name, Embedding, DateAddedStr, Category)
-    """
-    results = []
-    for name, emb, date_added_str, category in embedding_list_with_details:
-        avg_similarity = get_cosine_similarity(query_vector, emb)
-        individual_similarities = [get_cosine_similarity(good_emb, emb)
-                                   for _, good_emb in all_good_embeddings]
-        avg_individual_similarity = sum(individual_similarities) / len(individual_similarities) if individual_similarities else 0
-        
-        base_combined_score = avg_weight * avg_similarity + (1 - avg_weight) * avg_individual_similarity
-        
-        # NEU: Altersbonus hinzufügen
-        age_bonus = calculate_age_bonus(date_added_str, category)
-        final_combined_score = base_combined_score + age_bonus
-
-        results.append((name, emb, final_combined_score, date_added_str, category))
-    results.sort(key=lambda x: x[2], reverse=True)
-    return results
-
-def find_best_ingredients(required_ingredients_names, available_ingredients_details, max_ingredients=6, avg_weight=0.6):
+
+
+def find_best_ingredients(required_ingredients_names, available_ingredients_details, max_ingredients=6):
     """
-    Findet die besten Zutaten basierend auf RecipeBERT Embeddings, jetzt mit Alters- und Kategorie-Bonus.
+    Findet die besten Zutaten basierend auf RecipeBERT Embeddings
+    
     required_ingredients_names: Liste von Strings (nur Namen)
     available_ingredients_details: Liste von IngredientDetail-Objekten
     """
     required_ingredients_names = list(set(required_ingredients_names))
 
     # Filtern der verfügbaren Zutaten, um sicherzustellen, dass keine Pflichtzutaten dabei sind
-    # Korrektur hier: Zugriff auf item.name statt item['name']
     available_ingredients_filtered_details = [
         item for item in available_ingredients_details
-        if item.name not in required_ingredients_names # <--- KORREKTUR
+        if item.name not in required_ingredients_names
     ]
 
     # Wenn keine Pflichtzutaten vorhanden sind, aber verfügbare, wähle eine zufällig als Pflichtzutat
     if not required_ingredients_names and available_ingredients_filtered_details:
         random_item = random.choice(available_ingredients_filtered_details)
-        required_ingredients_names = [random_item.name] # <--- KORREKTUR
+        required_ingredients_names = [random_item.name]
         # Entferne die zufällig gewählte Zutat aus den verfügbaren Details
         available_ingredients_filtered_details = [
             item for item in available_ingredients_filtered_details
-            if item.name != random_item.name # <--- KORREKTUR
+            if item.name != random_item.name
         ]
         print(f"No required ingredients provided. Randomly selected: {required_ingredients_names[0]}")
 
@@ -141,39 +118,67 @@ def find_best_ingredients(required_ingredients_names, available_ingredients_deta
     if not available_ingredients_filtered_details:
         return required_ingredients_names
 
-    # Erstelle Embeddings für Pflichtzutaten (nur Name und Embedding)
-    embed_required = [(name, get_embedding(name)) for name in required_ingredients_names]
+    print(f"\n=== Suche passende Zutaten für Basis: {required_ingredients_names} ===")
+    print(f"Verfügbare Zutaten: {[item.name for item in available_ingredients_filtered_details]}")
+    print("-" * 50)
 
-    # Erstelle Embeddings für verfügbare Zutaten, inklusive ihrer Details
-    # Korrektur hier: Zugriff auf item.name, item.dateAdded, item.category
-    embed_available_with_details = [
-        (item.name, get_embedding(item.name), item.dateAdded, item.category) # <--- KORREKTUR
-        for item in available_ingredients_filtered_details
-    ]
+    current_combination = required_ingredients_names.copy()
+    remaining_ingredients_details = available_ingredients_filtered_details.copy()
 
-    num_to_add = min(max_ingredients - len(required_ingredients_names), len(embed_available_with_details))
+    num_to_add = min(max_ingredients - len(required_ingredients_names), len(remaining_ingredients_details))
 
-    final_ingredients_with_embeddings = embed_required.copy() # (Name, Embedding)
-    final_ingredients_names = required_ingredients_names.copy() # Nur Namen zum Tracken der ausgewählten
+    for round_num in range(num_to_add):
+        best_ingredient_detail = None
+        best_score = -1
 
-    for _ in range(num_to_add):
-        avg = average_embedding(final_ingredients_with_embeddings)
-        candidates = get_combined_scores(avg, embed_available_with_details, final_ingredients_with_embeddings, avg_weight)
-        
-        if not candidates:
-            break
+        # Formatiere aktuelle Kombination für BERT
+        current_text = format_ingredients_for_bert(current_combination)
+        current_embedding = get_embedding(current_text)
+
+        print(f"\nRunde {round_num + 1} - Aktuelle Kombination: {current_combination}")
+        print("Teste verbleibende Zutaten:")
+
+        for ingredient_detail in remaining_ingredients_details:
+            # Berechne semantische Ähnlichkeit mit BERT
+            ingredient_text = format_ingredients_for_bert([ingredient_detail.name])
+            ingredient_embedding = get_embedding(ingredient_text)
+            similarity = get_cosine_similarity(current_embedding, ingredient_embedding)
+
+            # Berechne Altersbonus
+            age_bonus = calculate_age_bonus(ingredient_detail.dateAdded, ingredient_detail.category)
             
-        best_name, best_embedding, best_score, _, _ = candidates[0] # Holen Sie den besten Kandidaten
-
-        final_ingredients_with_embeddings.append((best_name, best_embedding))
-        final_ingredients_names.append(best_name)
-        
-        # Entferne den besten Kandidaten aus den verfügbaren
-        # Korrektur hier: Zugriff auf item[0] (den Namen im Tupel)
-        embed_available_with_details = [item for item in embed_available_with_details if item[0] != best_name]
+            # Kombiniere Ähnlichkeit und Altersbonus
+            final_score = similarity + age_bonus
+
+            print(f"  - '{ingredient_detail.name}': Ähnlichkeit = {similarity:.4f}, Altersbonus = {age_bonus:.4f}, Gesamt = {final_score:.4f}")
+
+            if final_score > best_score:
+                best_score = final_score
+                best_ingredient_detail = ingredient_detail
+
+        if best_ingredient_detail:
+            current_combination.append(best_ingredient_detail.name)
+            remaining_ingredients_details.remove(best_ingredient_detail)
             
-    return final_ingredients_names
+            # Berechne die Komponenten für die Ausgabe
+            best_similarity = get_cosine_similarity(
+                current_embedding, 
+                get_embedding(format_ingredients_for_bert([best_ingredient_detail.name]))
+            )
+            best_age_bonus = calculate_age_bonus(best_ingredient_detail.dateAdded, best_ingredient_detail.category)
+            
+            print(f"\n-> Runde {round_num + 1} abgeschlossen: Beste Zutat ist '{best_ingredient_detail.name}' mit Gesamtscore {best_score:.4f}")
+            print(f"   (Ähnlichkeit: {best_similarity:.4f} + Altersbonus: {best_age_bonus:.4f})")
+            print(f"   Neue Kombination: {current_combination}")
+            print("-" * 50)
+        else:
+            print("Keine weiteren passenden Zutaten gefunden.")
+            break
+
+    print(f"\nEndgültige Zutatenkombination: {current_combination}")
+    return current_combination
 
+# --- Chef Transformer-spezifische Funktionen ---
 
 def skip_special_tokens(text, special_tokens):
     """Entfernt spezielle Tokens aus dem Text"""
@@ -341,4 +346,3 @@ async def generate_recipe_api(request_data: RecipeRequest):
 async def read_root():
     return {"message": "AI Recipe Generator API is running (FastAPI only)!"}
 
-print("INFO: Pure FastAPI application script finished execution and defined 'app' variable.")