Add

FastAPI_app.py

@@ -3,72 +3,142 @@
 # import libraries
 import os
 import io
-import numpy as np
-import traceback
 import time
-import uvicorn
-
+import traceback
 
-# Heavy imports 
-import tensorflow as tf
+import uvicorn
+import numpy as np
 from PIL import Image
 from fastapi import FastAPI, Form, UploadFile, File, Request, HTTPException
 from fastapi.responses import HTMLResponse
 from fastapi.staticfiles import StaticFiles
 from fastapi.templating import Jinja2Templates
 from fastapi.middleware.cors import CORSMiddleware
+
+# import ML libraries
+import tensorflow as tf
 import google.generativeai as genai
 
+# Transformers libraries (for fallback)
+from transformers import pipeline, AutoTokenizer, AutoModelForCausalLM
+import torch
+import threading
+
 
+# create presistent storage for GPT-2
+LOCAL_GPT2_DIR = "/data/gpt2"      # HF Spaces persistent folder
+REMOTE_GPT2_NAME = "gpt2-medium"
 
-from transformers import AutoTokenizer, AutoModelForCausalLM
+_local_generator = None
+_local_lock = threading.Lock()
 
-model_name = "gpt2"
-save_path = "./models/gpt2"
 
-tokenizer = AutoTokenizer.from_pretrained(model_name)
-tokenizer.save_pretrained(save_path)
+def load_or_download_gpt2():
+    """
+    This function downloads GPT-2-medium into `/data/gpt2` on first run.
+    And on subsequent runs, it loads the saved local version.
+    """
+    
+    global _local_generator
+    if _local_generator is not None:
+        return _local_generator
+
+    with _local_lock:
+        if _local_generator is not None:
+            return _local_generator
+
+        # Ensure /data directory exists
+        os.makedirs(LOCAL_GPT2_DIR, exist_ok=True)
+
+        # Case 1: if local model already exists, load from storage...
+        if os.path.exists(LOCAL_GPT2_DIR) and os.listdir(LOCAL_GPT2_DIR):
+            print("\n🔵 Loading GPT-2 from /data/gpt2 (local cache)...")
+            tokenizer = AutoTokenizer.from_pretrained(LOCAL_GPT2_DIR)
+            model = AutoModelForCausalLM.from_pretrained(LOCAL_GPT2_DIR)
+            
+        else:
+            # Case 2: try download, and save
+            print("\n🟡 Downloading GPT-2-medium... (first run)")
+            tokenizer = AutoTokenizer.from_pretrained(REMOTE_GPT2_NAME)
+            model = AutoModelForCausalLM.from_pretrained(REMOTE_GPT2_NAME)
 
-model = AutoModelForCausalLM.from_pretrained(model_name)
-model.save_pretrained(save_path)
+            print("\n🟢 Saving GPT-2-medium to /data/gpt2...")
+            tokenizer.save_pretrained(LOCAL_GPT2_DIR)
+            model.save_pretrained(LOCAL_GPT2_DIR)
 
+        device = 0 if torch.cuda.is_available() else -1
+        _local_generator = pipeline(
+            "text-generation",
+            model=model,
+            tokenizer=tokenizer,
+            device=device,
+        )
+        print("\n\n✅ GPT-2 loaded and ready.")
+        return _local_generator
 
-# Load model (global) once startup.
+
+
+def generate_recipe_local(ingredient_names, max_new_tokens=300, temperature=0.9):
+    """
+    Local offline recipe generation with GPT-2-medium.
+    """
+    generate = load_or_download_gpt2()
+
+    prompt = (
+        f"You are an AI chef. Create a short recipe using only these ingredients: "
+        f"{', '.join(ingredient_names)}.\n\n"
+        "- Start with a recipe name on its own line.\n"
+        "- Then a one-sentence description.\n"
+        "- Then a bullet list of ingredients with approximate quantities.\n"
+        "- Then 6-10 concise numbered steps.\n"
+        "- Optionally one quick tip.\n\nRecipe:\n"
+    )
+
+    outputs = generate(prompt, do_sample=True, temperature=temperature,
+                  max_new_tokens=max_new_tokens, num_return_sequences=1)
+
+    recipe_text = outputs[0]["generated_text"]
+
+    if "Recipe:" in recipe_text:
+        recipe_text = recipe_text.split("Recipe:", 1)[1].strip()
+
+    return recipe_text.strip()
+
+
+
+# Load ingredients model once startup.
 MODEL_PATH = "models/ingredient_model.h5"
 MODEL = tf.keras.models.load_model(MODEL_PATH)
 
 # Class names
-# CLASS_NAMES = sorted(os.listdir("dataset/dataset_2/train"))
-CLASS_NAMES = [
-    'apple', 'banana', 'beetroot', 'bell pepper', 'cabbage', 'capsicum', 'carrot', 'cauliflower', 'chilli pepper', 
-     'corn', 'cucumber', 'eggplant', 'garlic', 'ginger', 'grapes', 'jalepeno', 'kiwi', 'lemon', 'lettuce', 'mango',
-     'onion', 'orange', 'paprika', 'pear', 'peas', 'pineapple', 'pomegranate', 'potato', 'raddish', 'soy beans', 
-     'spinach', 'sweetcorn', 'sweetpotato', 'tomato', 'turnip', 'watermelon']
+CLASS_NAMES = sorted(os.listdir("dataset/dataset_2/train"))
+print(CLASS_NAMES)
+# CLASS_NAMES = [
+#     'apple', 'banana', 'beetroot', 'bell pepper', 'cabbage', 'capsicum', 'carrot', 'cauliflower', 'chilli pepper', 
+#      'corn', 'cucumber', 'eggplant', 'garlic', 'ginger', 'grapes', 'jalepeno', 'kiwi', 'lemon', 'lettuce', 'mango',
+#      'onion', 'orange', 'paprika', 'pear', 'peas', 'pineapple', 'pomegranate', 'potato', 'raddish', 'soy beans', 
+#      'spinach', 'sweetcorn', 'sweetpotato', 'tomato', 'turnip', 'watermelon']
 
 # Infer uploaded image function
 def infer_image(pil_image):
     img = pil_image.resize((224, 224))
     IMG = np.expand_dims(np.array(img) / 255.0, axis=0)
-    
-    preds = MODEL.predict(IMG)[0]
 
+    preds = MODEL.predict(IMG)[0]
     top_idxs = np.argsort(preds)[::-1][:3]
     
     # ingredient list
     ingredients = []
-
     for i in top_idxs:
-        confidence = float(preds[i])
-        
         ingredients.append({
             "name": CLASS_NAMES[i].capitalize(),
-            "confidence": confidence
+            "confidence": float(preds[i])
         })
         
         # Limit to top 5 ingredients
         if len(ingredients) >= 5:
             break
-    
+
     # incase of no prediction.
     if not ingredients:
         return [{"name": "unknown", "confidence": 0.0}]
@@ -76,27 +146,6 @@ def infer_image(pil_image):
     return ingredients
 
 
-# Fallback Recipe Generator -> GPT-2
-def generate_recipe_local(ingredient_names):
-    ingredients = ", ".join(ingredient_names)
-    return f"""
-# Simple Local Fallback Recipe
-
-Since no API key was provided, here is a simple offline recipe.
-
-## Ingredients
-- {ingredients}
-
-## Steps
-1. Combine {ingredients} in a bowl.
-2. Add salt and seasoning as desired.
-3. Cook for 10 minutes.
-4. Serve warm.
-
-*(Generated locally without external AI models.)*
-""".strip()
-
-
 # initialize FastAPI app
 app = FastAPI(
     title="Fridge2Dish API",
@@ -118,6 +167,7 @@ app.add_middleware(
 )
 
 
+
 # ROUTES
 
 # Home Route
@@ -134,7 +184,6 @@ async def upload_image(
     ):
          
     try:
-        # check image file
         if not file.filename.lower().endswith((".jpg", ".jpeg", ".png")):
             raise HTTPException(status_code=400, detail="Invalid image format.")
 
@@ -148,24 +197,17 @@ async def upload_image(
         ingredients = infer_image(pil_img)
         end_time = time.time()
         
-        print(f"Ingredient detection took {end_time - start_time:.2f} seconds")
+        print(f"\nIngredient detection took {end_time - start_time:.2f} seconds")
         
-        print(f"Detected ingredients: {ingredients}")
+        print(f"\nDetected ingredients: {ingredients}")
         
-        if not ingredients:
-            return {"ingredients": [], 
-                    "recipe": "No ingredients detected, Try to take a clearer picture."}
-            
-            
         ingredient_names = [item["name"] for item in ingredients]
-        
-        
-        # Recipe generation using Gemini
-        # Get api key from user input
+
+
+        # Recipe generation using Gemini or GPT-2 fallback
         api_key = user_api_key.strip()
-            
+
         if api_key:
-            
             try:
                 # Try Gemini first...
                 genai.configure(api_key=api_key)
@@ -179,36 +221,25 @@ async def upload_image(
                 - Ingredients list with quantities
                 - 6-10 concise steps
                 - Optional fun tips or variations
-                Make it easy to follow and appetizing!
-
-                Do not include any lines like "Sure! Here's a recipe...", "Here's a simple..." or similar.
                 Return results in markdown format.
                 """
-                
-                print("\n\nTrying Gemini...")
+
                 response = model.generate_content(prompt)
                 recipe_text = response.text.strip()
-                # print(recipe_text)
-                
 
             except Exception as e1:
-                print("\nGemini failed. Falling to GPT-2:", e1)
+                print("\nGemini failed → switching to GPT-2:", e1)
                 recipe_text = generate_recipe_local(ingredient_names)
-                
+
         else:
-            # Since no api_key -> fallback to GPT-2
-            print("\n\nNo API key provided. Using GPT-2 to generate recipe")
+            print("\nNo API key provided → using GPT-2 fallback.")
             recipe_text = generate_recipe_local(ingredient_names)
-            
-        # results
-        return {
-                "ingredients": ingredients,
-                "recipe": recipe_text,
-            }
-        
-    except Exception as e2:
+
+        return {"ingredients": ingredients, "recipe": recipe_text}
+
+    except Exception as e:
         traceback.print_exc()
-        raise HTTPException(status_code=500, detail=f"Server Error: {str(e2)}")
+        raise HTTPException(status_code=500, detail=f"Server Error: {str(e)}")
 
 
 # Health check
@@ -219,4 +250,4 @@ def health():
 
 # Run app
 if __name__ == "__main__":
-    uvicorn.run(app, host="0.0.0.0", port=7860)   
+    uvicorn.run(app, host="0.0.0.0", port=7860)