Update app.py

app.py

@@ -1,178 +1,105 @@
-from transformers import FlaxAutoModelForSeq2SeqLM, AutoTokenizer # AutoModel entfernt
-import torch # Beibehalten
-import numpy as np # Beibehalten
+from transformers import AutoTokenizer, AutoModel # Entfernt: FlaxAutoModelForSeq2SeqLM
+import torch
+import numpy as np
 import random
 import json
 from fastapi import FastAPI
 from fastapi.responses import JSONResponse
 from pydantic import BaseModel
 
-# Lade RecipeBERT Modell (KOMPLETT ENTFERNT für diesen Schritt)
-# bert_model_name = "alexdseo/RecipeBERT"
-# bert_tokenizer = AutoTokenizer.from_pretrained(bert_model_name)
-# bert_model = AutoModel.from_pretrained(bert_model_name)
-# bert_model.eval()
-
-# 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_token
-tokens_map = {
-    "<sep>": "--",
-    "<section>": "\n"
-}
-
-# --- RecipeBERT-spezifische Funktionen sind entfernt oder vereinfacht ---
-# get_embedding, average_embedding, get_cosine_similarity, get_combined_scores sind entfernt.
-
-# find_best_ingredients (modifiziert, um KEINE Embeddings zu nutzen)
+# Lade NUR RecipeBERT Modell
+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
+
+# T5-Modell und -Logik KOMPLETT ENTFERNT für diesen Schritt
+# special_tokens und tokens_map sind nicht mehr relevant, bleiben aber als Kommentar
+
+# --- RecipeBERT-spezifische Funktionen (die jetzt die Kernlogik sind) ---
+def get_embedding(text):
+    """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)
+    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 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()
+    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
+    return dot_product / (norm_a * norm_b)
+
+
+# find_best_ingredients (modifiziert, um KEINE Embeddings für T5-ähnliche Auswahl zu nutzen,
+# sondern nur grundlegende Zutatenbearbeitung und Optionalen Test für RecipeBERT-Laden)
 def find_best_ingredients(required_ingredients, available_ingredients, max_ingredients=6, avg_weight=0.6):
     """
-    Findet die besten Zutaten. Für diesen einfachen Test wird nur
-    die Liste der benötigten Zutaten um zufällig ausgewählte
-    verfügbare Zutaten ergänzt, OHNE Embeddings zu nutzen.
+    Für diesen Test: Gibt einfach die benötigten Zutaten plus ein paar zufällige verfügbare Zutaten zurück.
+    Die semantische Auswahl von RecipeBERT ist hier nicht aktiv (da T5-Generierung fehlt).
     """
     required_ingredients = list(set(required_ingredients))
     available_ingredients = list(set([i for i in available_ingredients if i not in required_ingredients]))
 
-    # Sonderfall: Wenn keine benötigten Zutaten vorhanden sind, wähle zufällig eine aus den verfügbaren Zutaten
-    if not required_ingredients and available_ingredients:
-        random_ingredient = random.choice(available_ingredients)
-        required_ingredients = [random_ingredient]
-        available_ingredients = [i for i in available_ingredients if i != random_ingredient]
-
-    # Wenn bereits maximale Kapazität erreicht ist
-    if len(required_ingredients) >= max_ingredients:
-        return required_ingredients[:max_ingredients]
-
-    # Wenn keine zusätzlichen Zutaten verfügbar sind
-    if not available_ingredients:
-        return required_ingredients
-
-    # Füge zufällig weitere Zutaten hinzu, bis max_ingredients erreicht ist
-    current_ingredients = required_ingredients.copy()
-    num_to_add = min(max_ingredients - len(current_ingredients), len(available_ingredients))
-
-    # Wähle zufällig aus den verfügbaren Zutaten
-    selected_from_available = random.sample(available_ingredients, num_to_add)
-    current_ingredients.extend(selected_from_available)
-
-    return current_ingredients
-
-
-def skip_special_tokens(text, special_tokens):
-    """Entfernt spezielle Tokens aus dem Text"""
-    for token in special_tokens:
-        text = text.replace(token, "")
-    return text
-
-def target_postprocessing(texts, special_tokens):
-    """Post-processed generierten Text"""
-    if not isinstance(texts, list):
-        texts = [texts]
-    new_texts = []
-    for text in texts:
-        text = skip_special_tokens(text, special_tokens)
-        for k, v in tokens_map.items():
-            text = text.replace(k, v)
-        new_texts.append(text)
-    return new_texts
-
-def validate_recipe_ingredients(recipe_ingredients, expected_ingredients, tolerance=0):
-    """
-    Validiert, ob das Rezept ungefähr die erwarteten Zutaten enthält.
-    """
-    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
-
-def generate_recipe_with_t5(ingredients_list, max_retries=5):
-    """Generiert ein Rezept mit dem T5 Rezeptgenerierungsmodell mit Validierung."""
-    original_ingredients = ingredients_list.copy()
-    for attempt in range(max_retries):
-        try:
-            if attempt > 0:
-                current_ingredients = original_ingredients.copy()
-                random.shuffle(current_ingredients)
-            else:
-                current_ingredients = ingredients_list
-            ingredients_string = ", ".join(current_ingredients)
-            prefix = "items: "
-            generation_kwargs = {
-                "max_length": 512,
-                "min_length": 64,
-                "do_sample": True,
-                "top_k": 60,
-                "top_p": 0.95
-            }
-            inputs = t5_tokenizer(
-                prefix + ingredients_string,
-                max_length=256,
-                padding="max_length",
-                truncation=True,
-                return_tensors="jax"
-            )
-            output_ids = t5_model.generate(
-                input_ids=inputs.input_ids,
-                attention_mask=inputs.attention_mask,
-                **generation_kwargs
-            )
-            generated = output_ids.sequences
-            generated_text = target_postprocessing(
-                t5_tokenizer.batch_decode(generated, skip_special_tokens=False),
-                special_tokens
-            )[0]
-            recipe = {}
-            sections = generated_text.split("\n")
-            for section in sections:
-                section = section.strip()
-                if section.startswith("title:"):
-                    recipe["title"] = section.replace("title:", "").strip().capitalize()
-                elif section.startswith("ingredients:"):
-                    ingredients_text = section.replace("ingredients:", "").strip()
-                    recipe["ingredients"] = [item.strip().capitalize() for item in ingredients_text.split("--") if item.strip()]
-                elif section.startswith("directions:"):
-                    directions_text = section.replace("directions:", "").strip()
-                    recipe["directions"] = [step.strip().capitalize() for step in directions_text.split("--") if step.strip()]
-            if "title" not in recipe:
-                recipe["title"] = f"Rezept mit {', '.join(current_ingredients[:3])}"
-            if "ingredients" not in recipe:
-                recipe["ingredients"] = current_ingredients
-            if "directions" not in recipe:
-                recipe["directions"] = ["Keine Anweisungen generiert"]
-            if validate_recipe_ingredients(recipe["ingredients"], original_ingredients):
-                return recipe
-            else:
-                if attempt == max_retries - 1:
-                    return recipe
-        except Exception as e:
-            if attempt == max_retries - 1:
-                return {
-                    "title": f"Rezept mit {original_ingredients[0] if original_ingredients else 'Zutaten'}",
-                    "ingredients": original_ingredients,
-                    "directions": ["Fehler beim Generieren der Rezeptanweisungen"]
-                }
+    final_ingredients = required_ingredients.copy()
+    num_to_add = min(max_ingredients - len(final_ingredients), len(available_ingredients))
+    if num_to_add > 0:
+        final_ingredients.extend(random.sample(available_ingredients, num_to_add))
+    
+    # Optional: Ein kleiner Test-Print, ob RecipeBERT erfolgreich geladen wurde
+    try:
+        if final_ingredients:
+            # Versuche ein Embedding für die erste Zutat zu generieren
+            test_embedding = get_embedding(final_ingredients[0])
+            print(f"INFO: Successfully generated embedding for '{final_ingredients[0]}'. RecipeBERT is loaded.")
+        else:
+            print("INFO: No ingredients to test embedding with.")
+    except Exception as e:
+        print(f"ERROR: RecipeBERT embedding test failed: {e}")
+
+    return final_ingredients
+
+# mock_generate_recipe (ersetzt generate_recipe_with_t5)
+def mock_generate_recipe(ingredients_list):
+    """Generiert ein Mock-Rezept, da T5-Modell entfernt ist."""
+    title = f"Einfaches Rezept mit {', '.join(ingredients_list[:3])}" if ingredients_list else "Einfaches Testrezept"
     return {
-        "title": f"Rezept mit {original_ingredients[0] if original_ingredients else 'Zutaten'}",
-        "ingredients": original_ingredients,
-        "directions": ["Fehler beim Generieren der Rezeptanweisungen"]
+        "title": title,
+        "ingredients": ingredients_list, # Die "generierten" Zutaten sind einfach die Eingabe
+        "directions": [
+            "Dies ist ein generierter Text von RecipeBERT (ohne T5).",
+            "Fügen Sie Ihre Zutaten zusammen und kochen Sie es nach Belieben.",
+            "Das Laden des RecipeBERT-Modells war erfolgreich!"
+        ]
     }
 
+
 def process_recipe_request_logic(required_ingredients, available_ingredients, max_ingredients, max_retries):
     """
     Kernlogik zur Verarbeitung einer Rezeptgenerierungsanfrage.
+    Für diesen Test wird nur RecipeBERT zum Laden getestet und ein Mock-Rezept zurückgegeben.
     """
     if not required_ingredients and not available_ingredients:
         return {"error": "Keine Zutaten angegeben"}
     try:
-        # Hier wird die vereinfachte find_best_ingredients verwendet, die KEINE Embeddings nutzt.
         optimized_ingredients = find_best_ingredients(
             required_ingredients, available_ingredients, max_ingredients
         )
-        recipe = generate_recipe_with_t5(optimized_ingredients, max_retries)
+        
+        # Rufe die Mock-Generierungsfunktion auf
+        recipe = mock_generate_recipe(optimized_ingredients) 
+        
         result = {
             'title': recipe['title'],
             'ingredients': recipe['ingredients'],
@@ -184,7 +111,7 @@ def process_recipe_request_logic(required_ingredients, available_ingredients, ma
         return {"error": f"Fehler bei der Rezeptgenerierung: {str(e)}"}
 
 # --- FastAPI-Implementierung ---
-app = FastAPI(title="AI Recipe Generator API") # Deine FastAPI-Instanz
+app = FastAPI(title="AI Recipe Generator API (RecipeBERT Only Test)")
 
 class RecipeRequest(BaseModel):
     required_ingredients: list[str] = []
@@ -195,10 +122,6 @@ class RecipeRequest(BaseModel):
 
 @app.post("/generate_recipe") # Der API-Endpunkt für Flutter
 async def generate_recipe_api(request_data: RecipeRequest):
-    """
-    Standard-REST-API-Endpunkt für die Flutter-App.
-    Nimmt direkt JSON-Daten an und gibt direkt JSON zurück.
-    """
     final_required_ingredients = request_data.required_ingredients
     if not final_required_ingredients and request_data.ingredients:
         final_required_ingredients = request_data.ingredients
@@ -211,9 +134,8 @@ async def generate_recipe_api(request_data: RecipeRequest):
     )
     return JSONResponse(content=result_dict)
 
-# Optionaler Root-Endpunkt für Health-Checks
 @app.get("/")
 async def read_root():
-    return {"message": "AI Recipe Generator API is running (T5 only)!"} # Angepasste Nachricht
+    return {"message": "AI Recipe Generator API is running (RecipeBERT only)!"} # Angepasste Nachricht
 
 print("INFO: FastAPI application script finished execution and defined 'app' variable.")