Upload 3 files

DEPLOY.md

@@ -0,0 +1,111 @@
+# Deploying the Face Attribute Classifier (Gradio) to Hugging Face Spaces
+
+## Why Gradio instead of Docker
+Hugging Face changed its free-tier policy: creating a Docker Space now
+requires a paid plan. The one remaining free path for personal accounts
+is **up to 2 Gradio Spaces on ZeroGPU hardware** — free, no card needed.
+
+"ZeroGPU hardware" sounds GPU-specific, but it isn't mandatory to use one.
+A GPU is only allocated to functions you explicitly wrap with
+`@spaces.GPU`. Since `app.py` in this package doesn't use that decorator
+anywhere, the app just runs on the container's CPU — which is exactly
+what three small classification models need.
+
+## What this app does differently from your original Flask repo
+Same logic as before — face-crop via Roboflow, then classify age/gender/
+race — but:
+- **Rebuilt as a Gradio app** (`gr.Interface`) instead of Flask routes +
+  HTML templates, since that's what the free tier now requires.
+- **Age/gender/race run locally** via `transformers.pipeline(...)`
+  instead of calling Hugging Face's shared Inference API — that's the
+  service that stopped serving the gender/race models, so this sidesteps
+  the problem entirely rather than depending on it.
+- **Roboflow key read from an environment variable** (a Space secret),
+  not hardcoded in the source.
+
+## 1. Create the Space
+1. Go to https://huggingface.co/new-space (free account is fine).
+2. Space name: `face-attribute-classifier` (or whatever you like).
+3. License: anything (MIT is fine).
+4. SDK: **Gradio**.
+5. Hardware: it will likely default to or only offer **ZeroGPU** on a
+   free account — that's fine, leave it. We're not using the GPU.
+6. Visibility: **Public**.
+7. Click **Create Space**.
+
+## 2. Add the files
+```bash
+git clone https://huggingface.co/spaces/<your-username>/face-attribute-classifier
+cd face-attribute-classifier
+
+cp /path/to/face-classifier-deploy/app.py .
+cp /path/to/face-classifier-deploy/README.md .
+```
+You also need a `requirements.txt` with at minimum:
+```
+gradio
+transformers
+torch --index-url https://download.pytorch.org/whl/cpu
+pillow
+requests
+```
+(Gradio Spaces install `requirements.txt` automatically — no Dockerfile
+needed this time.)
+
+## 3. Set the Roboflow key as a secret
+Space **Settings** tab → **Repository secrets** → add:
+- Name: `ROBOFLOW_API_KEY`
+- Value: your Roboflow key (worth regenerating it first, since the
+  original was sitting in plain text in a public GitHub repo)
+
+## 4. Push
+```bash
+git add .
+git commit -m "Deploy face attribute classifier (Gradio, local inference)"
+git push
+```
+First build will take a few minutes — downloading PyTorch plus three
+model checkpoints. Watch the **Building** then **Logs** tab; you should
+see "Loading race/age/gender models" on startup.
+
+## 5. Test it
+Once **Running**, open:
+```
+https://<your-username>-face-attribute-classifier.hf.space
+```
+You'll see Gradio's own UI (an upload box + three output fields) —
+upload a face photo and confirm age/gender/ethnicity all come back
+correctly.
+
+## 6. Calling it programmatically (for the Cloudflare Worker)
+Gradio apps expose a REST API automatically. Because `api_name="classify"`
+is set in `app.py`, the calling pattern is:
+
+1. **POST** to `https://<your-space-url>/gradio_api/call/classify`
+   with a JSON body containing the image (as a data URI) in Gradio's
+   expected input format. This returns an `event_id`.
+2. **GET** `https://<your-space-url>/gradio_api/call/classify/<event_id>`
+   to stream the result back (Server-Sent Events).
+
+This two-step flow is a bit more involved than the single POST/JSON
+round-trip Roboflow used. Rather than guess the exact payload shape
+sight-unseen, once your Space is live:
+- Open it in a browser, use the built-in UI to classify a photo once
+- Open DevTools → Network tab, find the two calls above, and copy their
+  exact request/response bodies
+
+Send those to me and I'll write the Worker's `/face` route to match
+exactly, and re-enable the "Try It" button on the portfolio.
+
+## Notes
+- Free tier sleeps after inactivity, cold start on next visit.
+- Model weights get cached after the first load, so cold starts are
+  "reload from cache," not "re-download from the internet."
+- **Heads up on sketchful.AI**: that Docker Space deployment we set up
+  earlier — if you haven't actually created and pushed that Space yet,
+  it's now blocked by this same policy change (creating a *new* Docker
+  Space requires a paid plan). If you already created it before the
+  policy changed, it should keep running fine; only new creation is
+  affected. Worth checking its status — if it needs to move too, that
+  one could go Gradio as well, or we could weigh a $9/mo Pro plan if
+  you end up wanting more than 2 Spaces total.

README.md

@@ -1,13 +1,18 @@
 ---
 title: Face Attribute Classifier
-emoji: 🐢
-colorFrom: indigo
-colorTo: purple
+emoji: 🧑
+colorFrom: gray
+colorTo: blue
 sdk: gradio
-sdk_version: 6.25.0
-python_version: '3.12'
 app_file: app.py
 pinned: false
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# Face Attribute Classifier
+
+Predicts age, gender, and ethnicity from a face image. Runs entirely
+locally in this Space (via `transformers`) — no dependency on Hugging
+Face's shared serverless Inference API.
+
+Built with Gradio. See the original Flask version for reference:
+https://github.com/bUZgy/race-age-gender-classifier

app.py

@@ -0,0 +1,98 @@
+import os
+import base64
+import requests
+import gradio as gr
+from PIL import Image
+from transformers import pipeline
+
+# --- Roboflow face-detection key, read from a Space secret (not hardcoded) ---
+ROBOFLOW_API_KEY = os.environ.get("ROBOFLOW_API_KEY", "")
+
+# --- Load all three classifiers once at startup ---
+# These run locally in this container via `transformers`, instead of calling
+# Hugging Face's shared serverless Inference API (which no longer serves the
+# gender/race models — only age currently has an attached provider).
+# No @spaces.GPU decorator needed — these are small, CPU-friendly models,
+# so they just run on the free CPU container as normal.
+print("Loading race/age/gender models — this can take a bit on first boot...")
+race_pipe = pipeline("image-classification", model="crangana/trained-race")
+age_pipe = pipeline("image-classification", model="crangana/trained-age")
+gender_pipe = pipeline("image-classification", model="crangana/trained-gender")
+print("Models loaded.")
+
+
+def crop_face(image_path):
+    """Detect and crop the face using Roboflow's hosted face detector."""
+    with open(image_path, "rb") as image_file:
+        image_base64 = base64.b64encode(image_file.read()).decode("utf-8")
+
+    url = "https://detect.roboflow.com/face-det-npvna/1"
+    params = {"api_key": ROBOFLOW_API_KEY}
+    headers = {"Content-Type": "application/x-www-form-urlencoded"}
+
+    response = requests.post(url, params=params, data=image_base64, headers=headers)
+    crop_data = response.json()
+
+    if not crop_data.get("predictions"):
+        raise ValueError("No face detected in the image.")
+
+    pred = crop_data["predictions"][0]
+    width, height = pred["width"], pred["height"]
+    x = pred["x"] - width / 2
+    y = pred["y"] - height / 2
+
+    image = Image.open(image_path)
+    cropped = image.crop((x, y, x + width, y + height))
+
+    cropped_path = "/tmp/cropped_face.jpg"
+    cropped.save(cropped_path)
+    return cropped_path
+
+
+def get_top(results):
+    """Pick the highest-confidence label from a list of {label, score} dicts."""
+    best = max(results, key=lambda r: r["score"])
+    return best["label"], best["score"]
+
+
+def classify(image):
+    if image is None:
+        return "No image provided.", "", ""
+
+    tmp_path = "/tmp/input_face.jpg"
+    image.convert("RGB").save(tmp_path)
+
+    try:
+        cropped_path = crop_face(tmp_path)
+    except Exception as e:
+        return f"Face detection failed: {e}", "—", "—"
+
+    try:
+        age_label, age_score = get_top(age_pipe(cropped_path))
+        gender_label, gender_score = get_top(gender_pipe(cropped_path))
+        race_label, race_score = get_top(race_pipe(cropped_path))
+    except Exception as e:
+        return f"Classification failed: {e}", "—", "—"
+
+    return (
+        f"{age_label} ({age_score:.0%})",
+        f"{gender_label} ({gender_score:.0%})",
+        f"{race_label} ({race_score:.0%})",
+    )
+
+
+demo = gr.Interface(
+    fn=classify,
+    inputs=gr.Image(type="pil", label="Upload a face photo"),
+    outputs=[
+        gr.Textbox(label="Age"),
+        gr.Textbox(label="Gender"),
+        gr.Textbox(label="Ethnicity"),
+    ],
+    title="Face Attribute Classifier",
+    description="Predicts age, gender, and ethnicity from a face photo.",
+    api_name="classify",  # names the programmatic API endpoint /gradio_api/call/classify
+)
+
+if __name__ == "__main__":
+    demo.launch()