Upload 6 files

DEPLOY_GUIDE.md

@@ -0,0 +1,79 @@
+# Deploying Bio-Bite to a Hugging Face Space
+
+## 1. Create the Space
+
+1. Go to [huggingface.co](https://huggingface.co) → profile picture → **New Space**
+2. **Space name:** `bio-bite` (owner: `benjac8`)
+3. **License:** MIT
+4. **SDK:** **Gradio**
+5. **Hardware:** **ZeroGPU** ⚠️ *this is the important one* — the free CPU tier is far too slow for a 3B model
+6. **Visibility:** Public
+7. Create
+
+> ZeroGPU is free but requires a verified email and an account older than 30 days, with a limit of 2 ZeroGPU Spaces per free account. If ZeroGPU isn't offered, see *Troubleshooting* below.
+
+## 2. Upload the four files
+
+**Files** tab → **Add file → Upload files**, then drag in all of these:
+
+| File | Size | Purpose |
+|---|---|---|
+| `app.py` | 13 KB | The application |
+| `requirements.txt` | <1 KB | Dependencies |
+| `README.md` | 3 KB | Space card (its YAML header configures the Space) |
+| `biobite_embeddings.parquet` | 22 MB | Precomputed embeddings (uploads via Git LFS automatically) |
+| `recovery_guidance.json` | 2 KB | The coded recovery science |
+
+Commit. The Space will start building — watch the **Logs** tab.
+
+First build takes ~5–10 minutes (installing torch/transformers, then downloading the models on first run).
+
+## 3. Optional: the live-data bonus
+
+**Settings → Variables and secrets → New secret**
+
+- Name: `SPOONACULAR_API_KEY`
+- Value: your free key from [spoonacular.com/food-api](https://spoonacular.com/food-api)
+
+The app then shows a real photo of the generated dish. Without the key it simply skips the image — nothing breaks.
+
+## 4. Test it
+
+Click a **Quick Starter**, then **Generate My Bio-Bite**. Expect ~15–25 seconds for the first response (model warm-up), faster afterwards.
+
+Verify:
+
+- [ ] 3 recipe cards appear with sensible macros
+- [ ] The detected recovery state matches the description
+- [ ] The generated recipe respects the constraint (e.g. no salmon when you said "no salmon")
+- [ ] "Why this works" mentions relevant nutrients
+- [ ] Tomorrow's plan has timed bullets
+- [ ] Disclaimer is visible
+
+## 5. Submit
+
+Put both links on Moodle:
+
+- **Dataset:** `https://huggingface.co/datasets/benjac8/bio-bite-recovery-nutrition`
+- **Space:** `https://huggingface.co/spaces/benjac8/bio-bite`
+
+---
+
+## Troubleshooting
+
+**Build fails on `spaces` import** — that's normal locally; on a ZeroGPU Space the package is preinstalled. If you're on CPU hardware, the app falls back automatically (just slowly).
+
+**"GPU quota exceeded"** — the free ZeroGPU allowance is ~5 minutes of GPU time per day (roughly 15–20 requests). Don't burn it on casual testing; save it for the demo. It resets daily.
+
+**Out of memory** — reduce `max_new_tokens` in `app.py` (760 → 500), or switch `GEN_MODEL` to `Qwen/Qwen2.5-1.5B-Instruct` (note: it failed JSON validation in benchmarking, so quality will drop).
+
+**Model returns unexpected format** — the app catches this and asks the user to press again. It's occasional and expected with sampling; pressing again resolves it.
+
+**Slow first request** — the models download on first run (~6 GB). Subsequent requests are much faster. Warm the Space up a few minutes before presenting.
+
+## Demo-day checklist
+
+- Open the Space ~10 minutes early and run one query to warm it up
+- Have the dataset page open in a second tab
+- Know your headline numbers: 10,000 rows · precision@3 = 0.806 · 3 embedding models compared · 3 generators benchmarked
+- Be ready to explain: *why the science is coded rather than generated*, and *why the 3B model was both faster and more reliable than the smaller ones*

README.md

@@ -1,13 +1,59 @@
 ---
-title: Bio Bite
-emoji: ⚡
-colorFrom: red
-colorTo: red
+title: Bio-Bite Recovery Nutrition Engine
+emoji: 🥗
+colorFrom: green
+colorTo: blue
 sdk: gradio
-sdk_version: 6.22.0
-python_version: '3.12'
+sdk_version: 5.9.1
 app_file: app.py
 pinned: false
+license: mit
+short_description: Turn wearable recovery data into a meal and a next-day plan
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# 🥗 Bio-Bite — Recovery Nutrition Engine
+
+Your smartwatch tells you that you slept 5 hours and hit a strain of 18/21. **So what should you eat?**
+
+Bio-Bite closes the gap between *seeing* your recovery numbers and *knowing what to do with them*. Describe your day in plain language and it returns three matched recovery meals, one brand-new recipe adapted to what's actually in your fridge, the science behind it, and a plan for tomorrow.
+
+## How it works
+
+```
+USER INPUT (free text + wearable numbers)
+        ↓
+  route to 1 of 6 recovery states   (majority vote over retrieved rows)
+        ↓
+  embed query → FAISS search over 10,000 recipes
+        ↓
+  3 recommended recipes  +  RAG generation
+        ↓
+AI OUTPUT: new recipe · why it works · tomorrow's plan
+```
+
+| Component | Choice | Why |
+|---|---|---|
+| **Dataset** | [`benjac8/bio-bite-recovery-nutrition`](https://huggingface.co/datasets/benjac8/bio-bite-recovery-nutrition) — 10,000 rows | Read live from the Hub |
+| **Embeddings** | `BAAI/bge-small-en-v1.5` | Won a 3-model comparison: **precision@3 = 0.806** vs 0.759 (MiniLM) and 0.676 (E5) |
+| **Search** | FAISS `IndexFlatIP` on normalised vectors | Cosine similarity, fast enough for live use |
+| **Generation** | `Qwen/Qwen2.5-3B-Instruct` | Benchmarked fastest (15.4s) **and** the only candidate producing valid JSON |
+
+### Grounded, not hallucinated
+
+The recovery science is **encoded in code**, not invented by the model. Each of the 6 recovery states maps to fixed, evidence-based guidance (protein for muscle repair, carbohydrate for glycogen, magnesium for sleep, electrolytes for rehydration). The language model only *phrases* the recipe and the plan — it cannot contradict the physiology.
+
+## Files
+
+- `app.py` — the Gradio application (retrieval + generation)
+- `biobite_embeddings.parquet` — 10,000 × 384 precomputed embeddings
+- `recovery_guidance.json` — the coded recovery science
+
+## Optional: live dish photos
+
+Set a `SPOONACULAR_API_KEY` secret in the Space settings to fetch a real photo of the generated dish. The app works fine without it.
+
+---
+
+⚠️ **Educational prototype — not medical, nutritional or training advice.** The dataset is synthetic (generated by a language model) and has not been reviewed by a registered dietitian. Consult a qualified professional for personal guidance.
+
+*Built for the Intro to Data Science final project, Reichman University.*

app.py

@@ -0,0 +1,377 @@
+"""
+Bio-Bite — Recovery Nutrition Engine
+====================================
+Reads the recovery data your smartwatch already collects (strain, sleep, HRV)
+and turns it into a personalized recovery meal and a next-day plan.
+
+Pipeline:  USER INPUT -> embed -> FAISS top-3 -> RAG generation -> AI OUTPUT
+
+- Dataset  : read directly from the Hugging Face Dataset repo
+- Embedder : BAAI/bge-small-en-v1.5 (winner of a 3-model comparison, P@3 = 0.806)
+- Generator: Qwen/Qwen2.5-3B-Instruct (fastest AND only model producing valid JSON)
+"""
+
+import json
+import os
+import re
+
+import faiss
+import gradio as gr
+import numpy as np
+import pandas as pd
+import torch
+from datasets import load_dataset
+from sentence_transformers import SentenceTransformer
+from transformers import pipeline
+
+# ZeroGPU support (falls back gracefully when running locally / on CPU)
+try:
+    import spaces
+    ZERO_GPU = True
+except ImportError:  # local run
+    ZERO_GPU = False
+
+    class _Dummy:
+        @staticmethod
+        def GPU(*a, **k):
+            def deco(fn):
+                return fn
+            return deco
+    spaces = _Dummy()
+
+# --------------------------------------------------------------------------
+# Configuration
+# --------------------------------------------------------------------------
+SEED = 42
+HF_DATASET = "benjac8/bio-bite-recovery-nutrition"
+EMBED_MODEL = "BAAI/bge-small-en-v1.5"
+QUERY_PREFIX = "Represent this sentence for searching relevant passages: "
+GEN_MODEL = "Qwen/Qwen2.5-3B-Instruct"
+EMB_FILE = "biobite_embeddings.parquet"
+GUIDANCE_FILE = "recovery_guidance.json"
+SPOONACULAR_KEY = os.environ.get("SPOONACULAR_API_KEY", "")
+
+np.random.seed(SEED)
+torch.manual_seed(SEED)
+
+# --------------------------------------------------------------------------
+# Load data, index and models (once, at startup)
+# --------------------------------------------------------------------------
+print("Loading dataset from Hugging Face…")
+df = load_dataset(HF_DATASET, split="train").to_pandas()
+
+print("Loading embeddings…")
+doc_emb = pd.read_parquet(EMB_FILE).to_numpy().astype("float32")
+index = faiss.IndexFlatIP(doc_emb.shape[1])
+index.add(doc_emb)
+
+with open(GUIDANCE_FILE) as fh:
+    NEXT_DAY_GUIDANCE = json.load(fh)
+
+print("Loading models…")
+embedder = SentenceTransformer(EMBED_MODEL)
+generator = pipeline(
+    "text-generation",
+    model=GEN_MODEL,
+    torch_dtype=torch.float16 if torch.cuda.is_available() else torch.float32,
+    device_map="auto" if torch.cuda.is_available() else None,
+)
+generator.tokenizer.pad_token_id = generator.tokenizer.eos_token_id
+print(f"Ready — {len(df)} recipes indexed.")
+
+
+# --------------------------------------------------------------------------
+# Retrieval
+# --------------------------------------------------------------------------
+def retrieve(user_text, k=3, diet=None, max_prep=None, pool=250):
+    """Top-k recovery recipes for a free-text description of the user's day."""
+    q = embedder.encode(
+        [QUERY_PREFIX + user_text], convert_to_numpy=True, normalize_embeddings=True
+    ).astype("float32")
+    scores, idx = index.search(q, pool)
+    cand = df.iloc[idx[0]].copy()
+    cand["similarity"] = scores[0]
+    if diet and diet != "Any":
+        cand = cand[cand["diet_tag"] == diet]
+    if max_prep:
+        cand = cand[cand["Prep_Time"] <= max_prep]
+    if len(cand) == 0:  # filters too strict -> fall back to unfiltered
+        cand = df.iloc[idx[0]].copy()
+        cand["similarity"] = scores[0]
+    return cand.head(k)
+
+
+def infer_recovery_category(user_text, k=7):
+    """Route free text to a recovery state by majority vote over retrieved rows."""
+    return retrieve(user_text, k=k)["recovery_category"].mode().iloc[0]
+
+
+# --------------------------------------------------------------------------
+# Generation (single combined call keeps latency ~15s within ZeroGPU quota)
+# --------------------------------------------------------------------------
+PROMPT = """You are an expert sports-nutrition dietitian and recovery coach.
+
+The athlete describes their day as: "{state}" ({numbers})
+Their recovery goal is: {category}
+Nutritional need: {need}
+
+A recommended recipe from our database, to use as inspiration:
+- Name: {name}
+- Ingredients: {ingredients}
+- Prep time: {prep} minutes
+
+The athlete now says: "{constraint}"
+
+Evidence-based recovery guidance you MUST follow (do not contradict it):
+- Training tomorrow: {training}
+- Nutrition tomorrow: {nutrition}
+- Sleep tonight: {sleep}
+
+Adapt the recipe into a NEW dish that respects the athlete's request while still
+meeting the nutritional need. Then write tomorrow's recovery plan.
+Write in ENGLISH only.
+Reply with ONE valid JSON object and NOTHING else, with exactly these keys:
+- "Recipe_Name": string (an original name for the new dish)
+- "Ingredients": string (comma-separated)
+- "Instructions": string (numbered steps)
+- "prep_time_min": integer
+- "why_it_works": string (2-3 sentences naming the key nutrients and the
+  mechanism, e.g. protein for muscle repair, magnesium for sleep quality)
+- "next_day_plan": string (5 bullet points, each starting with a clock time like
+  "07:30 - ", covering hydration, meals, training or rest, and a bedtime target;
+  max 18 words per bullet, separated by newlines)
+"""
+
+REQUIRED_KEYS = ["Recipe_Name", "Ingredients", "Instructions",
+                 "prep_time_min", "why_it_works", "next_day_plan"]
+
+
+@spaces.GPU(duration=110)
+def generate_biobite(source_row, state, constraint, category, numbers):
+    """RAG generation: retrieved recipe + coded science -> new recipe + plan."""
+    g = NEXT_DAY_GUIDANCE[category]
+    prompt = PROMPT.format(
+        state=state, numbers=numbers, category=category,
+        need=source_row["Nutritional_Need"], name=source_row["Recipe_Name"],
+        ingredients=source_row["Ingredients"], prep=source_row["Prep_Time"],
+        constraint=constraint, training=g["training"],
+        nutrition=g["nutrition"], sleep=g["sleep"],
+    )
+    out = generator(
+        [{"role": "user", "content": prompt}],
+        max_new_tokens=760, do_sample=True, temperature=0.7, top_p=0.9,
+        pad_token_id=generator.tokenizer.eos_token_id,
+    )
+    raw = out[0]["generated_text"][-1]["content"]
+
+    m = re.search(r"\{.*\}", raw, re.DOTALL)
+    if not m:
+        return None
+    try:
+        obj = json.loads(m.group(0))
+    except json.JSONDecodeError:
+        return None
+    if any(k not in obj for k in REQUIRED_KEYS):
+        return None
+    if isinstance(obj["Ingredients"], list):
+        obj["Ingredients"] = ", ".join(map(str, obj["Ingredients"]))
+    if isinstance(obj["next_day_plan"], list):
+        obj["next_day_plan"] = "\n".join(map(str, obj["next_day_plan"]))
+    return obj
+
+
+# --------------------------------------------------------------------------
+# Bonus: fetch a real dish photo from a live recipe API
+# --------------------------------------------------------------------------
+def fetch_dish_image(recipe_name):
+    """Live-data bonus. Returns an image URL or None (never breaks the app)."""
+    if not SPOONACULAR_KEY:
+        return None
+    try:
+        import requests
+        r = requests.get(
+            "https://api.spoonacular.com/recipes/complexSearch",
+            params={"query": recipe_name, "number": 1, "apiKey": SPOONACULAR_KEY},
+            timeout=6,
+        )
+        hits = r.json().get("results", [])
+        return hits[0].get("image") if hits else None
+    except Exception:
+        return None
+
+
+# --------------------------------------------------------------------------
+# HTML rendering
+# --------------------------------------------------------------------------
+def cards_html(rows):
+    cards = []
+    for _, r in rows.iterrows():
+        cards.append(f"""
+        <div style="flex:1;min-width:210px;border:1px solid #e3e3e3;border-radius:12px;
+                    padding:14px;background:#fff;">
+          <div style="font-size:11px;text-transform:uppercase;letter-spacing:.5px;
+                      color:#888;">{r['recovery_category']}</div>
+          <div style="font-weight:600;font-size:15px;margin:6px 0 10px;">
+            {r['Recipe_Name']}</div>
+          <div style="font-size:12px;color:#555;line-height:1.7;">
+            ⏱ {r['Prep_Time']} min &nbsp;·&nbsp; 🔥 {r['calories']} kcal<br>
+            🥩 {r['protein_g']}g protein &nbsp;·&nbsp; 🌾 {r['carbs_g']}g carbs<br>
+            ✨ {r['magnesium_mg']}mg magnesium<br>
+            <span style="color:#888;">{r['cuisine']} · {r['diet_tag']}</span>
+          </div>
+        </div>""")
+    return ('<div style="display:flex;gap:12px;flex-wrap:wrap;">'
+            + "".join(cards) + "</div>")
+
+
+def recipe_html(obj, image_url=None):
+    img = (f'<img src="{image_url}" style="width:100%;max-height:210px;'
+           f'object-fit:cover;border-radius:10px;margin-bottom:12px;">'
+           if image_url else "")
+    steps = str(obj["Instructions"]).replace("\n", "<br>")
+    return f"""
+    <div style="border:2px solid #4C72B0;border-radius:14px;padding:18px;background:#fff;">
+      {img}
+      <div style="font-size:19px;font-weight:700;margin-bottom:4px;">
+        🍳 {obj['Recipe_Name']}</div>
+      <div style="font-size:12px;color:#777;margin-bottom:12px;">
+        Ready in {obj['prep_time_min']} minutes</div>
+      <div style="font-size:13px;margin-bottom:10px;">
+        <b>Ingredients</b><br>{obj['Ingredients']}</div>
+      <div style="font-size:13px;margin-bottom:14px;">
+        <b>Instructions</b><br>{steps}</div>
+      <div style="background:#eef3fa;border-radius:10px;padding:12px;font-size:13px;">
+        <b>🔬 Why this works for you</b><br>{obj['why_it_works']}</div>
+    </div>"""
+
+
+def plan_html(plan_text, category):
+    bullets = [b.strip(" -•\t") for b in str(plan_text).split("\n") if b.strip()]
+    items = "".join(
+        f'<li style="margin-bottom:7px;">{b}</li>' for b in bullets)
+    return f"""
+    <div style="border:1px solid #e3e3e3;border-radius:14px;padding:18px;background:#fff;">
+      <div style="font-size:17px;font-weight:700;margin-bottom:2px;">
+        📅 Tomorrow's Recovery Plan</div>
+      <div style="font-size:12px;color:#777;margin-bottom:12px;">
+        Based on your recovery state: <b>{category}</b></div>
+      <ul style="font-size:13px;line-height:1.6;padding-left:20px;margin:0;">{items}</ul>
+    </div>"""
+
+
+# --------------------------------------------------------------------------
+# Main callback
+# --------------------------------------------------------------------------
+def run(state, constraint, diet, max_prep, sleep_hours, strain):
+    if not state or not state.strip():
+        return ("⚠️ Please describe your day first.", "", "")
+
+    nums = []
+    if sleep_hours:
+        nums.append(f"slept {sleep_hours}h")
+    if strain:
+        nums.append(f"strain {strain}/21")
+    numbers = ", ".join(nums) if nums else "no wearable numbers given"
+
+    category = infer_recovery_category(state)
+    top3 = retrieve(state, k=3, diet=diet,
+                    max_prep=int(max_prep) if max_prep else None)
+
+    header = (f'<div style="font-size:13px;color:#555;margin-bottom:10px;">'
+              f'Detected recovery state: <b>{category}</b> · {numbers}</div>')
+    recs = header + cards_html(top3)
+
+    if not constraint or not constraint.strip():
+        constraint = "Keep it simple with easy-to-find ingredients."
+
+    obj = generate_biobite(top3.iloc[0], state, constraint, category, numbers)
+    if obj is None:
+        return (recs,
+                '<div style="padding:16px;">The model returned an unexpected '
+                'format. Please press the button again.</div>', "")
+
+    img = fetch_dish_image(obj["Recipe_Name"])
+    return recs, recipe_html(obj, img), plan_html(obj["next_day_plan"], category)
+
+
+# --------------------------------------------------------------------------
+# UI
+# --------------------------------------------------------------------------
+QUICK_STARTERS = [
+    ["I did a heavy CrossFit workout today but only slept 4 hours and I'm exhausted",
+     "No salmon — only tofu or chicken, and I have just 15 minutes", "Any", 20, 4, 18],
+    ["I ran a half marathon this morning and I'm completely drained",
+     "I'm vegetarian and want something carb-heavy", "vegetarian", 40, 7, 19],
+    ["Really stressful week at work, barely sleeping, my HRV has dropped",
+     "Something calming, no caffeine, I have spinach and nuts", "Any", 30, 5, 8],
+]
+
+with gr.Blocks(title="Bio-Bite", theme=gr.themes.Soft()) as demo:
+    gr.Markdown(
+        """
+        # 🥗 Bio-Bite — your recovery, on a plate
+        Your watch tells you that you slept 5 hours and hit a strain of 18. **So what should you eat?**
+        Bio-Bite turns your recovery data into a personalized meal and a plan for tomorrow.
+        """
+    )
+
+    with gr.Row():
+        with gr.Column(scale=3):
+            state = gr.Textbox(
+                label="How was your day, physically?",
+                placeholder="e.g. Heavy leg day at the gym, slept badly, feeling wrecked…",
+                lines=3,
+            )
+            constraint = gr.Textbox(
+                label="👨‍🍳 What's in your fridge? Any constraints?",
+                placeholder="e.g. Only tofu and rice, 15 minutes, no nuts",
+                lines=2,
+            )
+        with gr.Column(scale=2):
+            diet = gr.Dropdown(
+                ["Any", "omnivore", "vegetarian", "vegan", "pescatarian", "gluten-free"],
+                value="Any", label="Diet",
+            )
+            max_prep = gr.Slider(10, 60, value=30, step=5, label="Max prep time (min)")
+            sleep_hours = gr.Slider(0, 10, value=7, step=0.5, label="Sleep last night (h)")
+            strain = gr.Slider(0, 21, value=10, step=1, label="Strain today (0–21)")
+
+    btn = gr.Button("🍽️  Generate My Bio-Bite", variant="primary", size="lg")
+
+    gr.Markdown("### ⚡ Quick starters — one click to try it")
+    gr.Examples(
+        examples=QUICK_STARTERS,
+        inputs=[state, constraint, diet, max_prep, sleep_hours, strain],
+        label="",
+    )
+
+    gr.Markdown("### 🔍 Three recovery meals matched to your state")
+    out_recs = gr.HTML()
+    with gr.Row():
+        with gr.Column():
+            gr.Markdown("### ✨ Your personalized Bio-Bite")
+            out_recipe = gr.HTML()
+        with gr.Column():
+            gr.Markdown("### 📅 Your plan for tomorrow")
+            out_plan = gr.HTML()
+
+    gr.Markdown(
+        """
+        ---
+        ⚠️ **Educational prototype — not medical, nutritional or training advice.**
+        Recipes come from a synthetic dataset generated by a language model and have not been
+        reviewed by a registered dietitian. Consult a qualified professional for personal guidance.
+
+        *Dataset: [benjac8/bio-bite-recovery-nutrition](https://huggingface.co/datasets/benjac8/bio-bite-recovery-nutrition)
+        · Embeddings: BAAI/bge-small-en-v1.5 · Generation: Qwen2.5-3B-Instruct*
+        """
+    )
+
+    btn.click(
+        run,
+        inputs=[state, constraint, diet, max_prep, sleep_hours, strain],
+        outputs=[out_recs, out_recipe, out_plan],
+    )
+
+if __name__ == "__main__":
+    demo.launch()

biobite_embeddings.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:b91a021a5f85739848457672745b4b7db8f51c84303b5d3b294753d2df5451db
+size 22280382

recovery_guidance.json

@@ -0,0 +1,32 @@
+{
+  "strength-recovery": {
+    "training": "Light active recovery or mobility work tomorrow; train the same muscle group again after ~48h.",
+    "nutrition": "Spread protein across 3-4 meals (~every 3-4 hours) to sustain muscle protein synthesis.",
+    "sleep": "Aim for 8 hours; deep sleep drives growth-hormone release and tissue repair."
+  },
+  "endurance-recovery": {
+    "training": "Easy aerobic (zone 2) session or a full rest day; avoid another hard effort.",
+    "nutrition": "Carbohydrate-forward meals to rebuild glycogen; include electrolytes.",
+    "sleep": "8 hours; consistent bed and wake times support aerobic adaptation."
+  },
+  "sleep-deprived": {
+    "training": "Reduce intensity - skip high-strain sessions until sleep is restored.",
+    "nutrition": "Regular balanced meals; cut caffeine after early afternoon.",
+    "sleep": "Prioritise 8-9 hours tonight; dim screens an hour before bed."
+  },
+  "high-stress": {
+    "training": "Gentle movement only - a walk, easy yoga, or breathwork.",
+    "nutrition": "Magnesium and omega-3 rich foods; limit caffeine and refined sugar.",
+    "sleep": "Consistent bedtime with a wind-down routine to support HRV recovery."
+  },
+  "rest-day": {
+    "training": "Normal training tomorrow is fine - you are recovered.",
+    "nutrition": "Balanced, micronutrient-dense meals; keep hydration steady.",
+    "sleep": "Maintain your usual 7-9 hour routine."
+  },
+  "rehydration": {
+    "training": "Train at moderate intensity only once fully rehydrated.",
+    "nutrition": "Fluids with sodium and potassium; include water-rich foods.",
+    "sleep": "7-9 hours; avoid alcohol, which worsens dehydration."
+  }
+}

requirements.txt

@@ -0,0 +1,11 @@
+gradio==5.9.1
+torch
+transformers>=4.44
+accelerate
+sentence-transformers>=3.0
+faiss-cpu
+datasets
+pandas
+pyarrow
+numpy
+requests