Update app.py

app.py

@@ -0,0 +1,139 @@
+import time, math
+import gradio as gr
+import torch
+import numpy as np
+import matplotlib.pyplot as plt
+from transformers import AutoImageProcessor, AutoModelForImageClassification
+
+# --- Model choice (CPU-friendly) ---
+MODEL_ID = "google/vit-base-patch16-224"  # alternatives: "microsoft/resnet-50", "facebook/convnext-tiny-224"
+
+# Load once at startup
+processor = AutoImageProcessor.from_pretrained(MODEL_ID)
+model = AutoModelForImageClassification.from_pretrained(MODEL_ID)
+model.eval()
+LABELS = model.config.id2label  # {idx: "label"}
+
+def _softmax_with_temperature(logits: torch.Tensor, temperature: float) -> torch.Tensor:
+    """Softmax(logits / T) with numerical stability."""
+    if temperature <= 0:
+        temperature = 1.0
+    scaled = logits / float(temperature)
+    # subtract max for numerical stability
+    scaled = scaled - torch.max(scaled)
+    exp = torch.exp(scaled)
+    return exp / torch.sum(exp)
+
+def _entropy(probs: np.ndarray) -> float:
+    """Shannon entropy in nats: -Σ p log p (ignore zeros)."""
+    p = probs[probs > 0]
+    return float(-(p * np.log(p)).sum())
+
+def _make_bar(labels, probs):
+    """Return a matplotlib horizontal bar chart of top-K probabilities."""
+    fig, ax = plt.subplots(figsize=(6, 3.2))
+    y = np.arange(len(labels))
+    ax.barh(y, probs)  # do not set colors (keep default)
+    ax.set_yticks(y, labels)
+    ax.invert_yaxis()
+    ax.set_xlim(0, 1)
+    ax.set_xlabel("Probability")
+    ax.set_title("Top-K predicted classes")
+    fig.tight_layout()
+    return fig
+
+def analyze(img, top_k=5, temperature=1.0):
+    """
+    Run the image through the classifier and expose:
+      - Top-K probabilities (bar chart + table)
+      - Pre-softmax logits for those Top-K
+      - Uncertainty metrics (entropy; top-1 margin; cumulative top-K)
+      - Preprocessing info and inference time
+    """
+    if img is None:
+        return (
+            {"<no image>": 1.0},   # quick glance label block
+            None,                  # bar plot
+            [],                    # table rows
+            "Please upload an image.",  # metrics markdown
+        )
+
+    t0 = time.perf_counter()
+    inputs = processor(images=img, return_tensors="pt")
+    with torch.no_grad():
+        outputs = model(**inputs)
+    logits = outputs.logits[0]  # shape [num_labels]
+    # Temperature-scaled softmax
+    probs = _softmax_with_temperature(logits, temperature)
+    # Top-K
+    k = max(1, int(top_k))
+    k = min(k, probs.shape[0])
+    top_vals, top_idx = torch.topk(probs, k=k, dim=-1)
+    top_idx = top_idx.tolist()
+    top_vals = top_vals.tolist()
+
+    labels = [LABELS[i] for i in top_idx]
+    logits_top = [float(logits[i]) for i in top_idx]
+
+    # Quick glance dict for gr.Label (keeps students oriented)
+    quick = {lab: float(p) for lab, p in zip(labels, top_vals)}
+
+    # Bar chart
+    fig = _make_bar(labels, top_vals)
+
+    # Table rows (Rank, Label, Probability, Logit)
+    rows = []
+    for rank, (lab, p, lg) in enumerate(zip(labels, top_vals, logits_top), start=1):
+        rows.append([rank, lab, round(float(p), 6), round(float(lg), 6)])
+
+    # Metrics
+    probs_np = probs.detach().cpu().numpy()
+    H = _entropy(probs_np)
+    top1 = float(top_vals[0])
+    top2 = float(top_vals[1]) if len(top_vals) > 1 else 0.0
+    margin = top1 - top2
+    cum_topk = float(sum(top_vals))
+    infer_ms = (time.perf_counter() - t0) * 1000.0
+
+    # Preprocessing info (resize/crop) from processor config if available
+    size = processor.size if hasattr(processor, "size") else {}
+    target_h = size.get("height", None)
+    target_w = size.get("width", None)
+    size_str = f"{target_h}×{target_w}" if (target_h and target_w) else "model default"
+
+    md = (
+        f"**Uncertainty**  \n"
+        f"- Entropy (lower→more confident): **{H:.3f} nats**  \n"
+        f"- Top-1 margin (Top-1 − Top-2): **{margin:.3f}**  \n"
+        f"- Cumulative Top-K probability: **{cum_topk:.3f}**  \n\n"
+        f"**Preprocessing & Runtime**  \n"
+        f"- Processor target size: **{size_str}**  \n"
+        f"- Inference time: **{infer_ms:.1f} ms** (CPU)  \n\n"
+        f"_Tip:_ Adjust **Temperature** to watch softmax sharpen (T<1) or soften (T>1) the distribution."
+    )
+
+    return quick, fig, rows, md
+
+with gr.Blocks(fill_height=True, analytics_enabled=False) as demo:
+    gr.Markdown("# 🖼️ Image Classification — ‘Watch the Decision’\nUpload an image, then watch the classifier’s probabilities, logits, and uncertainty metrics update.")
+
+    with gr.Row():
+        with gr.Column(scale=1):
+            img = gr.Image(type="pil", label="Upload an image (JPEG/PNG)", height=360)
+            topk = gr.Slider(1, 10, value=5, step=1, label="Top-K predictions")
+            temp = gr.Slider(0.25, 2.0, value=1.0, step=0.05, label="Softmax Temperature")
+            run = gr.Button("Analyze", variant="primary")
+        with gr.Column(scale=1):
+            gr.Markdown("### Quick glance")
+            glance = gr.Label(num_top_classes=10)
+            gr.Markdown("### Probabilities (Top-K)")
+            plot = gr.Plot()
+            gr.Markdown("### Details (Top-K)")
+            table = gr.Dataframe(headers=["Rank", "Label", "Probability", "Logit"], datatype=["number", "str", "number", "number"], row_count=5)
+            gr.Markdown("### Metrics & Notes")
+            notes = gr.Markdown()
+
+    run.click(analyze, [img, topk, temp], [glance, plot, table, notes])
+
+if __name__ == "__main__":
+    demo.launch()