amitbenavraham/fitfuel-recipes

🥗 FitFuel — AI-Powered Nutrition & Fitness Recipe App

Try the live app: https://huggingface.co/spaces/amitbenavraham/fitfuel-app

A synthetic recipe dataset and semantic recommendation pipeline, built for a fitness nutrition application.

📓 Project Notebook

The full project notebook (data generation, cleaning, EDA, embeddings, vision/generation, and application code) is available here: FitFuel Final Project.ipynb

📋 Project Overview

FitFuel is an end-to-end AI application built for the Introduction to Data Science course (Reichman University). It recommends recipes based on fitness goals (bulking / cutting / maintenance), dietary restrictions, and allergens — either from a free-text query or from a photo of your fridge or pantry, using computer vision to detect ingredients automatically.

Content generated by	Groq API (llama-3.1-8b-instant), Pydantic-validated
Method	Fully synthetic recipes spanning goal x meal type x cuisine x difficulty
Final clean dataset	10,790 recipes
Embedding model	GTE-small (384-dim), selected after a 3-model benchmark
Vision model	SmolVLM-500M-Instruct (fridge/pantry photo -> ingredient list)
Generation model	Qwen2.5-0.5B-Instruct (recipe-fit explanations)
Application	Gradio, deployed on a Hugging Face Space (ZeroGPU)

This repository hosts the underlying dataset, EDA, and embeddings. The full pipeline (data generation → EDA → embeddings → vision/generation → app) is documented below.

Disclaimer: This app is for educational, non-medical use. Calorie and macro values are AI-generated estimates, not verified nutritional or medical data. Always consult a registered dietitian or healthcare professional before making significant changes to your diet.

---

📦 Part 1 — Synthetic Data Generation

10,790 recipes generated via the Groq API (llama-3.1-8b-instant) with Pydantic schema validation, spanning every combination of goal / meal type / cuisine / difficulty, with checkpointing against API rate limits (SEED=42 for reproducibility).

📊 Part 2 — Dataset & EDA

Columns

Column	Description
recipe_name	Recipe title
ingredients	List of ingredient strings
instructions	Free-text cooking instructions
calories, protein_g, carbs_g, fat_g	AI-estimated nutrition values
goal_tag	bulking / cutting / maintenance
meal_type	breakfast / lunch / dinner / snack
difficulty	beginner / intermediate / advanced
prep_time_min	Estimated prep time in minutes
cuisine	Cuisine category
allergen_tags_model_raw	LLM-generated allergen tags (unreliable — kept for audit only)
allergen_tags_final	✅ Use this one. Deterministic, regex-based allergen tags
is_vegan, is_vegetarian, is_pescatarian, diet_tag	Deterministic dietary classification
calories_implied, calorie_diff, calorie_diff_pct	Macro-implied vs. stated calories, for transparency
source_model	Which LLM generated the row

✅ Domain-logic sanity checks (passed)

• goal_tag correlates with calories as expected: cutting (309 kcal) < maintenance (354 kcal) < bulking (518 kcal).
• difficulty correlates with prep time as expected: beginner (19.7 min) < intermediate (22.0 min) < advanced (23.9 min).

📈 EDA Visualizations

(click any chart to view full-size)

Model vs. Deterministic Lexicon Allergen Agreement

Compares allergen tags the LLM generated on its own against a deterministic, ingredient-based lexicon. Only ~41% matched exactly, and the model both missed real allergens and flagged ones that weren't actually there — which is why the app relies on the lexicon-based allergen_tags_final column instead.

Allergen Tag Frequency (Deterministic Lexicon)

Shows how often each allergen (dairy, gluten, nuts, eggs, soy, shellfish) appears across the 10,790 recipes, based on the reliable deterministic tags.

Stated Calories vs. Macro-Implied Calories

Checks whether each recipe's stated calorie count matches what its own protein/carbs/fat numbers imply (4·protein + 4·carbs + 9·fat). About 80% of recipes are off by more than 10 kcal in one direction or the other — expected noise from LLM-generated nutrition data, not a single systematic bias.

Dietary Tag Distribution

Breaks down the dataset by diet (vegan / vegetarian / pescatarian / omnivore), and shows how the usable recipe pool shrinks as dietary restrictions get stricter.

Recipe Count by Goal × Meal Type (Grid Coverage)

Checks that recipes are reasonably spread across every combination of goal, meal type, cuisine, and difficulty. Most of the 216 possible combinations are covered; 27 have zero recipes, which is why the recommender has a fallback that relaxes one filter at a time instead of returning nothing.

Domain-Logic Sanity Checks

A basic reality check: recipes tagged "bulking" should have more calories than "cutting" recipes, and "advanced" recipes should take longer to prepare than "beginner" ones. Both hold true in the data, confirming the tags behave the way you'd expect.

---

🧠 Part 3 — Recommendation with Embeddings

Embedding model selection

Three models were benchmarked on load time, encode time, and retrieval quality across the full 10,790-recipe dataset (all produce 384-dimensional embeddings, so storage cost is identical):

Model	Load time	Encode time	Throughput	Avg. top-3 similarity
MiniLM (all-MiniLM-L6-v2)	10.8s	5.9s	~1,830 recipes/sec	0.46 - 0.62
BGE-small (bge-small-en-v1.5)	10.8s	8.8s	~1,225 recipes/sec	0.71 - 0.84
GTE-small (gte-small) ✅ SELECTED	9.6s	3.6s	~3,000 recipes/sec	0.86 - 0.92

GTE-small won on every metric — fastest and highest quality, with zero storage tradeoff since all three share the same embedding dimension.

What we learned while testing: embeddings are great at finding recipes that sound similar to a query, but they're not reliable at enforcing hard rules. For example, searching "vegan dinner" could still return a chicken dish, because the model just sees it as a similar-sounding dinner recipe — it doesn't actually know or enforce the definition of "vegan". Because of this, FitFuel never lets the AI decide what's allowed or not: allergens, diet, goal, and meal type are all filtered out first using plain rule-based code, and only then does the AI rank what's left by how well it matches the query. This way, a user with a nut allergy can never end up with a nut-containing recipe, no matter what the embedding model "thinks" is similar.

Speed Benchmark

GTE-small was the fastest model to both load (9.6s) and encode all 10,790 recipes (3.6s), beating MiniLM (10.8s / 5.9s) and more than doubling BGE-small's encode speed (10.8s / 8.8s).

Similarity Score Comparison

For 3 realistic test queries, GTE-small consistently returned the closest matching recipes (highest similarity score), with its lead growing on more specific, multi-part queries like "low calorie asian lunch for cutting".

PCA Embedding Projection

Squashes each recipe's 384-dimensional embedding down to 2D so it can be plotted, colored by fitness goal. The goal groups overlap heavily — confirming that the embedding space organizes recipes by culinary similarity, not by nutritional goal, which is exactly why goal_tag is enforced separately through deterministic filtering rather than relying on the embeddings.

Sanity Check Results

Six real-world scenarios were tested end-to-end (a normal request, asking for another suggestion, allergen filtering, an over-constrained request that should trigger a fallback, an almost-impossible combination, and an invalid input) — all six passed, confirming the pipeline never crashes and never silently ignores a safety-relevant constraint.

Top-5 Recommendations Demo

A real example: searching "high protein dinner" (goal=bulking, meal=dinner, excluding nuts) returns 5 closely-scored, all meat-based dinner recipes — showing the deterministic filter narrows things down to a coherent, relevant pool before the AI ranks them.

Recommendation pipeline

USER INPUT → deterministic filter (allergens/diet/goal/meal/time/difficulty) → GTE-small query encoding → cosine similarity ranking → top-k AI OUTPUT, with automatic constraint-relaxation fallback (allergen/diet constraints are never relaxed).

Why not FAISS? At 10,790 recipes, brute-force cosine similarity (np.dot) completes in milliseconds — FAISS targets million-scale datasets and would add dependency overhead with no measurable benefit here.

---

🖼️ Part 4 — Vision & Generative AI

FitFuel goes beyond text search: upload a photo of your fridge or pantry and the app identifies your ingredients automatically.

Vision pipeline

1. Blur detection — Laplacian-variance sharpness check gracefully rejects unusable photos before wasting a model call ("please retake with more light and hold the camera steady").
2. Ingredient extraction — HuggingFaceTB/SmolVLM-500M-Instruct (a compact vision-language model) lists visible food items from the image.
3. Output cleaning — regex-based parsing deduplicates items, strips hallucinated long phrases, and normalizes casing; generation uses repetition_penalty + no_repeat_ngram_size to prevent repetition loops.
4. Empty-result fallback — if no ingredients are recognized, the user gets a clear, friendly message instead of a crash.
5. Recipe matching — detected ingredients become the query text fed into the same Part 3 recommendation engine.

Generative blurb writer

Qwen/Qwen2.5-0.5B-Instruct writes a short, encouraging one-line explanation of why each recommended recipe fits the user's fitness goal (max 20 words, explicitly instructed to avoid medical claims). Runs on CPU by design — it's a lightweight model that doesn't need GPU.

Verified with sanity checks

• ✅ Clear fridge photo → correct ingredient list → relevant recipe match
• ✅ Artificially blurred photo → blur check correctly triggers the graceful fallback message instead of attempting (and failing) extraction

---

🚀 Part 5 — The FitFuel Application

Live app: https://huggingface.co/spaces/amitbenavraham/fitfuel-app (Gradio, deployed on a ZeroGPU Hugging Face Space)

Features

• 💬 Text-based recommendations — describe what you want ("high protein dinner") with filters for goal, meal type, allergens, and diet
• 📷 Photo-based recommendations — snap your fridge/pantry, get a recipe built from what you actually have
• 🔄 "Show me another" — re-roll excludes previously shown recipes
• 🧮 Daily macro calculator — personalized calorie/protein/carb/fat targets from sex, age, height, weight, activity level, and goal
• 📝 Macro logging — track meals against daily targets
• ⚡ Quick-start suggestion chips — one-tap example queries
• 🎨 Custom green/blue FitFuel branding — gradient theme, rounded cards, branded logo header, built with Gradio's themes.Soft + custom CSS

Tech stack

Gradio UI · SentenceTransformers (GTE-small) for retrieval · transformers (SmolVLM-500M-Instruct for vision, Qwen2.5-0.5B-Instruct for text generation) · OpenCV for blur detection · pandas / numpy for data handling · plotly / matplotlib for in-app charts · deployed on a Hugging Face Space (ZeroGPU hardware)

---

⚠️ Known Limitations

• Allergen tags in allergen_tags_model_raw are unreliable: only ~41% exact agreement with a deterministic ingredient-based lexicon. Always use allergen_tags_final for any filtering — never the raw model output.
• Calorie/macro consistency is noisy: stated vs. macro-implied calories (4·protein + 4·carbs + 9·fat) disagree by more than 10 kcal in ~80% of rows. Treat calorie/macro values as estimates, not precise figures.
• Grid coverage gap: of 216 possible (goal × meal × cuisine × difficulty) combinations, 27 have zero recipes — the recommender falls back to relaxing one dimension rather than returning no results.
• Embeddings don't enforce hard dietary rules: semantic similarity alone can surface a recipe that doesn't actually meet a stated constraint (e.g. a "vegan" query returning meat dishes). This is why allergen/diet/goal/meal filtering always runs as deterministic code before the AI ranks results — never as something the embedding model is trusted to enforce on its own.
• Recipe names are ~95% unique — duplicate names can refer to different recipes.
• The vision pipeline (SmolVLM-500M-Instruct) is a compact model chosen for speed on free-tier hardware; it can miss less-visible or partially obscured ingredients in a fridge/pantry photo.

🎯 Intended Use

This dataset and pipeline power an educational fitness-nutrition recommender. It is intended for building and testing recommendation systems, evaluating embedding models, and exploring synthetic data generation — not as a verified nutritional database or a substitute for professional dietary advice.

📁 Files in this repository

• fitfuel_recipes_clean.parquet — cleaned recipe dataset (10,790 rows)
• embeddings/fitfuel_embeddings_gte_small.npy — precomputed GTE-small embeddings (384-dim, normalized)
• embeddings/fitfuel_embeddings_index.csv — row index aligning embeddings to recipes
• images/ — all EDA and Part 3 chart PNGs
• FitFuel Final Project.ipynb — full notebook (Parts 1-3: generation, EDA, embeddings)

📄 License

CC-BY-4.0

Authors: Daniel Halali & Amit Ben-Avraham | Reichman University | Introduction to Data Science | 2026

🤖 AI Usage Disclosure

This project was completed with assistance from Claude (Anthropic) for code debugging, chart design, and README writing. All analysis, decisions, and interpretations are our own.