Update FastAPI_app.py

FastAPI_app.py

@@ -1,5 +1,4 @@
 # FastAPI application for Fridge2Dish
-# Fallback: OpenChef-3B-v2 (GGUF) via llama-cpp-python
 
 # import libraries
 import os
@@ -18,29 +17,15 @@ from fastapi.templating import Jinja2Templates
 from fastapi.middleware.cors import CORSMiddleware
 
 # import ML libraries
+import torch
 import tensorflow as tf
 import google.generativeai as genai
+from transformers import AutoTokenizer, AutoModelForCausalLM, BitsAndBytesConfig
 
-# llama-cpp-python for GGUF fallback
 
-try:
-    from llama_cpp import Llama
-except Exception as e:
-    Llama = None
-    print("Warning: llama_cpp not available. Install llama-cpp-python to use local OpenChef fallback.", e)
 
 
-# -----------------------------
-# CONFIG — adjust this path
-# -----------------------------
-# Set LOCAL_GGUF_PATH to the path of your OpenChef-3B-v2 GGUF file that you've
-# uploaded into the repo/persistent storage. Example:
-# LOCAL_GGUF_PATH = "/data/OpenChef-3B-v2.Q4_K_M.gguf"
-#
-# Developer note: replace the value below with the actual uploaded file path.
-LOCAL_GGUF_PATH = "models/OpenChef-3B-v2.Q4_K_M.gguf"
-# -----------------------------
-
+# Configuration settings
 
 # Ingredient model (load once)
 MODEL_PATH = "models/ingredient_model.h5"
@@ -50,22 +35,84 @@ if not os.path.exists(MODEL_PATH):
 MODEL = tf.keras.models.load_model(MODEL_PATH)
 
 
-# Class names from train folder, otherwise manual.
+# Class names
 if os.path.isdir("dataset/dataset_2/train"):
     CLASS_NAMES = sorted(os.listdir("dataset/dataset_2/train"))
     
 else:
     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']
+        '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'
+    ]
+
+
+# Thread-safe lazy loading
+_lock = threading.Lock()
+_tokenizer = None
+_model = None
+
+def load_gemma2_2b():
+    global _tokenizer, _model
+    if _model is not None:
+        return _tokenizer, _model
+
+    with _lock:
+        if _model is not None:
+            return _tokenizer, _model
+
+        print("[Fallback] Loading Gemma-2-2B-it 4-bit (this takes ~20 seconds first time)...")
+        quantization_config = BitsAndBytesConfig(
+            load_in_4bit=True,
+            bnb_4bit_compute_dtype=torch.float16,
+            bnb_4bit_quant_type="nf4"
+        )
+
+        _tokenizer = AutoTokenizer.from_pretrained("google/gemma-2-2b-it", token=False)
+        _model = AutoModelForCausalLM.from_pretrained(
+            "google/gemma-2-2b-it",
+            device_map="auto",    
+            quantization_config=quantization_config,
+            torch_dtype=torch.float16,
+            trust_remote_code=True
+        )
+        print("[Fallback] Gemma-2-2B ready!")
+        return _tokenizer, _model
+
+def generate_recipe_gemma(ingredient_names):
+    tokenizer, model = load_gemma2_2b()
+    
+    prompt = f"""<start_of_turn>user
+        You are an AI chef. Create a short recipe using only: {', '.join(ingredient_names)}.
+        Include:
+        - Recipe name
+        - One-sentence description
+        - Ingredients list with quantities
+        - 6-10 concise steps
+        - Optional tips
+        RETURN RESULT IN MARKDOWN FORMAT ONLY.<end_of_turn>
+        <start_of_turn>model
+        """
+
+    inputs = tokenizer(prompt, return_tensors="pt")
+    outputs = model.generate(
+        inputs.input_ids,
+        max_new_tokens=512,
+        temperature=0.8,
+        top_p=0.9,
+        do_sample=True
+    )
+    recipe_text = tokenizer.decode(outputs[0], skip_special_tokens=True)
+    # Strip the prompt part
+    return recipe_text.split("<start_of_turn>model")[-1].strip()
 
 
 # Infer uploaded image function
 def infer_image(pil_image):
     """
-    Returns a list of dicts: [{ "name": CapitalizedName, "confidence": 0.xx }, ...]
+    Returns a list of dicts: [{ "name": ing_1, "confidence": 0.xx }, ...]
     """
     img = pil_image.resize((224, 224))
     arr = np.expand_dims(np.array(img) / 255.0, axis=0)
@@ -73,106 +120,12 @@ def infer_image(pil_image):
     top_idxs = np.argsort(preds)[::-1][:5]
     ingredients = []
     for i in top_idxs:
-        ingredients.append({
-            "name": CLASS_NAMES[i].capitalize(),
-            "confidence": float(preds[i])
-        })
+        ingredients.append({"name": CLASS_NAMES[i].capitalize(), "confidence": float(preds[i])})
+
     if not ingredients:
         return [{"name": "Unknown", "confidence": 0.0}]
-    return ingredients
-
-
-# Protect loading by locking.
-_llama_lock = threading.Lock()
-_llama_model = None
-
-
-def load_local_openchef():
-    """Load the OpenChef GGUF via llama-cpp-python. Thread-safe and cached."""
-    global _llama_model
-    if _llama_model is not None:
-        return _llama_model
-
-    if Llama is None:
-        raise RuntimeError("llama_cpp is not installed. Install 'llama-cpp-python' to use local OpenChef fallback.")
-
-    with _llama_lock:
-        if _llama_model is not None:
-            return _llama_model
-
-        if not os.path.exists(LOCAL_GGUF_PATH):
-            # be explicit about missing model
-            raise FileNotFoundError(
-                f"Local OpenChef GGUF not found at {LOCAL_GGUF_PATH}. "
-                "Place the .gguf file there or update LOCAL_GGUF_PATH."
-            )
-
-        # instantiate; adjust n_ctx if needed
-        print(f"[openchef] Loading GGUF model from {LOCAL_GGUF_PATH} ...")
-        _llama_model = Llama(model_path=LOCAL_GGUF_PATH, n_ctx=2048)
-        print("[openchef] Loaded.")
-        return _llama_model
-
-
-def generate_recipe_local_openchef(ingredient_names: list, max_tokens: int = 512, temperature: float = 0.7):
-    """
-    Generate a markdown recipe using the local OpenChef (GGUF).
-    Returns plain text (markdown).
-    """
-    llama = load_local_openchef()
 
-    # clean ingredient list string
-    ing_str = ", ".join(ingredient_names)
-
-    prompt = f"""You are a concise AI chef. Use ONLY these ingredients: {ing_str}
-
-Rules:
-- Title on one line.
-- One-sentence description.
-- "### Ingredients" followed by a bullet list with approximate quantities.
-- "### Steps" followed by 6-8 numbered concise steps.
-- Optionally a "Tip:" line at the end.
-- No extra commentary, no apologias. Return only the recipe in markdown.
-
-Recipe:
-"""
-
-    # llama-cpp-python returns dict with 'choices' etc or direct text depending on version
-    # Use completion with stop tokens to keep output concise.
-    try:
-        resp = llama.create(
-            prompt=prompt,
-            max_tokens=max_tokens,
-            temperature=temperature,
-            top_p=0.95,
-            stop=["\n\n\n"]
-        )
-    except TypeError:
-        # older/newer llama-cpp-python API differences
-        resp = llama(prompt, max_tokens=max_tokens, temperature=temperature)
-
-    # extract text
-    # resp may be dict-like: {'choices': [{'text': '...'}], ...}
-    text = ""
-    try:
-        if isinstance(resp, dict) and "choices" in resp:
-            # new style
-            text = resp["choices"][0].get("text", "").strip()
-        elif hasattr(resp, "choices"):
-            text = resp.choices[0].text.strip()
-        elif isinstance(resp, str):
-            text = resp.strip()
-        else:
-            # fallback, str conversion
-            text = str(resp).strip()
-    except Exception:
-        text = str(resp).strip()
-
-    # sanity clean: if the model repeated the prompt, strip it
-    if text.startswith("Recipe:"):
-        text = text.split("Recipe:", 1)[1].strip()
-
-    return text
+    return ingredients
 
 
 # initialize FastAPI app
@@ -182,7 +135,7 @@ app = FastAPI(
     version="3.0.0"
 )
 
-# static/templates
+# static and templates
 app.mount("/static", StaticFiles(directory="static"), name="static")
 templates = Jinja2Templates(directory="templates")
 
@@ -195,32 +148,22 @@ app.add_middleware(
     allow_headers=["*"],
 )
 
-
-
-# ROUTES
-
-# Home Route
+# Home route
 @app.get("/", response_class=HTMLResponse)
 def home(request: Request):
     return templates.TemplateResponse("index.html", {"request": request})
 
 
-# upload-image route
+# Upload-image route
 @app.post("/upload-image/")
-async def upload_image(
-    file: UploadFile = File(...),
-    user_api_key: str = Form(alias="api_key", default="")
-    ):
-         
+async def upload_image(file: UploadFile = File(...), user_api_key: str = Form(alias="api_key", default="")):
     try:
-        if not file.filename.lower().endswith((".jpg", ".jpeg", ".png")):
+        if not file.filename.lower().endswith((".jpg", ".jpeg", ".png", ".webp", ".gif")):
             raise HTTPException(status_code=400, detail="Invalid image format.")
 
-        # load image
         img_bytes = await file.read()
         pil_img = Image.open(io.BytesIO(img_bytes)).convert("RGB")
 
-        # detect ingredients
         start = time.time()
         ingredients = infer_image(pil_img)
         end = time.time()
@@ -232,11 +175,10 @@ async def upload_image(
         api_key = (user_api_key or "").strip()
 
         if api_key:
-            # try Gemini first
             try:
                 genai.configure(api_key=api_key)
-                model = genai.GenerativeModel("gemini-2.5-flash")
-                
+                model = genai.GenerativeModel("gemini-1.5-pro")
+
                 prompt = f"""
                 You are an AI chef. Create a short recipe using only: {', '.join(ingredient_names)}.
                 Include:
@@ -244,43 +186,39 @@ async def upload_image(
                 - One-sentence description
                 - Ingredients list with quantities
                 - 6-10 concise steps
-                - Optional fun tips or variations
-                Return results in markdown format.
+                - Optional tips
+                RETURN RESULT IN MARKDOWN FORMAT ONLY.
                 """
-                
+
                 print("Trying Gemini...")
                 response = model.generate_content(prompt)
                 recipe_text = response.text.strip()
-                print("\nGemini succeeded.")
-                
+                print("Gemini succeeded.")
+
             except Exception as e_gemini:
-                print("\nGemini failed:", e_gemini)
-                # fallback to local OpenChef
+                print("Gemini failed:", e_gemini)
                 try:
-                    recipe_text = generate_recipe_local_openchef(ingredient_names)
-                except Exception as e_local:
-                    print("\nLocal OpenChef failed:", e_local)
-                    raise e_local
+                    recipe_text = generate_recipe_gemma(ingredient_names)
+                except Exception as e_local1:
+                    print("Gemma local failed:", e_local1)
+                    raise e_local1
 
         else:
-            # no API key: use local OpenChef fallback
             try:
-                print("\nNo API key provided —> Using local OpenChef fallback.")
-                recipe_text = generate_recipe_local_openchef(ingredient_names)
-            except Exception as e_local:
-                print("Local OpenChef failed:", e_local)
-                raise e_local
+                print("No API key → Using Gemma fallback.")
+                recipe_text = generate_recipe_gemma(ingredient_names)
+            except Exception as e_local2:
+                print("Gemma local failed:", e_local2)
+                raise e_local2
 
         return {"ingredients": ingredients, "recipe": recipe_text}
 
     except HTTPException:
-        # re-raise known HTTP errors
         raise
     except Exception as e:
         traceback.print_exc()
-        raise HTTPException(status_code=500, detail=f"Server Error: {str(e)}")
-
-
+        
+        
 # Health check
 @app.get("/health")
 def health():
@@ -289,4 +227,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)