| """
|
| PromptOps Arena — HF Space demo (Gradio).
|
|
|
| Tabs:
|
| 1. Try the env: pick a task, edit a system prompt, see the LLM-under-test
|
| respond + the per-component reward. Up to 3 edit turns per episode.
|
| 2. Reward curve: training_log.jsonl rolling avg over GRPO rollouts.
|
| 3. Baselines vs trained agent: bar chart of mean reward / accuracy.
|
|
|
| The frozen LLM-under-test runs in-process. ZeroGPU is used at first inference.
|
| """
|
|
|
| from __future__ import annotations
|
|
|
| import json
|
| import os
|
| import sys
|
| from pathlib import Path
|
| from typing import Any, Dict, List, Tuple
|
|
|
|
|
| sys.path.insert(0, str(Path(__file__).resolve().parent))
|
|
|
| import gradio as gr
|
|
|
|
|
| os.environ.setdefault("PROMPTOPS_LLM_BACKEND", "transformers")
|
|
|
| from src.envs.promptops_arena.server.environment import PromptOpsArenaEnvironment
|
| from src.envs.promptops_arena.tasks import load_tasks
|
|
|
| ENV = PromptOpsArenaEnvironment(split="test", seed=0)
|
| ALL_TASKS: List[dict] = load_tasks(split="test")
|
| TASKS_BY_ID: Dict[str, dict] = {t["id"]: t for t in ALL_TASKS}
|
|
|
|
|
| SUGGESTED_PROMPTS = {
|
| "math": (
|
| "You are a careful math solver. Solve step by step internally, then "
|
| "output ONLY the final numeric answer inside <answer>...</answer> tags. "
|
| "No units, no extra words."
|
| ),
|
| "code": (
|
| "You are a Python coder. Output exactly one ```python ...``` code block "
|
| "containing only the requested function definition. No prose, no examples."
|
| ),
|
| "json": (
|
| "You are a JSON extractor. Output exactly one ```json ...``` code block "
|
| "containing a valid JSON object that matches the schema. No prose."
|
| ),
|
| }
|
|
|
|
|
| def list_task_choices() -> List[Tuple[str, str]]:
|
| out: List[Tuple[str, str]] = []
|
| for t in ALL_TASKS:
|
| label = f"[{t['type']}] {t['id']}: {t['question'][:70]}"
|
| out.append((label, t["id"]))
|
| return out
|
|
|
|
|
| def get_task_info(task_id: str) -> Tuple[str, str, str]:
|
| t = TASKS_BY_ID.get(task_id)
|
| if not t:
|
| return "", "", ""
|
| schema = ""
|
| if t.get("type") == "json" and "schema" in t:
|
| schema = f"\n\nSchema: ```json\n{json.dumps(t['schema'], indent=2)}\n```"
|
| if t.get("type") == "code" and "tests" in t:
|
| schema = "\n\nUnit tests:\n```python\n" + "\n".join(t["tests"]) + "\n```"
|
| return t["question"] + schema, t.get("type", ""), SUGGESTED_PROMPTS.get(t.get("type", ""), "")
|
|
|
|
|
| def run_prompt(task_id: str, system_prompt: str) -> Tuple[str, str, str]:
|
| """Run one shot of [system_prompt, task] through the env."""
|
| t = TASKS_BY_ID.get(task_id)
|
| if t is None:
|
| return "(no task selected)", "", ""
|
| if not (system_prompt or "").strip():
|
| return "(empty prompt)", "", ""
|
| res = ENV.execute_prompt(t, system_prompt)
|
| completion = res["completion"]
|
| rd = res["reward"]
|
| breakdown = (
|
| f"correctness: {rd['correctness']:.2f}\n"
|
| f"format : {rd['format']:.2f} (×0.1 in total)\n"
|
| f"brevity : {rd['brevity']:+.3f}\n"
|
| f"-------\n"
|
| f"TOTAL : {rd['total']:+.3f}"
|
| )
|
| verifier = res.get("verifier", {})
|
| details = verifier.get("details", "")
|
| return completion, breakdown, details
|
|
|
|
|
| def load_reward_curve_image() -> str | None:
|
| p = Path(__file__).resolve().parent / "docs" / "reward_curve.png"
|
| return str(p) if p.exists() else None
|
|
|
|
|
| def load_comparison_image() -> str | None:
|
| p = Path(__file__).resolve().parent / "docs" / "baseline_comparison.png"
|
| return str(p) if p.exists() else None
|
|
|
|
|
| def load_comparison_table() -> str:
|
| p = Path(__file__).resolve().parent / "results" / "comparison.json"
|
| if not p.exists():
|
| return "_No comparison.json yet — train + run plot_results.py to populate._"
|
| d = json.loads(p.read_text(encoding="utf-8"))
|
| rows = d.get("policies", {})
|
| if not rows:
|
| return "_comparison.json is empty._"
|
| lines = [
|
| "| policy | n | correct | format | mean_reward |",
|
| "|---|---:|---:|---:|---:|",
|
| ]
|
| for label, r in rows.items():
|
| lines.append(
|
| f"| {label} | {r['n']} | {r['correct']} | {r['format']} | {r['mean_reward']:+.3f} |"
|
| )
|
| return "\n".join(lines)
|
|
|
|
|
|
|
|
|
|
|
|
|
| INTRO = """
|
| # PromptOps Arena 🎯
|
|
|
| > An RL environment where an agent learns to **write better prompts** via GRPO,
|
| > across math, code, and JSON-extraction tasks.
|
|
|
| - **Agent (trained):** Qwen2.5-1.5B-Instruct + LoRA, optimized with GRPO.
|
| - **LLM-under-test (frozen):** Qwen2.5-0.5B-Instruct.
|
| - **Reward:** `correctness + 0.1·format + brevity_penalty`, all programmatic.
|
|
|
| Try writing your own system prompts in the **Try the env** tab.
|
| """
|
|
|
|
|
| with gr.Blocks(title="PromptOps Arena", theme=gr.themes.Soft()) as demo:
|
| gr.Markdown(INTRO)
|
|
|
| with gr.Tab("Try the env"):
|
| with gr.Row():
|
| task_dd = gr.Dropdown(
|
| choices=list_task_choices(),
|
| value=ALL_TASKS[0]["id"] if ALL_TASKS else None,
|
| label="Pick a task",
|
| interactive=True,
|
| )
|
| task_text = gr.Markdown(label="Task")
|
| task_type_box = gr.Textbox(label="task type", interactive=False)
|
| with gr.Row():
|
| with gr.Column():
|
| system_prompt = gr.Textbox(
|
| label="Your system prompt (this is the action)",
|
| lines=8,
|
| placeholder="Write the system prompt to give to the small frozen LLM…",
|
| )
|
| with gr.Row():
|
| suggest_btn = gr.Button("Use suggested prompt")
|
| run_btn = gr.Button("▶ Run", variant="primary")
|
| with gr.Column():
|
| completion_out = gr.Textbox(
|
| label="LLM-under-test completion", lines=8, interactive=False,
|
| )
|
| reward_out = gr.Textbox(
|
| label="Reward decomposition", lines=6, interactive=False,
|
| )
|
| verifier_out = gr.Textbox(
|
| label="Verifier details", lines=2, interactive=False,
|
| )
|
|
|
| def _on_task(task_id):
|
| text, ttype, suggested = get_task_info(task_id)
|
| return text, ttype, suggested
|
|
|
| task_dd.change(_on_task, inputs=task_dd, outputs=[task_text, task_type_box, system_prompt])
|
| suggest_btn.click(_on_task, inputs=task_dd, outputs=[task_text, task_type_box, system_prompt])
|
| run_btn.click(run_prompt, inputs=[task_dd, system_prompt],
|
| outputs=[completion_out, reward_out, verifier_out])
|
|
|
| with gr.Tab("Reward curve"):
|
| gr.Markdown("### GRPO training reward curve\n"
|
| "Each point is the env's total reward for one rollout during training.")
|
| rc_img = gr.Image(value=load_reward_curve_image(), label="reward_curve.png",
|
| interactive=False, show_label=False)
|
| gr.Markdown(
|
| "_If this is empty, training hasn't been run yet or `docs/reward_curve.png` "
|
| "is missing. Run `scripts/plot_results.py` after training._"
|
| )
|
|
|
| with gr.Tab("Baselines vs trained agent"):
|
| gr.Markdown("### Comparison on the held-out test split\n")
|
| cmp_img = gr.Image(value=load_comparison_image(), label="baseline_comparison.png",
|
| interactive=False, show_label=False)
|
| gr.Markdown(load_comparison_table())
|
|
|
| with gr.Tab("How it works"):
|
| gr.Markdown((Path(__file__).resolve().parent / "docs" / "SCOPE.md").read_text(encoding="utf-8"))
|
|
|
|
|
| if __name__ == "__main__":
|
| demo.queue().launch()
|
|
|
