Upload 3 files

app.py

@@ -1,70 +1,40 @@
-import gradio as gr
-from huggingface_hub import InferenceClient
-
-
-def respond(
-    message,
-    history: list[dict[str, str]],
-    system_message,
-    max_tokens,
-    temperature,
-    top_p,
-    hf_token: gr.OAuthToken,
-):
-    """
-    For more information on `huggingface_hub` Inference API support, please check the docs: https://huggingface.co/docs/huggingface_hub/v0.22.2/en/guides/inference
-    """
-    client = InferenceClient(token=hf_token.token, model="openai/gpt-oss-20b")
-
-    messages = [{"role": "system", "content": system_message}]
-
-    messages.extend(history)
-
-    messages.append({"role": "user", "content": message})
-
-    response = ""
-
-    for message in client.chat_completion(
-        messages,
-        max_tokens=max_tokens,
-        stream=True,
-        temperature=temperature,
-        top_p=top_p,
-    ):
-        choices = message.choices
-        token = ""
-        if len(choices) and choices[0].delta.content:
-            token = choices[0].delta.content
-
-        response += token
-        yield response
-
-
-"""
-For information on how to customize the ChatInterface, peruse the gradio docs: https://www.gradio.app/docs/chatinterface
-"""
-chatbot = gr.ChatInterface(
-    respond,
-    type="messages",
-    additional_inputs=[
-        gr.Textbox(value="You are a friendly Chatbot.", label="System message"),
-        gr.Slider(minimum=1, maximum=2048, value=512, step=1, label="Max new tokens"),
-        gr.Slider(minimum=0.1, maximum=4.0, value=0.7, step=0.1, label="Temperature"),
-        gr.Slider(
-            minimum=0.1,
-            maximum=1.0,
-            value=0.95,
-            step=0.05,
-            label="Top-p (nucleus sampling)",
-        ),
-    ],
-)
-
-with gr.Blocks() as demo:
-    with gr.Sidebar():
-        gr.LoginButton()
-    chatbot.render()
-
-
-if __name__ == "__main__":
-    demo.launch()
+# app.py
+import os
+os.environ["TRANSFORMERS_NO_TF"] = "1"
+os.environ["TRANSFORMERS_NO_FLAX"] = "1"
+os.environ["TF_CPP_MIN_LOG_LEVEL"] = "3"
+
+import gradio as gr
+from PIL import Image
+from hf_model import PretrainedAgeEstimator
+
+est = PretrainedAgeEstimator()
+
+def predict(img):
+    # Gradio may pass PIL or numpy; handle both
+    if not isinstance(img, Image.Image):
+        img = Image.fromarray(img)
+
+    age, top = est.predict(img, topk=5)
+
+    # 1) dict[str, float] for Label
+    probs = {lbl: float(prob) for lbl, prob in top}
+
+    # 2) plain string for the estimate
+    summary = f"Estimated age: **{age:.1f}** years"
+
+    return probs, summary
+
+demo = gr.Interface(
+    fn=predict,
+    inputs=gr.Image(type="pil", label="Upload a face image"),
+    outputs=[
+        gr.Label(num_top_classes=5, label="Age Prediction (probabilities)"),
+        gr.Markdown(label="Summary"),
+    ],
+    title="Pretrained Age Estimator",
+    description="Runs a pretrained ViT-based age classifier and reports a point estimate from class probabilities."
+)
+
+if __name__ == "__main__":
+    demo.launch(share=True)

hf_model.py

@@ -0,0 +1,73 @@
+# hf_model.py
+# ---- keep TF/JAX silent and unused ----
+import os
+os.environ["TRANSFORMERS_NO_TF"] = "1"      # don't load TensorFlow
+os.environ["TRANSFORMERS_NO_FLAX"] = "1"   # don't load Flax/JAX
+os.environ["TF_CPP_MIN_LOG_LEVEL"] = "3"   # silence TF C++ logs (INFO/WARN)
+
+# optional: extra hush
+try:
+    from transformers.utils import logging as hf_logging
+    hf_logging.set_verbosity_error()
+    import tensorflow as tf
+    tf.get_logger().setLevel("ERROR")
+    import absl.logging
+    absl.logging.set_verbosity(absl.logging.ERROR)
+except Exception:
+    pass
+
+
+
+from typing import Dict, List, Tuple
+from PIL import Image
+import torch
+from transformers import AutoImageProcessor, AutoModelForImageClassification
+
+
+
+# A solid, ready-made age classifier (ViT backbone).
+# It predicts age ranges as classes; we map ranges -> a point estimate.
+HF_MODEL_ID = "nateraw/vit-age-classifier"
+
+# Map model class labels to numeric midpoints for an age estimate
+# (these labels come with the above model).
+AGE_RANGE_TO_MID = {
+    "0-2": 1, "3-9": 6, "10-19": 15, "20-29": 25, "30-39": 35,
+    "40-49": 45, "50-59": 55, "60-69": 65, "70+": 75
+}
+
+class PretrainedAgeEstimator:
+    def __init__(self, model_id: str = HF_MODEL_ID, device: str | None = None, use_fast: bool = True):
+        self.device = device or ("cuda" if torch.cuda.is_available() else "cpu")
+        self.processor = AutoImageProcessor.from_pretrained(model_id, use_fast=True)
+
+        self.model = AutoModelForImageClassification.from_pretrained(model_id)
+        self.model.to(self.device).eval()
+
+        # keep label mapping
+        self.id2label: Dict[int, str] = self.model.config.id2label
+        self.label2id: Dict[str, int] = self.model.config.label2id
+
+    @torch.inference_mode()
+    def predict(self, img: Image.Image, topk: int = 3) -> Tuple[float, List[Tuple[str, float]]]:
+        """Return (point_estimate_age, [(label, prob), ...])."""
+        if img.mode != "RGB":
+            img = img.convert("RGB")
+
+        inputs = self.processor(images=img, return_tensors="pt").to(self.device)
+        logits = self.model(**inputs).logits
+        probs = logits.softmax(dim=-1).squeeze(0)  # [num_classes]
+
+        # Top-k labels
+        topk = min(topk, probs.numel())
+        values, indices = torch.topk(probs, k=topk)
+        top = [(self.id2label[i.item()], v.item()) for i, v in zip(indices, values)]
+
+        # Point estimate from expectation over range midpoints
+        expected = 0.0
+        for i, p in enumerate(probs):
+            label = self.id2label[i]
+            mid = AGE_RANGE_TO_MID.get(label, 35)  # default mid if unseen label
+            expected += mid * p.item()
+
+        return expected, top

infer.py

@@ -0,0 +1,18 @@
+# infer.py
+from PIL import Image
+from hf_model import PretrainedAgeEstimator
+
+def predict_age(image_path: str):
+    est = PretrainedAgeEstimator()
+    img = Image.open(image_path)
+    age, top = est.predict(img, topk=3)
+    return age, top
+
+if __name__ == "__main__":
+    import sys, json
+    path = sys.argv[1]
+    age, top = predict_age(path)
+    print(json.dumps({
+        "estimated_age": round(age, 1),
+        "top_classes": [(lbl, round(prob, 4)) for lbl, prob in top]
+    }, indent=2))