Update app.py

app.py

@@ -5,17 +5,18 @@ import numpy as np
 import random
 import json
 
-# Model loading (same as before)
+# 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()
+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 for T5 model output processing
+# Token Mapping für die T5 Modell-Ausgabe
 special_tokens = t5_tokenizer.all_special_tokens
 tokens_map = {
     "<sep>": "--",
@@ -23,12 +24,12 @@ tokens_map = {
 }
 
 def get_embedding(text):
-    """Computes embedding for a text with Mean Pooling over all 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 - take average of all token embeddings
+    # 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()
@@ -38,18 +39,18 @@ def get_embedding(text):
     return (sum_embeddings / sum_mask).squeeze(0)
 
 def average_embedding(embedding_list):
-    """Computes the average of a list of embeddings"""
+    """Berechnet den Durchschnitt einer Liste von Embeddings"""
     tensors = torch.stack([emb for _, emb in embedding_list])
     return tensors.mean(dim=0)
 
 def get_cosine_similarity(vec1, vec2):
-    """Computes the cosine similarity between two vectors"""
+    """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()
 
-    # Make sure vectors have the right shape (flatten if necessary)
+    # Stelle sicher, dass die Vektoren die richtige Form haben (flachen sie bei Bedarf ab)
     vec1 = vec1.flatten()
     vec2 = vec2.flatten()
 
@@ -57,98 +58,108 @@ def get_cosine_similarity(vec1, vec2):
     norm_a = np.linalg.norm(vec1)
     norm_b = np.linalg.norm(vec2)
 
-    # Avoid division by zero
+    # Division durch Null vermeiden
     if norm_a == 0 or norm_b == 0:
         return 0
 
     return dot_product / (norm_a * norm_b)
 
 def get_combined_scores(query_vector, embedding_list, all_good_embeddings, avg_weight=0.6):
-    """Computes combined score considering both similarity to average and individual ingredients"""
+    """Berechnet einen kombinierten Score unter Berücksichtigung der Ähnlichkeit zum Durchschnitt und zu einzelnen Zutaten"""
     results = []
 
     for name, emb in embedding_list:
-        # Similarity to average vector
+        # Ähnlichkeit zum Durchschnittsvektor
         avg_similarity = get_cosine_similarity(query_vector, emb)
 
-        # Average similarity to individual ingredients
+        # Durchschnittliche Ähnlichkeit zu einzelnen Zutaten
         individual_similarities = [get_cosine_similarity(good_emb, emb)
                                    for _, good_emb in all_good_embeddings]
         avg_individual_similarity = sum(individual_similarities) / len(individual_similarities)
 
-        # Combined score (weighted average)
+        # Kombinierter Score (gewichteter Durchschnitt)
         combined_score = avg_weight * avg_similarity + (1 - avg_weight) * avg_individual_similarity
 
         results.append((name, emb, combined_score))
 
-    # Sort by combined score (descending)
+    # Sortiere nach kombiniertem Score (absteigend)
     results.sort(key=lambda x: x[2], reverse=True)
     return results
 
 def find_best_ingredients(required_ingredients, available_ingredients, max_ingredients=6, avg_weight=0.6):
     """
-    Finds the best ingredients based on RecipeBERT embeddings.
+    Findet die besten Zutaten basierend auf RecipeBERT Embeddings.
+
+    Args:
+        required_ingredients (list): Benötigte Zutaten, die verwendet werden müssen
+        available_ingredients (list): Verfügbare Zutaten zur Auswahl
+        max_ingredients (int): Maximale Anzahl von Zutaten für das Rezept
+        avg_weight (float): Gewicht für den Durchschnittsvektor
+
+    Returns:
+        list: Die optimale Kombination von Zutaten
     """
-    # Ensure no duplicates in lists
+    # Stelle sicher, dass keine Duplikate in den Listen sind
     required_ingredients = list(set(required_ingredients))
     available_ingredients = list(set([i for i in available_ingredients if i not in required_ingredients]))
 
-    # Special case: If no required ingredients, randomly select one from available 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]
+        # print(f"Keine benötigten Zutaten angegeben. Zufällig ausgewählt: {random_ingredient}")
 
-    # If still no ingredients or already at max capacity
+    # Wenn immer noch keine Zutaten vorhanden oder bereits maximale Kapazität erreicht ist
     if not required_ingredients or len(required_ingredients) >= max_ingredients:
         return required_ingredients[:max_ingredients]
 
-    # If no additional ingredients available
+    # Wenn keine zusätzlichen Zutaten verfügbar sind
     if not available_ingredients:
         return required_ingredients
 
-    # Calculate embeddings for all ingredients
+    # Berechne Embeddings für alle Zutaten
     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
+    # Anzahl der hinzuzufügenden Zutaten
     num_to_add = min(max_ingredients - len(required_ingredients), len(available_ingredients))
 
-    # Copy required ingredients to final list
+    # Kopiere benötigte Zutaten in die endgültige Liste
     final_ingredients = embed_required.copy()
 
-    # Add best ingredients
+    # Füge die besten Zutaten hinzu
     for _ in range(num_to_add):
-        # Calculate average vector of current combination
+        # Berechne den Durchschnittsvektor der aktuellen Kombination
         avg = average_embedding(final_ingredients)
 
-        # Calculate combined scores for all candidates
+        # Berechne kombinierte Scores für alle Kandidaten
         candidates = get_combined_scores(avg, embed_available, final_ingredients, avg_weight)
 
-        # If no candidates left, break
+        # Wenn keine Kandidaten mehr übrig sind, breche ab
         if not candidates:
             break
 
-        # Choose best ingredient
+        # Wähle die beste Zutat
         best_name, best_embedding, _ = candidates[0]
 
-        # Add best ingredient to final list
+        # Füge die beste Zutat zur endgültigen Liste hinzu
         final_ingredients.append((best_name, best_embedding))
 
-        # Remove ingredient from available ingredients
+        # Entferne die Zutat aus den verfügbaren Zutaten
         embed_available = [item for item in embed_available if item[0] != best_name]
 
-    # Extract only ingredient names
+    # Extrahiere nur die Zutatennamen
     return [name for name, _ in final_ingredients]
 
 def skip_special_tokens(text, special_tokens):
-    """Removes special tokens from text"""
+    """Entfernt spezielle Tokens aus dem Text"""
     for token in special_tokens:
         text = text.replace(token, "")
     return text
 
 def target_postprocessing(texts, special_tokens):
-    """Post-processes generated text"""
+    """Post-processed generierten Text"""
     if not isinstance(texts, list):
         texts = [texts]
 
@@ -164,29 +175,31 @@ def target_postprocessing(texts, special_tokens):
     return new_texts
 
 def validate_recipe_ingredients(recipe_ingredients, expected_ingredients, tolerance=0):
-    """Validates if the recipe contains approximately the expected ingredients."""
+    """
+    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):
-    """Generates a recipe using the T5 recipe generation model with validation."""
+    """Generiert ein Rezept mit dem T5 Rezeptgenerierungsmodell mit Validierung."""
     original_ingredients = ingredients_list.copy()
 
     for attempt in range(max_retries):
         try:
-            # For retries after the first attempt, shuffle the ingredients
+            # Für Wiederholungsversuche nach dem ersten Versuch, mische die Zutaten
             if attempt > 0:
                 current_ingredients = original_ingredients.copy()
                 random.shuffle(current_ingredients)
             else:
                 current_ingredients = ingredients_list
 
-            # Format ingredients as a comma-separated string
+            # Formatiere Zutaten als kommaseparierten String
             ingredients_string = ", ".join(current_ingredients)
             prefix = "items: "
 
-            # Generation settings
+            # Generationseinstellungen
             generation_kwargs = {
                 "max_length": 512,
                 "min_length": 64,
@@ -194,8 +207,9 @@ def generate_recipe_with_t5(ingredients_list, max_retries=5):
                 "top_k": 60,
                 "top_p": 0.95
             }
+            # print(f"Versuch {attempt + 1}: {prefix + ingredients_string}")
 
-            # Tokenize input
+            # Tokenisiere Eingabe
             inputs = t5_tokenizer(
                 prefix + ingredients_string,
                 max_length=256,
@@ -204,21 +218,21 @@ def generate_recipe_with_t5(ingredients_list, max_retries=5):
                 return_tensors="jax"
             )
 
-            # Generate text
+            # Generiere Text
             output_ids = t5_model.generate(
                 input_ids=inputs.input_ids,
                 attention_mask=inputs.attention_mask,
                 **generation_kwargs
             )
 
-            # Decode and post-process
+            # Dekodieren und Nachbearbeiten
             generated = output_ids.sequences
             generated_text = target_postprocessing(
                 t5_tokenizer.batch_decode(generated, skip_special_tokens=False),
                 special_tokens
             )[0]
 
-            # Parse sections
+            # Abschnitte parsen
             recipe = {}
             sections = generated_text.split("\n")
             for section in sections:
@@ -232,177 +246,192 @@ def generate_recipe_with_t5(ingredients_list, max_retries=5):
                     directions_text = section.replace("directions:", "").strip()
                     recipe["directions"] = [step.strip().capitalize() for step in directions_text.split("--") if step.strip()]
 
-            # If title is missing, create one
+            # Wenn der Titel fehlt, erstelle einen
             if "title" not in recipe:
-                recipe["title"] = f"Recipe with {', '.join(current_ingredients[:3])}"
+                recipe["title"] = f"Rezept mit {', '.join(current_ingredients[:3])}"
 
-            # Ensure all sections exist
+            # Stelle sicher, dass alle Abschnitte existieren
             if "ingredients" not in recipe:
                 recipe["ingredients"] = current_ingredients
             if "directions" not in recipe:
-                recipe["directions"] = ["No directions generated"]
+                recipe["directions"] = ["Keine Anweisungen generiert"]
 
-            # Validate the recipe
+            # Validiere das Rezept
             if validate_recipe_ingredients(recipe["ingredients"], original_ingredients):
+                # print(f"Erfolg bei Versuch {attempt + 1}: Rezept hat die richtige Anzahl von Zutaten")
                 return recipe
             else:
+                # print(f"Versuch {attempt + 1} fehlgeschlagen: Erwartet {len(original_ingredients)} Zutaten, erhalten {len(recipe['ingredients'])}")
                 if attempt == max_retries - 1:
+                    # print("Maximale Wiederholungsversuche erreicht, letztes generiertes Rezept wird zurückgegeben")
                     return recipe
 
         except Exception as e:
+            # print(f"Fehler bei der Rezeptgenerierung Versuch {attempt + 1}: {str(e)}")
             if attempt == max_retries - 1:
                 return {
-                    "title": f"Recipe with {original_ingredients[0] if original_ingredients else 'ingredients'}",
+                    "title": f"Rezept mit {original_ingredients[0] if original_ingredients else 'Zutaten'}",
                     "ingredients": original_ingredients,
-                    "directions": ["Error generating recipe instructions"]
+                    "directions": ["Fehler beim Generieren der Rezeptanweisungen"]
                 }
 
-    # Fallback
+    # Fallback (sollte nicht erreicht werden)
     return {
-        "title": f"Recipe with {original_ingredients[0] if original_ingredients else 'ingredients'}",
+        "title": f"Rezept mit {original_ingredients[0] if original_ingredients else 'Zutaten'}",
         "ingredients": original_ingredients,
-        "directions": ["Error generating recipe instructions"]
+        "directions": ["Fehler beim Generieren der Rezeptanweisungen"]
     }
 
 def flutter_api_generate_recipe(ingredients_data):
     """
-    Flutter-friendly API function that processes JSON input
-    and returns structured JSON output matching your original Flask API
+    Flutter-freundliche API-Funktion, die JSON-Eingaben verarbeitet
+    und strukturierte JSON-Ausgaben zurückgibt, die deiner ursprünglichen Flask-API entsprechen.
     """
     try:
-        # Parse input - handle both string and dict formats
+        # Eingabe parsen - behandle sowohl String- als auch Dict-Formate
         if isinstance(ingredients_data, str):
             data = json.loads(ingredients_data)
         else:
-            data = ingredients_data
-            
-        # Extract parameters (same as your Flask API)
+            data = ingredients_data # Ist bereits ein Dict (z.B. von Gradio UI)
+
+        # Parameter extrahieren (wie deine ursprüngliche Flask-API)
         required_ingredients = data.get('required_ingredients', [])
         available_ingredients = data.get('available_ingredients', [])
-        
-        # Backward compatibility
+
+        # Abwärtskompatibilität: Wenn nur 'ingredients' angegeben ist, behandle es als required_ingredients
         if data.get('ingredients') and not required_ingredients:
             required_ingredients = data.get('ingredients', [])
-            
+
         max_ingredients = data.get('max_ingredients', 7)
         max_retries = data.get('max_retries', 5)
-        
+
         if not required_ingredients and not available_ingredients:
-            return json.dumps({"error": "No ingredients provided"})
-            
-        # Find optimal ingredients
+            return json.dumps({"error": "Keine Zutaten angegeben"})
+
+        # Optimale Zutaten finden
         optimized_ingredients = find_best_ingredients(
             required_ingredients,
-            available_ingredients, 
+            available_ingredients,
             max_ingredients
         )
-        
-        # Generate recipe
+
+        # Rezept mit optimierten Zutaten generieren
         recipe = generate_recipe_with_t5(optimized_ingredients, max_retries)
-        
-        # Return in exact same format as your Flask API
+
+        # Für die Flutter-App formatieren - strukturiertes Format
         result = {
             'title': recipe['title'],
-            'ingredients': recipe['ingredients'], 
+            'ingredients': recipe['ingredients'],
             'directions': recipe['directions'],
             'used_ingredients': optimized_ingredients
         }
-        
+
         return json.dumps(result)
-        
+
     except Exception as e:
-        return json.dumps({"error": f"Error in recipe generation: {str(e)}"})
+        return json.dumps({"error": f"Fehler bei der Rezeptgenerierung: {str(e)}"})
 
-def gradio_ui_generate_recipe(required_ingredients_text, available_ingredients_text, max_ingredients, max_retries):
-    """Gradio UI function for web interface"""
+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:
-        # Parse text inputs
+        # Text-Eingaben parsen
         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()]
-        
-        # Create data dict in Flutter API format
-        data = {
+
+        # Erstelle ein Dictionary im Format der Flutter API
+        data_for_flutter_api = {
             'required_ingredients': required_ingredients,
             'available_ingredients': available_ingredients,
-            'max_ingredients': max_ingredients,
-            'max_retries': max_retries
+            'max_ingredients': max_ingredients_val, # Verwende den Parameter aus dem Slider
+            'max_retries': max_retries_val # Verwende den Parameter aus dem Slider
         }
-        
-        # Use the same function as Flutter API
-        result_json = flutter_api_generate_recipe(data)
+
+        # --- WICHTIG: Wandle das Python-Dictionary in einen JSON-String um,
+        # da flutter_api_generate_recipe intern dieses Format erwartet,
+        # wenn es über einen Gradio-Input aufgerufen wird, der einen String liefert.
+        # Dies simuliert den JSON-String, den die Flutter-App senden würde.
+        data_json_string = json.dumps(data_for_flutter_api)
+        # ---------------------------------------------------------------------
+
+        # Verwende dieselbe Funktion wie die Flutter API
+        result_json = flutter_api_generate_recipe(data_json_string) # <-- Hier die Änderung
+
         result = json.loads(result_json)
-        
+
         if 'error' in result:
             return result['error'], "", "", ""
-            
-        # Format for Gradio display
+
+        # Für die Gradio-Anzeige formatieren
         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, 
+            ingredients_list,
             directions_list,
             used_ingredients
         )
-        
+
     except Exception as e:
-        return f"Error: {str(e)}", "", "", ""
-
-# Create Gradio Interface
-with gr.Blocks(title="AI Recipe Generator") as demo:
-    gr.Markdown("# 🍳 AI Recipe Generator")
-    gr.Markdown("Generate recipes using AI with intelligent ingredient combination!")
-    
-    with gr.Tab("Web Interface"):
+        # 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="Required Ingredients (comma-separated)",
-                    placeholder="chicken, rice, onion",
+                    label="Benötigte Zutaten (kommasepariert)",
+                    placeholder="Hähnchen, Reis, Zwiebel",
                     lines=2
                 )
                 available_ing = gr.Textbox(
-                    label="Available Ingredients (comma-separated)", 
-                    placeholder="garlic, tomato, pepper, herbs",
+                    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="Maximum Ingredients")
-                max_retries = gr.Slider(1, 10, value=5, step=1, label="Max Retries")
-                generate_btn = gr.Button("Generate Recipe", variant="primary")
-            
+                # Die Parameter-Namen für Slider müssen mit den Argumenten der Gradio UI Funktion übereinstimmen
+                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="Recipe Title", interactive=False)
-                ingredients_output = gr.Textbox(label="Ingredients", lines=8, interactive=False)
-                directions_output = gr.Textbox(label="Directions", lines=10, interactive=False)
-                used_ingredients_output = gr.Textbox(label="Used Ingredients", 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 Testing"):
-        gr.Markdown("### Test the Flutter API")
-        gr.Markdown("This tab uses the same function that Flutter apps will call via API")
-        
+                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], # Hier die Slider-Komponenten übergeben
+                    outputs=[title_output, ingredients_output, directions_output, used_ingredients_output]
+                )
+
+    with gr.Tab("API-Test"):
+        gr.Markdown("### Teste die Flutter API")
+        gr.Markdown("Dieser Tab verwendet dieselbe Funktion, die Flutter-Apps über die API aufrufen werden.")
+
         api_input = gr.Textbox(
-            label="JSON Input (Flutter API Format)",
+            label="JSON-Eingabe (Flutter API-Format)",
             placeholder='{"required_ingredients": ["chicken", "rice"], "available_ingredients": ["onion", "garlic"], "max_ingredients": 6}',
             lines=4
         )
-        api_output = gr.Textbox(label="JSON Output", lines=15, interactive=False)
-        api_test_btn = gr.Button("Test API", variant="secondary")
-        
+        api_output = gr.Textbox(label="JSON-Ausgabe", lines=15, interactive=False)
+        api_test_btn = gr.Button("API testen", variant="secondary")
+
         api_test_btn.click(
             fn=flutter_api_generate_recipe,
             inputs=[api_input],
             outputs=[api_output],
-            api_name="generate_recipe_for_flutter" # <-- Hinzufügen dieser Zeile
+            api_name="generate_recipe_for_flutter" # <-- Dies ist der von Flutter verwendete API-Name
         )
-        
+
         gr.Examples(
             examples=[
                 ['{"required_ingredients": ["chicken", "rice"], "available_ingredients": ["onion", "garlic", "tomato"], "max_ingredients": 6}'],
@@ -412,4 +441,4 @@ with gr.Blocks(title="AI Recipe Generator") as demo:
         )
 
 if __name__ == "__main__":
-    demo.launch()
+    demo.launch()