Lesson 1.1 What is AI vs. ML vs. Deep Learning (health context)

Outcomes (progressive ladder)

• Foundational: Differentiate AI, ML, DL with nutrition examples; map data types to model families.
• Intermediate: Design a hybrid pipeline (rules + ML + DL) that includes calibration and uncertainty gating.
• Advanced: Justify technique choice with mathematical framing, risk/benefit trade-offs, latency/footprint constraints, and fairness slices; produce a minimal model card.

Concept Primer (expanded, concise)

• AI = any computational strategy that mimics intelligent behavior (rules/knowledge graphs/heuristics included).
• ML = AI that learns from data: y^=fθ(x)\hat{y} = f_\theta(x)y^=fθ(x) where θ\thetaθ is learned to minimize a loss (e.g., log loss).
• DL = ML using neural networks: fθ=fL∘fL−1∘…∘f1f_\theta = f_L \circ f_{L-1} \circ \ldots \circ f_1fθ=fL∘fL−1∘…∘f1, learning hierarchical features from raw inputs.

In nutrition workflow terms

1. Perception (understand inputs): image → foods/portions, text/voice → structured meals. (DL shines.)
2. Reasoning & policy: safety and clinical rules (AI/rules).
3. Prediction: adherence/risk scores (ML on tabular signals).
4. Planning: optimize meals under constraints (AI/optimization + ML priors).
5. Coaching: choose timing/tone of nudges (ML uplift models).

Mathematical framing by use-case

• Adherence prediction (tabular):
  • Input x∈Rdx \in \mathbb{R}^dx∈Rd, label y∈{0,1}y \in \{0,1\}y∈{0,1}.
  • Learn p(y=1∣x)=σ(w⊤x)p(y=1|x) = \sigma(w^\top x)p(y=1∣x)=σ(w⊤x) (logistic) or g(x)g(x)g(x) (GBM).
  • Evaluate with PR-AUC (class imbalance), ECE (calibration).
• Plate recognition (image):
  • Input X∈RH×W×3X \in \mathbb{R}^{H\times W\times 3}X∈RH×W×3.
  • Multi-label classification + instance segmentation: optimize
    L=Lcls+λLseg+μLportion\mathcal{L} = \mathcal{L}_{cls} + \lambda \mathcal{L}_{seg} + \mu \mathcal{L}_{portion}L=Lcls+λLseg+μLportion.
• Meal text parsing (NLP):
  • Sequence labeling for entities (food, quantity, unit): BIO tags trained with cross-entropy; optionally add a constraint layer to enforce “quantity must precede unit”.

Nutrition data taxonomy → best-fit approaches

Choice framework (practical)

1. Risk level: If a mistake could cause harm (e.g., med–food interaction), prefer rules or interpretable ML with override.
2. Data shape: Unstructured ⇒ DL; structured/tabular ⇒ ML.
3. Data volume: <5k labeled images? Use transfer learning + augmentation.
4. Explainability need: Clinician-facing decisions ⇒ feature-attribution, monotonic constraints, or rules.
5. Latency/footprint: On-device target? Quantize/prune or keep to small ML.

Heuristic: Use the smallest, most explainable tool that meets the nutritional objective with validated performance on your population slices.

Failure modes & mitigations (nutrition-specific)

• Portion misestimation on complex curries → add segmentation + calibrate with known bowl volumes; fall back to user confirmation.
• Cuisine bias (model trained on Western foods) → curate stratified training and report slice metrics by cuisine.
• Under-reporting (behavioral) → predict likelihood of under-reporting and adapt nudges; never assume logs are ground truth.
• Unit chaos (g/mL/servings) → canonicalize with a unit dictionary + probabilistic conversion when metadata is missing.
• Spurious correlations (steps correlate with lighter meals) → test with temporal validation and domain/shift tests.

Uncertainty, calibration, and abstention

• Predictive uncertainty: use softmax entropy or MC-Dropout variance; if uncertainty high, ask the user or abstain.
• Calibration: reliability diagrams; apply Platt/isotonic scaling. Track Brier score.
• Decision logic:
  • If ppp well-calibrated and p>0.8p>0.8p>0.8 (image food class), auto-accept;
  • 0.5<p≤0.80.5<p\le 0.80.5<p≤0.8: ask for confirmation;
  • p≤0.5p\le 0.5p≤0.5: abstain and propose manual entry.

Hybrid pipeline blueprint (nutrition app)

[Input] -> [DL perception (optional)] -> [Normalization + Units]
-> [Safety rules: allergens, drug-nutrient, clinical ceilings]
-> [ML predictor: adherence/risk, calibrated]
-> [Planner: constraints (macros, budget, cuisine)]
-> [Coach: uplift model for nudge timing]
-> [Uncertainty gate -> human confirm]
-> [Audit log + metrics by slice]

Governance checklist (lightweight)

• Intended use & exclusions documented.
• Population coverage (age, cuisines, languages) with slice metrics.
• Data provenance and consent scope.
• Model card: performance, calibration plots, known failure cases, retraining cadence.
• Safeguards: bounds on nutrient recommendations; human override; incident playbook.

Case sprint (problem → approach → trade-offs)

Scenario: Build “Smart Plate” for mixed Indian meals.

• Problem: Identify dishes and estimate portions from a single top-down photo; produce kcal ± CI.
• Approach:
  1. Pretrained segmentation (e.g., lightweight Mask head) to separate items.
  2. Class head for dish ID; volume via reference object (plate diameter) + shape assumptions.
  3. Convert volume→grams using density priors; attach CI from bootstrap.
  4. Safety: cap kcal per item; flag high-fat gravies for manual confirm.
• Trade-offs:
  • Accuracy vs. UX: more prompts improve accuracy but slow logging.
  • On-device vs. cloud: on-device protects privacy, may reduce accuracy; consider hybrid: fast local top-k, cloud re-score on demand.
  • Generalization: add domain adaptation using few-shot prompts for new dishes.

Hands-on sketches (code-centric, minimal)

A. Rules layer (Python-like pseudocode)

def safety_checks(meal, meds):
alerts = []
if meal.sodium_mg_24h >= 2300:
alerts.append("High sodium: choose low-sodium swaps.")
if "grapefruit" in meal.foods and meds.contains("statin"):
alerts.append("Avoid grapefruit with statins.")
kcal_cap = min(900, 18 * meal.user_weight_kg) # simple cap
if meal.estimated_kcal > kcal_cap:
alerts.append("Check portion size; estimate seems high.")
return alerts

B. Classical ML (tabular adherence)

# Sketch only; not runnable here
X_train, y_train = make_temporal_split(features, label, cutoff="2025-06-01")
model = GradientBoostingClassifier()
model.fit(X_train, y_train)
p_val = calibrate(model, method="isotonic") # returns calibrated probabilities
evaluate(p_val, y_val, metrics=["PR_AUC", "Brier", "ECE"])

C. DL perception as a feature extractor

# Pseudocode: use pretrained CNN features + small head
features = cnn_backbone(photo).detach()
portion_pred = mlp_head(features) # grams per class
if entropy(softmax(portion_pred)) > THRESH:
return "ask_user_confirmation"

Evaluation beyond accuracy (what to actually report)

• Discrimination: PR-AUC for imbalanced targets; ROC-AUC can mislead.
• Calibration: Brier score, reliability curves; report before and after scaling.
• Net benefit: decision curve analysis to show clinical utility at chosen thresholds.
• Robustness: cross-device (low-light vs. daylight), cross-cuisine, cross-language.
• Fairness: ΔPR-AUC and ΔECE across demographic and regional slices; propose mitigation (reweighting, targeted data collection).

Advanced extensions (choose any)

1. Uplift modeling for nudges: two-model or meta-learner to estimate treatment effect of notifications on logging behavior.
2. Monotonic constraints: enforce “more fiber → non-decreasing satiety score” in gradient boosting for safer behavior.
3. Multi-objective planning: optimize macros + budget + cultural fit; solve with constrained optimization, then re-rank with ML adherence probability.
4. Edge AI: post-training quantization of CNN to 8-bit; measure latency on mid-range Android; introduce a confidence-driven offload to cloud.
5. Few-shot cuisine adaptation: prompt-tuned vision-language backbone; create a 50-image adapter set per new cuisine.

Practice set (self-check, open-ended)

1. Triage matrix: For five features of a nutrition app you know, fill a 3×5 matrix labeling the best approach (Rule/ML/DL) and one risk mitigation each.
2. Threshold design: With calibrated probabilities for “skip dinner log,” choose operational thresholds for auto-nudge, silent, and coach escalation; justify using PR-AUC and decision curves.
3. Uncertainty policy: Write acceptance/abstention rules for plate recognition with different user segments (novice vs. expert logger).
4. Bias audit plan: Define three cuisine/language slices to monitor; set action criteria (e.g., ΔPR-AUC > 0.05 triggers data collection).
5. Model card draft: One-page summary: task, data, metrics (overall + slices), calibration plot snapshot, known failure cases, retrain trigger.

Glossary (targeted)

• Calibration: When predicted probabilities match observed frequencies (e.g., among users with p=0.7p=0.7p=0.7, ~70% actually skip logging).
• Abstention: Model declines to decide when uncertainty is high; hands off to human/user.
• Uplift model: Predicts change in outcome due to an intervention, not just the outcome.
• Decision curve: Plots net benefit vs. threshold to compare strategies.
• Monotonic constraint: Structural rule enforced in a model so outputs vary predictably with key features.

Further reading

• Artificial Intelligence: A Modern Approach — taxonomy and reasoning patterns.
• The Elements of Statistical Learning — solid grounding for tabular ML.
• Deep Learning — architectures and training dynamics.
• “Hidden Technical Debt in ML Systems” — operational realities.
• “Why Should I Trust You?” (model interpretability survey) — practical XAI methods.

Final takeaway

Most nutrition systems win with composition, not a single technique: use rules to guarantee safety, classical ML to predict behaviors and risks from structured signals, and DL to parse unstructured inputs. Wrap it with calibration, uncertainty-aware abstention, fairness checks, and a minimal governance layer—and you’ve moved from basics to an industry-grade foundation.