Initial app

.gitignore

@@ -0,0 +1,4 @@
+__pycache__/
+*.pyc
+.gradio/
+flagged/

README.md

@@ -1,12 +1,27 @@
 ---
 title: Denoise Judging
-emoji: 🐠
-colorFrom: indigo
-colorTo: red
+emoji: 🔬
+colorFrom: blue
+colorTo: indigo
 sdk: gradio
-sdk_version: 6.14.0
+sdk_version: 5.49.1
 app_file: app.py
 pinned: false
+short_description: Blind A/B judging of denoised microscopy images
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# Denoise Judging
+
+Blind A/B judging Space for the Stemson-AI denoising experiments.
+
+- Reads triplets (`raw`, `cimp_gan`, `n2v`) from the private dataset
+  `Stemson-AI/denoise-judging-triplets`.
+- Writes one judgment per JSON file to the private dataset
+  `Stemson-AI/denoise-judgments`.
+- De-duplicates by email: a user only sees triplets they have not yet judged.
+
+## Required Space secret
+
+- `HF_TOKEN` — fine-grained token with **read** access to
+  `Stemson-AI/denoise-judging-triplets` and **write** access to
+  `Stemson-AI/denoise-judgments`.

app.py

@@ -0,0 +1,343 @@
+"""Blind A/B judging Space for denoised images.
+
+Reads triplets from a private HF dataset and writes one JSON per judgment
+to a separate private results dataset.
+
+Required Space secret: HF_TOKEN (write access to RESULTS_REPO).
+"""
+
+from __future__ import annotations
+
+import io
+import json
+import os
+import random
+import re
+import uuid
+from datetime import datetime, timezone
+from pathlib import Path
+
+import gradio as gr
+from huggingface_hub import HfApi, list_repo_files, snapshot_download
+
+TRIPLETS_REPO = "Stemson-AI/denoise-judging-triplets"
+RESULTS_REPO = "Stemson-AI/denoise-judgments"
+
+HF_TOKEN = os.environ.get("HF_TOKEN")
+if not HF_TOKEN:
+    print("WARNING: HF_TOKEN not set; reads/writes to private repos will fail.")
+
+api = HfApi(token=HF_TOKEN)
+
+EMAIL_RE = re.compile(r"^[^@\s]+@[^@\s]+\.[^@\s]+$")
+
+
+def load_triplets() -> tuple[Path, list[dict]]:
+    local = snapshot_download(
+        repo_id=TRIPLETS_REPO,
+        repo_type="dataset",
+        token=HF_TOKEN,
+    )
+    root = Path(local)
+    rows: list[dict] = []
+    with open(root / "metadata.jsonl") as f:
+        for line in f:
+            line = line.strip()
+            if line:
+                rows.append(json.loads(line))
+    return root, rows
+
+
+def email_slug(email: str) -> str:
+    return re.sub(r"[^a-z0-9]+", "_", email.strip().lower()).strip("_")
+
+
+def already_judged(email: str) -> set[str]:
+    """Return triplet_ids the user has already judged, by inspecting filenames."""
+    slug = email_slug(email)
+    try:
+        files = list_repo_files(RESULTS_REPO, repo_type="dataset", token=HF_TOKEN)
+    except Exception as exc:
+        print(f"list_repo_files failed: {exc!r}")
+        return set()
+    done: set[str] = set()
+    prefix = f"judgments/{slug}__"
+    for f in files:
+        if not f.startswith(prefix) or not f.endswith(".json"):
+            continue
+        # judgments/<slug>__<triplet_id>__<ts>.json
+        stem = f[len(prefix) : -len(".json")]
+        parts = stem.split("__")
+        if len(parts) >= 2:
+            done.add("__".join(parts[:-1]))
+    return done
+
+
+TRIPLETS_ROOT, TRIPLETS = load_triplets()
+TRIPLET_BY_ID = {r["triplet_id"]: r for r in TRIPLETS}
+print(f"loaded {len(TRIPLETS)} triplets from {TRIPLETS_ROOT}")
+
+
+# ---------- session helpers ---------------------------------------------------
+
+
+def _empty_session() -> dict:
+    return {
+        "name": "",
+        "email": "",
+        "session_id": "",
+        "queue": [],          # list of triplet_ids remaining
+        "idx": 0,             # pointer into queue
+        "left_method": "",    # which method is shown on the left this turn
+        "right_method": "",   # which method is shown on the right this turn
+        "n_done_now": 0,      # judgments made this session
+        "n_total": 0,         # queue length at session start
+        "n_already": 0,       # triplet count user had already judged before login
+    }
+
+
+def _paths_for_current(session: dict) -> tuple[str, str, str] | None:
+    if session["idx"] >= len(session["queue"]):
+        return None
+    tid = session["queue"][session["idx"]]
+    rec = TRIPLET_BY_ID[tid]
+    raw = str(TRIPLETS_ROOT / rec["raw"])
+    left = str(TRIPLETS_ROOT / rec[session["left_method"]])
+    right = str(TRIPLETS_ROOT / rec[session["right_method"]])
+    return raw, left, right
+
+
+def _assign_sides(session: dict) -> None:
+    methods = ["cimp_gan", "n2v"]
+    random.shuffle(methods)
+    session["left_method"], session["right_method"] = methods
+
+
+def _progress(session: dict) -> str:
+    total = session["n_total"]
+    done = session["n_done_now"]
+    if total == 0:
+        return "All 60 triplets are already judged for this email — thank you!"
+    return f"Triplet {min(done + 1, total)} / {total} this session  •  {session['n_already']} already done before"
+
+
+# ---------- handlers ----------------------------------------------------------
+
+
+def start(name: str, email: str):
+    name = (name or "").strip()
+    email = (email or "").strip().lower()
+    if not name:
+        return (
+            gr.update(),  # login_group
+            gr.update(),  # judging_group
+            gr.update(value="Please enter your name.", visible=True),  # error_md
+            gr.update(), gr.update(), gr.update(),  # raw, left, right
+            gr.update(),  # progress
+            _empty_session(),
+            gr.update(), gr.update(),  # buttons A/B interactivity
+            gr.update(),  # done_md
+        )
+    if not EMAIL_RE.match(email):
+        return (
+            gr.update(),
+            gr.update(),
+            gr.update(value="Please enter a valid email.", visible=True),
+            gr.update(), gr.update(), gr.update(),
+            gr.update(),
+            _empty_session(),
+            gr.update(), gr.update(),
+            gr.update(),
+        )
+
+    done = already_judged(email)
+    remaining = [r["triplet_id"] for r in TRIPLETS if r["triplet_id"] not in done]
+    rng = random.Random(f"{email}|{uuid.uuid4()}")
+    rng.shuffle(remaining)
+
+    session = _empty_session()
+    session.update(
+        name=name,
+        email=email,
+        session_id=str(uuid.uuid4()),
+        queue=remaining,
+        idx=0,
+        n_total=len(remaining),
+        n_already=len(done),
+    )
+
+    if not remaining:
+        return (
+            gr.update(visible=False),
+            gr.update(visible=True),
+            gr.update(visible=False),
+            gr.update(value=None), gr.update(value=None), gr.update(value=None),
+            gr.update(value=_progress(session)),
+            session,
+            gr.update(interactive=False), gr.update(interactive=False),
+            gr.update(value="Nothing left to judge for this email. Thank you!", visible=True),
+        )
+
+    _assign_sides(session)
+    raw, left, right = _paths_for_current(session)
+
+    return (
+        gr.update(visible=False),
+        gr.update(visible=True),
+        gr.update(visible=False),
+        gr.update(value=raw),
+        gr.update(value=left),
+        gr.update(value=right),
+        gr.update(value=_progress(session)),
+        session,
+        gr.update(interactive=True), gr.update(interactive=True),
+        gr.update(visible=False),
+    )
+
+
+def _write_judgment(session: dict, chosen_side: str) -> None:
+    tid = session["queue"][session["idx"]]
+    chosen_method = (
+        session["left_method"] if chosen_side == "A" else session["right_method"]
+    )
+    ts = datetime.now(timezone.utc).strftime("%Y%m%dT%H%M%SZ")
+    payload = {
+        "ts": datetime.now(timezone.utc).isoformat(),
+        "user_name": session["name"],
+        "user_email": session["email"],
+        "triplet_id": tid,
+        "left_method": session["left_method"],
+        "right_method": session["right_method"],
+        "chosen_side": chosen_side,
+        "chosen_method": chosen_method,
+        "session_id": session["session_id"],
+    }
+    path = f"judgments/{email_slug(session['email'])}__{tid}__{ts}.json"
+    api.upload_file(
+        path_or_fileobj=io.BytesIO(json.dumps(payload, indent=2).encode()),
+        path_in_repo=path,
+        repo_id=RESULTS_REPO,
+        repo_type="dataset",
+        commit_message=f"judgment {tid} by {session['email']}",
+    )
+
+
+def choose(side: str, session: dict):
+    if not session.get("queue") or session["idx"] >= len(session["queue"]):
+        return (
+            gr.update(), gr.update(), gr.update(),
+            gr.update(),
+            session,
+            gr.update(interactive=False), gr.update(interactive=False),
+            gr.update(value="No more triplets.", visible=True),
+        )
+    try:
+        _write_judgment(session, side)
+    except Exception as exc:
+        return (
+            gr.update(), gr.update(), gr.update(),
+            gr.update(value=_progress(session)),
+            session,
+            gr.update(interactive=True), gr.update(interactive=True),
+            gr.update(value=f"Could not save judgment: {exc!r}", visible=True),
+        )
+
+    session["idx"] += 1
+    session["n_done_now"] += 1
+
+    if session["idx"] >= len(session["queue"]):
+        return (
+            gr.update(value=None), gr.update(value=None), gr.update(value=None),
+            gr.update(value=f"All {session['n_total']} triplets done — thank you!"),
+            session,
+            gr.update(interactive=False), gr.update(interactive=False),
+            gr.update(
+                value=f"All done! You judged {session['n_done_now']} triplets this session.",
+                visible=True,
+            ),
+        )
+
+    _assign_sides(session)
+    raw, left, right = _paths_for_current(session)
+    return (
+        gr.update(value=raw), gr.update(value=left), gr.update(value=right),
+        gr.update(value=_progress(session)),
+        session,
+        gr.update(interactive=True), gr.update(interactive=True),
+        gr.update(visible=False),
+    )
+
+
+# ---------- UI ----------------------------------------------------------------
+
+
+with gr.Blocks(title="Denoising A/B Judging", theme=gr.themes.Soft()) as demo:
+    session_state = gr.State(_empty_session())
+
+    gr.Markdown("# Denoising A/B Judging")
+    gr.Markdown(
+        "For each triplet you'll see a **raw** image and two denoised options "
+        "(**A** and **B**). Pick the one you think is the better denoising. "
+        "Click any image to zoom in."
+    )
+
+    with gr.Group(visible=True) as login_group:
+        gr.Markdown("### Sign in to start")
+        name_in = gr.Textbox(label="Name", placeholder="Your name")
+        email_in = gr.Textbox(label="Email", placeholder="you@example.com")
+        start_btn = gr.Button("Start judging", variant="primary")
+        login_error = gr.Markdown(visible=False)
+
+    with gr.Group(visible=False) as judging_group:
+        progress_md = gr.Markdown("")
+        with gr.Row():
+            raw_img = gr.Image(
+                label="Raw",
+                type="filepath",
+                interactive=False,
+                show_download_button=False,
+                show_fullscreen_button=True,
+                height=420,
+            )
+        with gr.Row():
+            with gr.Column():
+                left_img = gr.Image(
+                    label="Option A",
+                    type="filepath",
+                    interactive=False,
+                    show_download_button=False,
+                    show_fullscreen_button=True,
+                    height=420,
+                )
+                a_btn = gr.Button("A is better", variant="primary")
+            with gr.Column():
+                right_img = gr.Image(
+                    label="Option B",
+                    type="filepath",
+                    interactive=False,
+                    show_download_button=False,
+                    show_fullscreen_button=True,
+                    height=420,
+                )
+                b_btn = gr.Button("B is better", variant="primary")
+        done_md = gr.Markdown(visible=False)
+
+    start_outputs = [
+        login_group, judging_group, login_error,
+        raw_img, left_img, right_img,
+        progress_md, session_state,
+        a_btn, b_btn, done_md,
+    ]
+    start_btn.click(start, inputs=[name_in, email_in], outputs=start_outputs)
+
+    choose_outputs = [
+        raw_img, left_img, right_img,
+        progress_md, session_state,
+        a_btn, b_btn, done_md,
+    ]
+    a_btn.click(lambda s: choose("A", s), inputs=[session_state], outputs=choose_outputs)
+    b_btn.click(lambda s: choose("B", s), inputs=[session_state], outputs=choose_outputs)
+
+
+if __name__ == "__main__":
+    demo.launch()

requirements.txt

@@ -0,0 +1,2 @@
+gradio>=5.0
+huggingface_hub>=0.26