Deploy Calority model API

.dockerignore

@@ -0,0 +1,8 @@
+.venv
+__pycache__
+*.pyc
+.env
+calority-nutrition-model
+calority-scratch-model
+calority-food-model
+*.log

.env.example

@@ -0,0 +1,6 @@
+MODEL_ID=nateraw/food
+MODEL_TASK=nutrition-regression
+MODEL_DIR=./calority-nutrition-model
+HF_MODEL_REPO_ID=
+MODEL_API_KEY=change-me-before-deploy
+PORT=8000

Dockerfile

@@ -1,16 +1,28 @@
-# Read the doc: https://huggingface.co/docs/hub/spaces-sdks-docker
-# you will also find guides on how best to write your Dockerfile
+FROM python:3.11-slim
 
-FROM python:3.9
+ENV PYTHONDONTWRITEBYTECODE=1
+ENV PYTHONUNBUFFERED=1
+ENV PORT=7860
+ENV MODEL_TASK=nutrition-regression
+
+RUN apt-get update && apt-get install -y --no-install-recommends \
+    libgl1 \
+    libglib2.0-0 \
+    && rm -rf /var/lib/apt/lists/*
 
 RUN useradd -m -u 1000 user
 USER user
-ENV PATH="/home/user/.local/bin:$PATH"
 
-WORKDIR /app
+ENV HOME=/home/user
+ENV PATH="/home/user/.local/bin:${PATH}"
+
+WORKDIR /home/user/app
+
+COPY requirements.txt .
+RUN pip install --no-cache-dir --upgrade pip && pip install --no-cache-dir -r requirements.txt
+
+COPY --chown=user . .
 
-COPY --chown=user ./requirements.txt requirements.txt
-RUN pip install --no-cache-dir --upgrade -r requirements.txt
+EXPOSE 7860
 
-COPY --chown=user . /app
-CMD ["uvicorn", "app:app", "--host", "0.0.0.0", "--port", "7860"]
+CMD ["sh", "-c", "uvicorn main:app --host 0.0.0.0 --port ${PORT}"]

README.md

@@ -1,10 +1,23 @@
 ---
-title: Calority Model Api
-emoji: 🐠
-colorFrom: gray
-colorTo: purple
+title: Calority Model API
+emoji: 🥗
+colorFrom: green
+colorTo: yellow
 sdk: docker
 pinned: false
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# Calority Model API
+
+FastAPI service for Calority meal nutrition analysis.
+
+Set these Space secrets:
+
+- `MODEL_TASK=nutrition-regression`
+- `HF_MODEL_REPO_ID=<your-hf-username>/<your-model-repo>`
+- `MODEL_API_KEY=<same-value-you-store-in-supabase>`
+
+The API exposes:
+
+- `GET /health`
+- `POST /analyze-meal`

calority_nutrition_model.py

@@ -0,0 +1,112 @@
+import json
+from pathlib import Path
+
+import torch
+from PIL import Image
+from torch import nn
+
+from calority_scratch_model import IMAGE_SIZE, image_to_tensor
+
+
+TARGET_COLUMNS = ["total_calories", "total_mass", "total_fat", "total_carb", "total_protein"]
+
+
+class CalorityNutritionCNN(nn.Module):
+    def __init__(self, output_size: int = len(TARGET_COLUMNS)):
+        super().__init__()
+        self.features = nn.Sequential(
+            self._block(3, 32),
+            self._block(32, 64),
+            self._block(64, 128),
+            self._block(128, 256),
+            self._block(256, 384),
+        )
+        self.pool = nn.AdaptiveAvgPool2d((1, 1))
+        self.regressor = nn.Sequential(
+            nn.Flatten(),
+            nn.Dropout(0.35),
+            nn.Linear(384, 256),
+            nn.ReLU(inplace=True),
+            nn.Dropout(0.2),
+            nn.Linear(256, output_size),
+        )
+
+    @staticmethod
+    def _block(in_channels: int, out_channels: int) -> nn.Sequential:
+        return nn.Sequential(
+            nn.Conv2d(in_channels, out_channels, kernel_size=3, padding=1, bias=False),
+            nn.BatchNorm2d(out_channels),
+            nn.ReLU(inplace=True),
+            nn.Conv2d(out_channels, out_channels, kernel_size=3, padding=1, bias=False),
+            nn.BatchNorm2d(out_channels),
+            nn.ReLU(inplace=True),
+            nn.MaxPool2d(2),
+        )
+
+    def forward(self, pixel_values: torch.Tensor) -> torch.Tensor:
+        x = self.features(pixel_values)
+        x = self.pool(x)
+        return self.regressor(x)
+
+
+def predict_nutrients(
+    model: CalorityNutritionCNN,
+    image: Image.Image,
+    target_mean: torch.Tensor,
+    target_std: torch.Tensor,
+    device: torch.device,
+) -> dict:
+    tensor = image_to_tensor(image, IMAGE_SIZE).unsqueeze(0).to(device)
+    with torch.no_grad():
+        normalized = model(tensor)[0].cpu()
+    values = torch.clamp((normalized * target_std) + target_mean, min=0)
+    return {column: round(float(value), 2) for column, value in zip(TARGET_COLUMNS, values)}
+
+
+def save_nutrition_checkpoint(
+    model: nn.Module,
+    target_mean: torch.Tensor,
+    target_std: torch.Tensor,
+    output_dir: str | Path,
+) -> None:
+    output_path = Path(output_dir)
+    output_path.mkdir(parents=True, exist_ok=True)
+    torch.save(model.state_dict(), output_path / "model.pt")
+    (output_path / "target_stats.json").write_text(
+        json.dumps(
+            {
+                "target_columns": TARGET_COLUMNS,
+                "target_mean": [float(value) for value in target_mean],
+                "target_std": [float(value) for value in target_std],
+            },
+            indent=2,
+        ),
+        encoding="utf-8",
+    )
+    (output_path / "config.json").write_text(
+        json.dumps(
+            {
+                "architecture": "CalorityNutritionCNN",
+                "task": "nutrition-regression",
+                "image_size": IMAGE_SIZE,
+            },
+            indent=2,
+        ),
+        encoding="utf-8",
+    )
+
+
+def load_nutrition_checkpoint(
+    model_dir: str | Path,
+    device: str | torch.device = "cpu",
+) -> tuple[CalorityNutritionCNN, torch.Tensor, torch.Tensor]:
+    model_path = Path(model_dir)
+    stats = json.loads((model_path / "target_stats.json").read_text(encoding="utf-8"))
+    model = CalorityNutritionCNN(output_size=len(stats["target_columns"]))
+    state = torch.load(model_path / "model.pt", map_location=device)
+    model.load_state_dict(state)
+    model.to(device)
+    model.eval()
+    target_mean = torch.tensor(stats["target_mean"], dtype=torch.float32)
+    target_std = torch.tensor(stats["target_std"], dtype=torch.float32)
+    return model, target_mean, target_std

calority_scratch_model.py

@@ -0,0 +1,78 @@
+import json
+from pathlib import Path
+
+import torch
+from PIL import Image
+from torch import nn
+
+
+IMAGE_SIZE = 224
+MEAN = torch.tensor([0.485, 0.456, 0.406]).view(3, 1, 1)
+STD = torch.tensor([0.229, 0.224, 0.225]).view(3, 1, 1)
+
+
+class CalorityFoodCNN(nn.Module):
+    def __init__(self, num_labels: int):
+        super().__init__()
+        self.features = nn.Sequential(
+            self._block(3, 32),
+            self._block(32, 64),
+            self._block(64, 128),
+            self._block(128, 256),
+            self._block(256, 384),
+        )
+        self.pool = nn.AdaptiveAvgPool2d((1, 1))
+        self.classifier = nn.Sequential(
+            nn.Flatten(),
+            nn.Dropout(0.35),
+            nn.Linear(384, 256),
+            nn.ReLU(inplace=True),
+            nn.Dropout(0.2),
+            nn.Linear(256, num_labels),
+        )
+
+    @staticmethod
+    def _block(in_channels: int, out_channels: int) -> nn.Sequential:
+        return nn.Sequential(
+            nn.Conv2d(in_channels, out_channels, kernel_size=3, padding=1, bias=False),
+            nn.BatchNorm2d(out_channels),
+            nn.ReLU(inplace=True),
+            nn.Conv2d(out_channels, out_channels, kernel_size=3, padding=1, bias=False),
+            nn.BatchNorm2d(out_channels),
+            nn.ReLU(inplace=True),
+            nn.MaxPool2d(2),
+        )
+
+    def forward(self, pixel_values: torch.Tensor) -> torch.Tensor:
+        x = self.features(pixel_values)
+        x = self.pool(x)
+        return self.classifier(x)
+
+
+def image_to_tensor(image: Image.Image, image_size: int = IMAGE_SIZE) -> torch.Tensor:
+    resized = image.convert("RGB").resize((image_size, image_size), Image.Resampling.BILINEAR)
+    raw = torch.ByteTensor(torch.ByteStorage.from_buffer(resized.tobytes()))
+    tensor = raw.view(image_size, image_size, 3).permute(2, 0, 1).float() / 255.0
+    return (tensor - MEAN) / STD
+
+
+def save_checkpoint(model: nn.Module, labels: list[str], output_dir: str | Path) -> None:
+    output_path = Path(output_dir)
+    output_path.mkdir(parents=True, exist_ok=True)
+    torch.save(model.state_dict(), output_path / "model.pt")
+    (output_path / "labels.json").write_text(json.dumps(labels, indent=2), encoding="utf-8")
+    (output_path / "config.json").write_text(
+        json.dumps({"architecture": "CalorityFoodCNN", "image_size": IMAGE_SIZE}, indent=2),
+        encoding="utf-8",
+    )
+
+
+def load_checkpoint(model_dir: str | Path, device: str | torch.device = "cpu") -> tuple[CalorityFoodCNN, list[str]]:
+    model_path = Path(model_dir)
+    labels = json.loads((model_path / "labels.json").read_text(encoding="utf-8"))
+    model = CalorityFoodCNN(num_labels=len(labels))
+    state = torch.load(model_path / "model.pt", map_location=device)
+    model.load_state_dict(state)
+    model.to(device)
+    model.eval()
+    return model, labels

main.py

@@ -0,0 +1,297 @@
+import base64
+import io
+import os
+import re
+from dataclasses import dataclass
+from functools import lru_cache
+from pathlib import Path
+
+import torch
+from fastapi import FastAPI, Header, HTTPException
+from huggingface_hub import snapshot_download
+from PIL import Image
+from pydantic import BaseModel, Field
+from transformers import pipeline
+
+from calority_nutrition_model import load_nutrition_checkpoint, predict_nutrients
+from calority_scratch_model import image_to_tensor, load_checkpoint
+
+
+MODEL_ID = os.getenv("MODEL_ID", "nateraw/food")
+MODEL_DIR = os.getenv("MODEL_DIR", "")
+HF_MODEL_REPO_ID = os.getenv("HF_MODEL_REPO_ID", "")
+MODEL_TASK = os.getenv("MODEL_TASK", "classification")
+MODEL_API_KEY = os.getenv("MODEL_API_KEY", "")
+
+app = FastAPI(title="Calority Meal Model", version="0.1.0")
+
+
+class AnalyzeMealRequest(BaseModel):
+    imageBase64: str = Field(min_length=1)
+    mimeType: str = "image/jpeg"
+    portionContext: str = ""
+
+
+@dataclass(frozen=True)
+class NutritionProfile:
+    serving_g: int
+    calories_100g: int
+    protein_100g: float
+    carbs_100g: float
+    fat_100g: float
+
+
+NUTRITION = {
+    "apple pie": NutritionProfile(140, 237, 1.9, 34.0, 11.0),
+    "baby back ribs": NutritionProfile(220, 290, 20.0, 6.0, 21.0),
+    "baklava": NutritionProfile(80, 428, 6.0, 54.0, 21.0),
+    "beef carpaccio": NutritionProfile(120, 160, 22.0, 1.0, 7.0),
+    "beef tartare": NutritionProfile(150, 190, 20.0, 2.0, 12.0),
+    "beet salad": NutritionProfile(180, 90, 3.0, 12.0, 4.0),
+    "bibimbap": NutritionProfile(450, 145, 6.0, 20.0, 4.0),
+    "bread pudding": NutritionProfile(160, 220, 5.0, 32.0, 8.0),
+    "breakfast burrito": NutritionProfile(280, 210, 10.0, 23.0, 9.0),
+    "bruschetta": NutritionProfile(120, 190, 6.0, 25.0, 7.0),
+    "caesar salad": NutritionProfile(220, 170, 8.0, 8.0, 12.0),
+    "cannoli": NutritionProfile(90, 310, 7.0, 33.0, 16.0),
+    "caprese salad": NutritionProfile(180, 170, 9.0, 5.0, 13.0),
+    "carrot cake": NutritionProfile(120, 415, 4.0, 50.0, 22.0),
+    "cheesecake": NutritionProfile(125, 321, 6.0, 26.0, 22.0),
+    "chicken curry": NutritionProfile(300, 165, 13.0, 7.0, 9.0),
+    "chicken quesadilla": NutritionProfile(250, 260, 14.0, 22.0, 13.0),
+    "chicken wings": NutritionProfile(180, 290, 24.0, 1.0, 20.0),
+    "chocolate cake": NutritionProfile(120, 371, 5.0, 53.0, 16.0),
+    "club sandwich": NutritionProfile(260, 240, 13.0, 22.0, 12.0),
+    "cup cakes": NutritionProfile(80, 305, 4.0, 47.0, 12.0),
+    "donuts": NutritionProfile(80, 452, 5.0, 51.0, 25.0),
+    "dumplings": NutritionProfile(220, 190, 9.0, 26.0, 6.0),
+    "edamame": NutritionProfile(160, 121, 11.0, 9.0, 5.0),
+    "falafel": NutritionProfile(180, 333, 13.0, 32.0, 18.0),
+    "filet mignon": NutritionProfile(180, 250, 26.0, 0.0, 16.0),
+    "fish and chips": NutritionProfile(350, 230, 11.0, 24.0, 10.0),
+    "french fries": NutritionProfile(150, 312, 3.4, 41.0, 15.0),
+    "fried rice": NutritionProfile(300, 165, 5.0, 25.0, 5.0),
+    "greek salad": NutritionProfile(220, 110, 4.0, 7.0, 8.0),
+    "grilled cheese sandwich": NutritionProfile(180, 350, 12.0, 28.0, 21.0),
+    "hamburger": NutritionProfile(250, 295, 17.0, 24.0, 14.0),
+    "hot dog": NutritionProfile(150, 290, 11.0, 24.0, 17.0),
+    "hummus": NutritionProfile(120, 166, 8.0, 14.0, 10.0),
+    "lasagna": NutritionProfile(320, 170, 10.0, 16.0, 8.0),
+    "macaroni and cheese": NutritionProfile(250, 164, 7.0, 20.0, 6.0),
+    "omelette": NutritionProfile(180, 154, 11.0, 1.0, 12.0),
+    "pancakes": NutritionProfile(220, 227, 6.0, 28.0, 10.0),
+    "pizza": NutritionProfile(250, 266, 11.0, 33.0, 10.0),
+    "ramen": NutritionProfile(500, 90, 4.0, 12.0, 3.0),
+    "samosa": NutritionProfile(150, 260, 6.0, 30.0, 13.0),
+    "sashimi": NutritionProfile(160, 130, 22.0, 0.0, 4.0),
+    "spaghetti bolognese": NutritionProfile(350, 150, 8.0, 20.0, 5.0),
+    "steak": NutritionProfile(220, 250, 26.0, 0.0, 15.0),
+    "sushi": NutritionProfile(220, 145, 7.0, 24.0, 2.0),
+    "tacos": NutritionProfile(220, 210, 10.0, 21.0, 10.0),
+    "waffles": NutritionProfile(180, 291, 8.0, 33.0, 14.0),
+}
+
+DEFAULT_PROFILE = NutritionProfile(250, 180, 8.0, 20.0, 6.0)
+
+
+@lru_cache(maxsize=1)
+def classifier():
+    return pipeline("image-classification", model=MODEL_ID)
+
+
+@lru_cache(maxsize=1)
+def resolved_model_dir() -> str:
+    if MODEL_DIR:
+        return MODEL_DIR
+    if HF_MODEL_REPO_ID:
+        return snapshot_download(repo_id=HF_MODEL_REPO_ID)
+    return ""
+
+
+@lru_cache(maxsize=1)
+def scratch_classifier():
+    model_dir = resolved_model_dir()
+    if not model_dir or MODEL_TASK != "classification":
+        return None
+    model_path = Path(model_dir)
+    if not (model_path / "model.pt").exists():
+        return None
+    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+    model, labels = load_checkpoint(model_path, device=device)
+    return model, labels, device
+
+
+@lru_cache(maxsize=1)
+def nutrition_regressor():
+    model_dir = resolved_model_dir()
+    if not model_dir or MODEL_TASK != "nutrition-regression":
+        return None
+    model_path = Path(model_dir)
+    if not (model_path / "model.pt").exists() or not (model_path / "target_stats.json").exists():
+        return None
+    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+    model, target_mean, target_std = load_nutrition_checkpoint(model_path, device=device)
+    return model, target_mean, target_std, device
+
+
+def classify_image(image: Image.Image) -> list[dict]:
+    scratch = scratch_classifier()
+    if scratch is None:
+        return classifier()(image, top_k=3)
+
+    model, labels, device = scratch
+    tensor = image_to_tensor(image).unsqueeze(0).to(device)
+    with torch.no_grad():
+        probabilities = torch.softmax(model(tensor), dim=1)[0]
+    top_scores, top_indices = torch.topk(probabilities, k=min(3, len(labels)))
+    return [
+        {"label": labels[index.item()], "score": score.item()}
+        for score, index in zip(top_scores, top_indices)
+    ]
+
+
+def analyze_nutrients(image: Image.Image, portion_context: str) -> dict | None:
+    regressor = nutrition_regressor()
+    if regressor is None:
+        return None
+
+    model, target_mean, target_std, device = regressor
+    nutrients = predict_nutrients(model, image, target_mean, target_std, device)
+
+    calories = round(nutrients["total_calories"])
+    mass = round(nutrients["total_mass"])
+    fat = round(nutrients["total_fat"])
+    carbs = round(nutrients["total_carb"])
+    protein = round(nutrients["total_protein"])
+    macro_calories = (protein * 4) + (carbs * 4) + (fat * 9)
+    macro_gap = abs(macro_calories - calories)
+    confidence = "medium" if calories > 0 else "low"
+    confidence_note = (
+        f"Estimated from image using Calority nutrition regression. Macro calories differ by {macro_gap} kcal."
+    )
+    if portion_context:
+        confidence_note = f"{confidence_note} User context: {portion_context}."
+
+    return {
+        "name": "Food Plate",
+        "calories": calories,
+        "protein": protein,
+        "carbs": carbs,
+        "fat": fat,
+        "ingredients": [
+            f"Estimated total mass {mass}g",
+            f"Protein {protein}g - {protein * 4} kcal",
+            f"Carbs {carbs}g - {carbs * 4} kcal",
+            f"Fat {fat}g - {fat * 9} kcal",
+        ],
+        "confidence": confidence,
+        "confidenceNote": confidence_note,
+        "nutritionDetails": {
+            "totalMass": mass,
+            "calories": calories,
+            "protein": protein,
+            "carbs": carbs,
+            "fat": fat,
+            "macroCalories": macro_calories,
+        },
+    }
+
+
+def require_auth(authorization: str | None) -> None:
+    if not MODEL_API_KEY:
+        return
+    expected = f"Bearer {MODEL_API_KEY}"
+    if authorization != expected:
+        raise HTTPException(status_code=401, detail="Invalid model service token")
+
+
+def decode_image(image_base64: str) -> Image.Image:
+    try:
+        raw = base64.b64decode(image_base64)
+        return Image.open(io.BytesIO(raw)).convert("RGB")
+    except Exception as exc:
+        raise HTTPException(status_code=400, detail="Invalid imageBase64") from exc
+
+
+def normalize_label(label: str) -> str:
+    return label.lower().replace("_", " ").replace("-", " ").strip()
+
+
+def grams_from_context(portion_context: str, fallback: int) -> int:
+    match = re.search(r"(\d{2,4})\s*(g|gram|grams)\b", portion_context.lower())
+    if match:
+        return max(30, min(1200, int(match.group(1))))
+    return fallback
+
+
+def nutrition_for(label: str, grams: int) -> dict:
+    profile = NUTRITION.get(label, DEFAULT_PROFILE)
+    factor = grams / 100
+    calories = round(profile.calories_100g * factor)
+    protein = round(profile.protein_100g * factor)
+    carbs = round(profile.carbs_100g * factor)
+    fat = round(profile.fat_100g * factor)
+    return {
+        "calories": calories,
+        "protein": protein,
+        "carbs": carbs,
+        "fat": fat,
+        "ingredient": f"{label.title()} estimated {grams}g - {calories} kcal",
+    }
+
+
+def confidence_from(score: float) -> tuple[str, str]:
+    if score >= 0.75:
+        return "high", ""
+    if score >= 0.45:
+        return "medium", "The food is visible, but the model is not fully certain."
+    return "low", "The model could not confidently identify the meal."
+
+
+@app.get("/health")
+def health() -> dict:
+    if nutrition_regressor():
+        model_source = f"nutrition-regression:{HF_MODEL_REPO_ID or MODEL_DIR}"
+    elif scratch_classifier():
+        model_source = f"classification:{HF_MODEL_REPO_ID or MODEL_DIR}"
+    else:
+        model_source = f"pipeline:{MODEL_ID}"
+    return {"status": "ok", "model": model_source}
+
+
+@app.post("/analyze-meal")
+def analyze_meal(payload: AnalyzeMealRequest, authorization: str | None = Header(default=None)) -> dict:
+    require_auth(authorization)
+    image = decode_image(payload.imageBase64)
+    nutrient_result = analyze_nutrients(image, payload.portionContext)
+    if nutrient_result:
+        return nutrient_result
+
+    predictions = classify_image(image)
+    best = predictions[0]
+    label = normalize_label(best["label"])
+    score = float(best["score"])
+
+    profile = NUTRITION.get(label, DEFAULT_PROFILE)
+    grams = grams_from_context(payload.portionContext, profile.serving_g)
+    macros = nutrition_for(label, grams)
+    confidence, confidence_note = confidence_from(score)
+
+    alternatives = [
+        f"{normalize_label(item['label']).title()} ({round(float(item['score']) * 100)}%)"
+        for item in predictions[1:]
+    ]
+
+    if alternatives and confidence != "high":
+        confidence_note = f"{confidence_note} Alternatives: {', '.join(alternatives)}".strip()
+
+    return {
+        "name": label.title(),
+        "calories": macros["calories"],
+        "protein": macros["protein"],
+        "carbs": macros["carbs"],
+        "fat": macros["fat"],
+        "ingredients": [macros["ingredient"]],
+        "confidence": confidence,
+        "confidenceNote": confidence_note,
+    }

requirements.txt

@@ -1,2 +1,12 @@
-fastapi
-uvicorn[standard]
+fastapi==0.115.6
+uvicorn[standard]==0.32.1
+pillow==11.0.0
+pydantic==2.10.4
+python-multipart==0.0.20
+transformers==4.47.1
+torch==2.5.1
+accelerate==1.2.1
+datasets==3.2.0
+huggingface_hub==0.27.0
+scikit-learn==1.6.0
+tqdm==4.67.1

train_food_model.py

@@ -0,0 +1,78 @@
+import argparse
+
+import numpy as np
+from datasets import load_dataset
+from sklearn.metrics import accuracy_score
+from transformers import (
+    AutoImageProcessor,
+    AutoModelForImageClassification,
+    Trainer,
+    TrainingArguments,
+)
+
+
+def parse_args():
+    parser = argparse.ArgumentParser(description="Fine-tune Calority's food image classifier.")
+    parser.add_argument("--base-model", default="google/vit-base-patch16-224-in21k")
+    parser.add_argument("--dataset", default="food101")
+    parser.add_argument("--output-dir", default="./calority-food-model")
+    parser.add_argument("--epochs", type=int, default=3)
+    parser.add_argument("--batch-size", type=int, default=16)
+    return parser.parse_args()
+
+
+def main():
+    args = parse_args()
+    dataset = load_dataset(args.dataset)
+    labels = dataset["train"].features["label"].names
+    processor = AutoImageProcessor.from_pretrained(args.base_model)
+
+    def transform(batch):
+        images = [image.convert("RGB") for image in batch["image"]]
+        encoded = processor(images=images, return_tensors="pt")
+        encoded["labels"] = batch["label"]
+        return encoded
+
+    train_ds = dataset["train"].with_transform(transform)
+    eval_ds = dataset["validation"].with_transform(transform)
+
+    model = AutoModelForImageClassification.from_pretrained(
+        args.base_model,
+        num_labels=len(labels),
+        id2label={i: label for i, label in enumerate(labels)},
+        label2id={label: i for i, label in enumerate(labels)},
+    )
+
+    def compute_metrics(eval_pred):
+        logits, labels_np = eval_pred
+        preds = np.argmax(logits, axis=-1)
+        return {"accuracy": accuracy_score(labels_np, preds)}
+
+    training_args = TrainingArguments(
+        output_dir=args.output_dir,
+        learning_rate=5e-5,
+        per_device_train_batch_size=args.batch_size,
+        per_device_eval_batch_size=args.batch_size,
+        num_train_epochs=args.epochs,
+        eval_strategy="epoch",
+        save_strategy="epoch",
+        load_best_model_at_end=True,
+        metric_for_best_model="accuracy",
+        remove_unused_columns=False,
+    )
+
+    trainer = Trainer(
+        model=model,
+        args=training_args,
+        train_dataset=train_ds,
+        eval_dataset=eval_ds,
+        compute_metrics=compute_metrics,
+    )
+
+    trainer.train()
+    trainer.save_model(args.output_dir)
+    processor.save_pretrained(args.output_dir)
+
+
+if __name__ == "__main__":
+    main()

train_from_scratch.py

@@ -0,0 +1,142 @@
+import argparse
+from pathlib import Path
+
+import torch
+from datasets import load_dataset
+from torch import nn
+from torch.utils.data import DataLoader
+from tqdm import tqdm
+
+from calority_scratch_model import CalorityFoodCNN, image_to_tensor, save_checkpoint
+
+
+def parse_args():
+    parser = argparse.ArgumentParser(description="Train Calority's food model from scratch on a Hugging Face dataset.")
+    parser.add_argument("--dataset", default="food101", help="Hugging Face dataset name, for example food101")
+    parser.add_argument("--image-column", default="image")
+    parser.add_argument("--label-column", default="label")
+    parser.add_argument("--train-split", default="train")
+    parser.add_argument("--eval-split", default="validation")
+    parser.add_argument("--output-dir", default="./calority-scratch-model")
+    parser.add_argument("--epochs", type=int, default=12)
+    parser.add_argument("--batch-size", type=int, default=32)
+    parser.add_argument("--learning-rate", type=float, default=3e-4)
+    parser.add_argument("--num-workers", type=int, default=0)
+    parser.add_argument("--limit-train", type=int, default=0, help="Optional small limit for quick smoke tests")
+    parser.add_argument("--limit-eval", type=int, default=0, help="Optional small limit for quick smoke tests")
+    return parser.parse_args()
+
+
+def get_labels(dataset, split: str, label_column: str) -> list[str]:
+    feature = dataset[split].features[label_column]
+    if hasattr(feature, "names") and feature.names:
+        return list(feature.names)
+
+    values = sorted(set(dataset[split][label_column]))
+    return [str(value) for value in values]
+
+
+def make_collate_fn(image_column: str, label_column: str):
+    def collate(batch):
+        images = torch.stack([image_to_tensor(item[image_column]) for item in batch])
+        labels = torch.tensor([int(item[label_column]) for item in batch], dtype=torch.long)
+        return images, labels
+
+    return collate
+
+
+def evaluate(model, loader, loss_fn, device):
+    model.eval()
+    total_loss = 0.0
+    total_correct = 0
+    total_seen = 0
+
+    with torch.no_grad():
+        for images, labels in loader:
+            images = images.to(device)
+            labels = labels.to(device)
+            logits = model(images)
+            loss = loss_fn(logits, labels)
+            total_loss += loss.item() * labels.size(0)
+            total_correct += (logits.argmax(dim=1) == labels).sum().item()
+            total_seen += labels.size(0)
+
+    return total_loss / max(total_seen, 1), total_correct / max(total_seen, 1)
+
+
+def main():
+    args = parse_args()
+    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+    dataset = load_dataset(args.dataset)
+
+    if args.limit_train:
+        dataset[args.train_split] = dataset[args.train_split].shuffle(seed=42).select(range(args.limit_train))
+    if args.limit_eval:
+        dataset[args.eval_split] = dataset[args.eval_split].shuffle(seed=42).select(range(args.limit_eval))
+
+    labels = get_labels(dataset, args.train_split, args.label_column)
+    model = CalorityFoodCNN(num_labels=len(labels)).to(device)
+
+    collate_fn = make_collate_fn(args.image_column, args.label_column)
+    train_loader = DataLoader(
+        dataset[args.train_split],
+        batch_size=args.batch_size,
+        shuffle=True,
+        num_workers=args.num_workers,
+        collate_fn=collate_fn,
+    )
+    eval_loader = DataLoader(
+        dataset[args.eval_split],
+        batch_size=args.batch_size,
+        shuffle=False,
+        num_workers=args.num_workers,
+        collate_fn=collate_fn,
+    )
+
+    loss_fn = nn.CrossEntropyLoss()
+    optimizer = torch.optim.AdamW(model.parameters(), lr=args.learning_rate, weight_decay=1e-4)
+    scheduler = torch.optim.lr_scheduler.CosineAnnealingLR(optimizer, T_max=args.epochs)
+
+    best_acc = 0.0
+    output_dir = Path(args.output_dir)
+    output_dir.mkdir(parents=True, exist_ok=True)
+
+    for epoch in range(1, args.epochs + 1):
+        model.train()
+        running_loss = 0.0
+        total_seen = 0
+        total_correct = 0
+
+        progress = tqdm(train_loader, desc=f"epoch {epoch}/{args.epochs}", leave=False)
+        for images, labels_batch in progress:
+            images = images.to(device)
+            labels_batch = labels_batch.to(device)
+
+            optimizer.zero_grad(set_to_none=True)
+            logits = model(images)
+            loss = loss_fn(logits, labels_batch)
+            loss.backward()
+            optimizer.step()
+
+            running_loss += loss.item() * labels_batch.size(0)
+            total_correct += (logits.argmax(dim=1) == labels_batch).sum().item()
+            total_seen += labels_batch.size(0)
+            progress.set_postfix(
+                loss=round(running_loss / max(total_seen, 1), 4),
+                acc=round(total_correct / max(total_seen, 1), 4),
+            )
+
+        scheduler.step()
+        eval_loss, eval_acc = evaluate(model, eval_loader, loss_fn, device)
+        print(f"epoch={epoch} eval_loss={eval_loss:.4f} eval_acc={eval_acc:.4f}")
+
+        if eval_acc >= best_acc:
+            best_acc = eval_acc
+            save_checkpoint(model, labels, output_dir)
+            print(f"saved best model to {output_dir} with eval_acc={best_acc:.4f}")
+
+    print(f"done. best_eval_acc={best_acc:.4f}")
+
+
+if __name__ == "__main__":
+    main()

train_nutrients_from_scratch.py

@@ -0,0 +1,154 @@
+import argparse
+from pathlib import Path
+
+import torch
+from datasets import load_dataset
+from torch import nn
+from torch.utils.data import DataLoader
+from tqdm import tqdm
+
+from calority_nutrition_model import (
+    TARGET_COLUMNS,
+    CalorityNutritionCNN,
+    save_nutrition_checkpoint,
+)
+from calority_scratch_model import image_to_tensor
+
+
+def parse_args():
+    parser = argparse.ArgumentParser(
+        description="Train Calority's calorie and macro predictor from scratch on mmathys/food-nutrients."
+    )
+    parser.add_argument("--dataset", default="mmathys/food-nutrients")
+    parser.add_argument("--source-split", default="test", help="This dataset currently ships with only a test split.")
+    parser.add_argument("--image-column", default="image")
+    parser.add_argument("--output-dir", default="./calority-nutrition-model")
+    parser.add_argument("--epochs", type=int, default=40)
+    parser.add_argument("--batch-size", type=int, default=16)
+    parser.add_argument("--learning-rate", type=float, default=3e-4)
+    parser.add_argument("--validation-size", type=float, default=0.15)
+    parser.add_argument("--num-workers", type=int, default=0)
+    parser.add_argument("--limit", type=int, default=0, help="Optional small limit for quick smoke tests")
+    return parser.parse_args()
+
+
+def make_targets(dataset_split) -> torch.Tensor:
+    rows = [[float(item[column]) for column in TARGET_COLUMNS] for item in dataset_split]
+    return torch.tensor(rows, dtype=torch.float32)
+
+
+def make_collate_fn(image_column: str, target_mean: torch.Tensor, target_std: torch.Tensor):
+    def collate(batch):
+        images = torch.stack([image_to_tensor(item[image_column]) for item in batch])
+        targets = torch.tensor(
+            [[float(item[column]) for column in TARGET_COLUMNS] for item in batch],
+            dtype=torch.float32,
+        )
+        normalized_targets = (targets - target_mean) / target_std
+        return images, normalized_targets, targets
+
+    return collate
+
+
+def evaluate(model, loader, loss_fn, target_mean, target_std, device):
+    model.eval()
+    total_loss = 0.0
+    total_mae = torch.zeros(len(TARGET_COLUMNS))
+    total_seen = 0
+
+    with torch.no_grad():
+        for images, normalized_targets, raw_targets in loader:
+            images = images.to(device)
+            normalized_targets = normalized_targets.to(device)
+            predictions = model(images)
+            loss = loss_fn(predictions, normalized_targets)
+
+            raw_predictions = torch.clamp(
+                (predictions.cpu() * target_std) + target_mean,
+                min=0,
+            )
+            total_loss += loss.item() * images.size(0)
+            total_mae += torch.abs(raw_predictions - raw_targets).sum(dim=0)
+            total_seen += images.size(0)
+
+    mae = total_mae / max(total_seen, 1)
+    return total_loss / max(total_seen, 1), mae
+
+
+def main():
+    args = parse_args()
+    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+    dataset = load_dataset(args.dataset)
+    source = dataset[args.source_split].shuffle(seed=42)
+
+    if args.limit:
+        source = source.select(range(min(args.limit, len(source))))
+
+    split = source.train_test_split(test_size=args.validation_size, seed=42)
+    train_ds = split["train"]
+    eval_ds = split["test"]
+
+    train_targets = make_targets(train_ds)
+    target_mean = train_targets.mean(dim=0)
+    target_std = torch.clamp(train_targets.std(dim=0), min=1.0)
+
+    model = CalorityNutritionCNN(output_size=len(TARGET_COLUMNS)).to(device)
+    collate_fn = make_collate_fn(args.image_column, target_mean, target_std)
+    train_loader = DataLoader(
+        train_ds,
+        batch_size=args.batch_size,
+        shuffle=True,
+        num_workers=args.num_workers,
+        collate_fn=collate_fn,
+    )
+    eval_loader = DataLoader(
+        eval_ds,
+        batch_size=args.batch_size,
+        shuffle=False,
+        num_workers=args.num_workers,
+        collate_fn=collate_fn,
+    )
+
+    loss_fn = nn.SmoothL1Loss()
+    optimizer = torch.optim.AdamW(model.parameters(), lr=args.learning_rate, weight_decay=1e-4)
+    scheduler = torch.optim.lr_scheduler.CosineAnnealingLR(optimizer, T_max=args.epochs)
+    output_dir = Path(args.output_dir)
+    best_calorie_mae = float("inf")
+
+    for epoch in range(1, args.epochs + 1):
+        model.train()
+        running_loss = 0.0
+        total_seen = 0
+
+        progress = tqdm(train_loader, desc=f"epoch {epoch}/{args.epochs}", leave=False)
+        for images, normalized_targets, _ in progress:
+            images = images.to(device)
+            normalized_targets = normalized_targets.to(device)
+
+            optimizer.zero_grad(set_to_none=True)
+            predictions = model(images)
+            loss = loss_fn(predictions, normalized_targets)
+            loss.backward()
+            optimizer.step()
+
+            running_loss += loss.item() * images.size(0)
+            total_seen += images.size(0)
+            progress.set_postfix(loss=round(running_loss / max(total_seen, 1), 4))
+
+        scheduler.step()
+        eval_loss, mae = evaluate(model, eval_loader, loss_fn, target_mean, target_std, device)
+        metric_line = ", ".join(
+            f"{column}_mae={mae[index]:.2f}" for index, column in enumerate(TARGET_COLUMNS)
+        )
+        print(f"epoch={epoch} eval_loss={eval_loss:.4f} {metric_line}")
+
+        if mae[0].item() <= best_calorie_mae:
+            best_calorie_mae = mae[0].item()
+            save_nutrition_checkpoint(model, target_mean, target_std, output_dir)
+            print(f"saved best nutrition model to {output_dir} with calorie_mae={best_calorie_mae:.2f}")
+
+    print(f"done. best_calorie_mae={best_calorie_mae:.2f}")
+
+
+if __name__ == "__main__":
+    main()

upload_model_to_hf.py

@@ -0,0 +1,40 @@
+import argparse
+import os
+from pathlib import Path
+
+from huggingface_hub import HfApi, create_repo, upload_folder
+
+
+def parse_args():
+    parser = argparse.ArgumentParser(description="Upload a trained Calority checkpoint to Hugging Face Hub.")
+    parser.add_argument("--model-dir", default="./calority-nutrition-model")
+    parser.add_argument("--repo-id", required=True, help="Example: your-username/calority-nutrition-model")
+    parser.add_argument("--private", action="store_true")
+    return parser.parse_args()
+
+
+def main():
+    args = parse_args()
+    model_dir = Path(args.model_dir)
+    if not (model_dir / "model.pt").exists():
+        raise SystemExit(f"Missing checkpoint: {model_dir / 'model.pt'}")
+    if not (model_dir / "target_stats.json").exists():
+        raise SystemExit(f"Missing target stats: {model_dir / 'target_stats.json'}")
+
+    token = os.getenv("HF_TOKEN")
+    api = HfApi(token=token)
+    create_repo(args.repo_id, repo_type="model", private=args.private, exist_ok=True, token=token)
+    upload_folder(
+        repo_id=args.repo_id,
+        repo_type="model",
+        folder_path=str(model_dir),
+        path_in_repo=".",
+        commit_message="Upload Calority nutrition model checkpoint",
+        token=token,
+    )
+    info = api.model_info(args.repo_id, token=token)
+    print(f"Uploaded checkpoint to https://huggingface.co/{info.modelId}")
+
+
+if __name__ == "__main__":
+    main()

upload_space_to_hf.py

@@ -0,0 +1,47 @@
+import argparse
+import os
+from pathlib import Path
+
+from huggingface_hub import create_repo, upload_folder
+
+
+def parse_args():
+    parser = argparse.ArgumentParser(description="Upload the Calority model API to a Hugging Face Docker Space.")
+    parser.add_argument("--space-id", required=True, help="Example: your-username/calority-model-api")
+    parser.add_argument("--private", action="store_true")
+    return parser.parse_args()
+
+
+def main():
+    args = parse_args()
+    token = os.getenv("HF_TOKEN")
+    create_repo(
+        args.space_id,
+        repo_type="space",
+        space_sdk="docker",
+        private=args.private,
+        exist_ok=True,
+        token=token,
+    )
+    upload_folder(
+        repo_id=args.space_id,
+        repo_type="space",
+        folder_path=str(Path(__file__).parent),
+        path_in_repo=".",
+        commit_message="Deploy Calority model API",
+        ignore_patterns=[
+            ".env",
+            "__pycache__/*",
+            "*.pyc",
+            "calority-model-api/*",
+            "calority-nutrition-model/*",
+            "calority-scratch-model/*",
+            "calority-food-model/*",
+        ],
+        token=token,
+    )
+    print(f"Uploaded Space files to https://huggingface.co/spaces/{args.space_id}")
+
+
+if __name__ == "__main__":
+    main()