sync source for HF Jobs training run

app.py

@@ -0,0 +1,207 @@
+"""
+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
+
+# Make src importable regardless of where Gradio runs
+sys.path.insert(0, str(Path(__file__).resolve().parent))
+
+import gradio as gr  # type: ignore
+
+# Default to the real backend on Spaces; allow override
+os.environ.setdefault("PROMPTOPS_LLM_BACKEND", "transformers")
+
+from src.envs.promptops_arena.server.environment import PromptOpsArenaEnvironment  # noqa: E402
+from src.envs.promptops_arena.tasks import load_tasks  # noqa: E402
+
+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)
+
+
+# ---------------------------------------------------------------------------
+# UI
+# ---------------------------------------------------------------------------
+
+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()

results/comparison.json

@@ -0,0 +1,210 @@
+{
+  "policies": {
+    "zero_shot (stub)": {
+      "n": 30,
+      "correct": 0,
+      "format": 0,
+      "mean_reward": 0.0,
+      "by_type": {
+        "math": {
+          "n": 10,
+          "correct": 0,
+          "format": 0
+        },
+        "code": {
+          "n": 10,
+          "correct": 0,
+          "format": 0
+        },
+        "json": {
+          "n": 10,
+          "correct": 0,
+          "format": 0
+        }
+      },
+      "backend": "stub"
+    },
+    "cot (stub)": {
+      "n": 30,
+      "correct": 0,
+      "format": 30,
+      "mean_reward": 0.1,
+      "by_type": {
+        "math": {
+          "n": 10,
+          "correct": 0,
+          "format": 10
+        },
+        "code": {
+          "n": 10,
+          "correct": 0,
+          "format": 10
+        },
+        "json": {
+          "n": 10,
+          "correct": 0,
+          "format": 10
+        }
+      },
+      "backend": "stub"
+    },
+    "zero_shot (real LLM)": {
+      "n": 6,
+      "correct": 4,
+      "format": 3,
+      "mean_reward": 0.7166666666666668,
+      "by_type": {
+        "math": {
+          "n": 2,
+          "correct": 1,
+          "format": 0
+        },
+        "code": {
+          "n": 2,
+          "correct": 1,
+          "format": 1
+        },
+        "json": {
+          "n": 2,
+          "correct": 2,
+          "format": 2
+        }
+      },
+      "backend": "transformers"
+    },
+    "cot (real LLM)": {
+      "n": 6,
+      "correct": 4,
+      "format": 6,
+      "mean_reward": 0.7666666666666667,
+      "by_type": {
+        "math": {
+          "n": 2,
+          "correct": 0,
+          "format": 2
+        },
+        "code": {
+          "n": 2,
+          "correct": 2,
+          "format": 2
+        },
+        "json": {
+          "n": 2,
+          "correct": 2,
+          "format": 2
+        }
+      },
+      "backend": "transformers"
+    }
+  },
+  "ranking_by_mean_reward": [
+    [
+      "cot (real LLM)",
+      {
+        "n": 6,
+        "correct": 4,
+        "format": 6,
+        "mean_reward": 0.7666666666666667,
+        "by_type": {
+          "math": {
+            "n": 2,
+            "correct": 0,
+            "format": 2
+          },
+          "code": {
+            "n": 2,
+            "correct": 2,
+            "format": 2
+          },
+          "json": {
+            "n": 2,
+            "correct": 2,
+            "format": 2
+          }
+        },
+        "backend": "transformers"
+      }
+    ],
+    [
+      "zero_shot (real LLM)",
+      {
+        "n": 6,
+        "correct": 4,
+        "format": 3,
+        "mean_reward": 0.7166666666666668,
+        "by_type": {
+          "math": {
+            "n": 2,
+            "correct": 1,
+            "format": 0
+          },
+          "code": {
+            "n": 2,
+            "correct": 1,
+            "format": 1
+          },
+          "json": {
+            "n": 2,
+            "correct": 2,
+            "format": 2
+          }
+        },
+        "backend": "transformers"
+      }
+    ],
+    [
+      "cot (stub)",
+      {
+        "n": 30,
+        "correct": 0,
+        "format": 30,
+        "mean_reward": 0.1,
+        "by_type": {
+          "math": {
+            "n": 10,
+            "correct": 0,
+            "format": 10
+          },
+          "code": {
+            "n": 10,
+            "correct": 0,
+            "format": 10
+          },
+          "json": {
+            "n": 10,
+            "correct": 0,
+            "format": 10
+          }
+        },
+        "backend": "stub"
+      }
+    ],
+    [
+      "zero_shot (stub)",
+      {
+        "n": 30,
+        "correct": 0,
+        "format": 0,
+        "mean_reward": 0.0,
+        "by_type": {
+          "math": {
+            "n": 10,
+            "correct": 0,
+            "format": 0
+          },
+          "code": {
+            "n": 10,
+            "correct": 0,
+            "format": 0
+          },
+          "json": {
+            "n": 10,
+            "correct": 0,
+            "format": 0
+          }
+        },
+        "backend": "stub"
+      }
+    ]
+  ]
+}

scripts/eval_trained.py

@@ -0,0 +1,217 @@
+"""
+Phase 6: Evaluate the GRPO-trained agent on the test split.
+
+Loads:
+  - base agent: Qwen/Qwen2.5-1.5B-Instruct (frozen weights)
+  - LoRA adapter: from --adapter (local dir or HF model repo id)
+
+For each test task:
+  1. build agent input (same as training)
+  2. agent generates a candidate system prompt
+  3. env runs LLM-under-test with that prompt; verify; reward
+  4. up to --max-turns retries with the previous attempt visible
+
+Outputs results/trained_agent.json in the same shape as run_baseline.py.
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import os
+import sys
+import time
+from pathlib import Path
+from typing import Any, Dict, List
+
+sys.path.insert(0, str(Path(__file__).resolve().parents[1]))
+
+from src.envs.promptops_arena.server.environment import PromptOpsArenaEnvironment
+from src.envs.promptops_arena.tasks import load_tasks
+from src.envs.promptops_arena import llm_under_test
+from scripts.train_grpo import build_agent_input  # reuse the exact prompt template
+
+
+def _load_agent(base_model: str, adapter: str | None):
+    import torch  # type: ignore
+    from transformers import AutoModelForCausalLM, AutoTokenizer  # type: ignore
+
+    device = "cuda" if torch.cuda.is_available() else "cpu"
+    dtype = torch.bfloat16 if device == "cuda" else torch.float32
+
+    tok = AutoTokenizer.from_pretrained(base_model)
+    if tok.pad_token is None:
+        tok.pad_token = tok.eos_token
+
+    mdl = AutoModelForCausalLM.from_pretrained(
+        base_model, torch_dtype=dtype, device_map=device,
+    )
+    if adapter:
+        from peft import PeftModel  # type: ignore
+        mdl = PeftModel.from_pretrained(mdl, adapter)
+    mdl.eval()
+
+    def gen(text: str, max_new_tokens: int = 300) -> str:
+        msgs = [
+            {"role": "system", "content": "You are a helpful prompt engineer."},
+            {"role": "user", "content": text},
+        ]
+        encoded = tok.apply_chat_template(
+            msgs, add_generation_prompt=True, return_tensors="pt",
+        )
+        if hasattr(encoded, "input_ids"):
+            ids = encoded.input_ids
+        elif isinstance(encoded, dict):
+            ids = encoded["input_ids"]
+        else:
+            ids = encoded
+        ids = ids.to(device)
+        with torch.no_grad():
+            out = mdl.generate(
+                input_ids=ids, max_new_tokens=max_new_tokens,
+                do_sample=False, pad_token_id=tok.eos_token_id,
+            )
+        return tok.decode(out[0][ids.shape[1]:], skip_special_tokens=True).strip()
+
+    return gen
+
+
+def _build_followup_input(task: dict, history: List[dict]) -> str:
+    """Like build_agent_input but with prior attempts visible (refinement turn)."""
+    base = build_agent_input(task)
+    if not history:
+        return base
+    extra = ["", "PRIOR ATTEMPTS (yours, with what the small model produced):"]
+    for i, h in enumerate(history, 1):
+        extra.append(f"--- attempt {i} (reward={h['reward']:.2f}, correct={h['correct']}) ---")
+        extra.append(f"YOUR PROMPT: {h['prompt'][:400]}")
+        extra.append(f"MODEL OUTPUT: {h['completion'][:200]}")
+    extra.append("")
+    extra.append("Improve the system prompt. Output ONLY the new system prompt, no preamble.")
+    return base + "\n" + "\n".join(extra)
+
+
+def evaluate_trained(env, task, agent_gen, max_turns: int = 3) -> Dict[str, Any]:
+    history: List[dict] = []
+    best_reward = -1.0
+    best_components: Dict[str, float] = {}
+    correct = False
+    edit_turns = 0
+
+    for turn in range(max_turns):
+        edit_turns = turn + 1
+        ai = build_agent_input(task) if turn == 0 else _build_followup_input(task, history)
+        sp = agent_gen(ai).strip() or "Solve this:"
+        res = env.execute_prompt(task, sp)
+        components = res["reward"]
+        total = components["total"]
+        is_correct = components["correctness"] >= 1.0
+
+        history.append({
+            "prompt": sp,
+            "completion": res["completion"],
+            "reward": total,
+            "correct": is_correct,
+        })
+
+        if total > best_reward:
+            best_reward = total
+            best_components = components
+
+        if is_correct:
+            correct = True
+            break
+
+    return {
+        "task_id": task["id"],
+        "task_type": task["type"],
+        "policy": "trained_agent",
+        "edit_turns": edit_turns,
+        "final_reward": best_reward,
+        "correct": correct,
+        "format_ok": best_components.get("format", 0.0) >= 1.0,
+        "components": best_components,
+        "trace": history,
+    }
+
+
+def main():
+    p = argparse.ArgumentParser()
+    p.add_argument("--adapter", default=None,
+                   help="Local dir or HF repo id of the LoRA adapter.")
+    p.add_argument("--base", default="Qwen/Qwen2.5-1.5B-Instruct")
+    p.add_argument("--split", default="test")
+    p.add_argument("--out", default="results/trained_agent.json")
+    p.add_argument("--limit", type=int, default=None)
+    p.add_argument("--per-type", type=int, default=None)
+    p.add_argument("--max-turns", type=int, default=3)
+    args = p.parse_args()
+
+    os.environ.setdefault("PROMPTOPS_LLM_BACKEND", "transformers")
+
+    tasks = load_tasks(split=args.split)
+    if args.per_type:
+        bucketed: Dict[str, List[dict]] = {}
+        for t in tasks:
+            bucketed.setdefault(t["type"], []).append(t)
+        sampled: List[dict] = []
+        for tt, lst in bucketed.items():
+            sampled.extend(lst[: args.per_type])
+        tasks = sampled
+    if args.limit:
+        tasks = tasks[: args.limit]
+
+    print(f"[eval_trained] adapter={args.adapter} base={args.base} "
+          f"split={args.split} n_tasks={len(tasks)} "
+          f"llm_backend={llm_under_test.backend_name()}")
+
+    env = PromptOpsArenaEnvironment(split=args.split, seed=0)
+    agent_gen = _load_agent(args.base, args.adapter)
+
+    rows: List[Dict[str, Any]] = []
+    t0 = time.time()
+    for i, task in enumerate(tasks):
+        row = evaluate_trained(env, task, agent_gen, max_turns=args.max_turns)
+        rows.append(row)
+        n_correct = sum(1 for r in rows if r["correct"])
+        print(f"  [{i+1}/{len(tasks)}] {task['type']:5s} "
+              f"correct={n_correct}/{i+1} "
+              f"r={row['final_reward']:+.3f} elapsed={time.time()-t0:.1f}s")
+
+    by_type: Dict[str, Dict[str, int]] = {}
+    for r in rows:
+        d = by_type.setdefault(r["task_type"], {"n": 0, "correct": 0, "format": 0})
+        d["n"] += 1
+        d["correct"] += int(r["correct"])
+        d["format"] += int(r["format_ok"])
+
+    overall = {
+        "n": len(rows),
+        "correct": sum(1 for r in rows if r["correct"]),
+        "format": sum(1 for r in rows if r["format_ok"]),
+        "mean_reward": sum(r["final_reward"] for r in rows) / max(1, len(rows)),
+    }
+
+    out = {
+        "policy": "trained_agent",
+        "adapter": args.adapter,
+        "base_model": args.base,
+        "split": args.split,
+        "llm_backend": llm_under_test.backend_name(),
+        "by_type": by_type,
+        "overall": overall,
+        "rows": rows,
+    }
+
+    out_path = Path(args.out)
+    out_path.parent.mkdir(parents=True, exist_ok=True)
+    out_path.write_text(json.dumps(out, indent=2), encoding="utf-8")
+    print(f"\n[eval_trained] wrote {out_path}")
+    print(f"  overall: {overall['correct']}/{overall['n']} correct, "
+          f"mean_reward={overall['mean_reward']:.3f}")
+    for tt, d in by_type.items():
+        print(f"  {tt:5s}: {d['correct']}/{d['n']} correct, format {d['format']}/{d['n']}")
+
+
+if __name__ == "__main__":
+    main()

scripts/hf_job_entry.sh

@@ -1,82 +1,82 @@
-#!/usr/bin/env bash
-# Entrypoint executed inside the HF Jobs container.
-# Expects:
-#   /code        -> RO mount of dataset Dar3devil/promptops-arena-src
-#   $HF_TOKEN    -> secret, for pushing the trained adapter
-#   $HF_USERNAME -> user namespace for the model repo (default: Dar3devil)
-#   $STEPS, $BATCH, $NUM_GENS (optional overrides)
-
-set -euo pipefail
-
-HF_USERNAME="${HF_USERNAME:-Dar3devil}"
-STEPS="${STEPS:-200}"
-BATCH="${BATCH:-4}"
-NUM_GENS="${NUM_GENS:-4}"
-LOG_LEVEL="${LOG_LEVEL:-info}"
-MODEL_REPO="${HF_USERNAME}/promptops-arena-agent"
-
-echo "[entry] HF_USERNAME=${HF_USERNAME} STEPS=${STEPS} BATCH=${BATCH} NUM_GENS=${NUM_GENS}"
-echo "[entry] copying source from /code -> /workspace"
-mkdir -p /workspace
-cp -r /code/. /workspace/
-cd /workspace
-
-echo "[entry] python: $(python --version)"
-echo "[entry] gpu:"
-nvidia-smi || echo "no nvidia-smi"
-
-echo "[entry] installing deps"
-pip install --no-cache-dir --quiet --upgrade pip
-pip install --no-cache-dir --quiet \
-    "torch>=2.4.0" \
-    "transformers>=4.45.0" \
-    "trl>=1.2.0" \
-    "peft>=0.13.0" \
-    "accelerate>=1.0.0" \
-    "datasets>=2.20.0" \
-    "huggingface_hub>=0.25.0" \
-    "jsonschema>=4.20.0" \
-    "openenv-core>=0.1.0" \
-    "fastapi>=0.110.0" \
-    "uvicorn>=0.27.0" \
-    "pydantic>=2.0.0"
-
-export PROMPTOPS_LLM_BACKEND=transformers
-export PYTHONUTF8=1
-export TOKENIZERS_PARALLELISM=false
-
-echo "[entry] launching GRPO training"
-python scripts/train_grpo.py \
-    --steps "${STEPS}" \
-    --batch "${BATCH}" \
-    --num-generations "${NUM_GENS}" \
-    --out outputs/grpo-lora \
-    --log results/training_log.jsonl
-
-echo "[entry] training done. uploading adapter + log to ${MODEL_REPO}"
-python - <<'PY'
-import os
-from huggingface_hub import HfApi, create_repo
-
-api = HfApi()
-repo_id = f"{os.environ['HF_USERNAME']}/promptops-arena-agent"
-create_repo(repo_id, repo_type="model", exist_ok=True, private=False)
-
-api.upload_folder(
-    folder_path="outputs/grpo-lora",
-    repo_id=repo_id,
-    repo_type="model",
-    commit_message="GRPO-trained LoRA adapter",
-)
-# also upload training log so we can plot reward curves locally
-api.upload_file(
-    path_or_fileobj="results/training_log.jsonl",
-    path_in_repo="training_log.jsonl",
-    repo_id=repo_id,
-    repo_type="model",
-    commit_message="training reward log",
-)
-print(f"[entry] uploaded to https://huggingface.co/{repo_id}")
-PY
-
-echo "[entry] all done."
+#!/usr/bin/env bash
+# Entrypoint executed inside the HF Jobs container.
+# Expects:
+#   /code        -> RO mount of dataset Dar3devil/promptops-arena-src
+#   $HF_TOKEN    -> secret, for pushing the trained adapter
+#   $HF_USERNAME -> user namespace for the model repo (default: Dar3devil)
+#   $STEPS, $BATCH, $NUM_GENS (optional overrides)
+
+set -euo pipefail
+
+HF_USERNAME="${HF_USERNAME:-Dar3devil}"
+STEPS="${STEPS:-200}"
+BATCH="${BATCH:-4}"
+NUM_GENS="${NUM_GENS:-4}"
+LOG_LEVEL="${LOG_LEVEL:-info}"
+MODEL_REPO="${HF_USERNAME}/promptops-arena-agent"
+
+echo "[entry] HF_USERNAME=${HF_USERNAME} STEPS=${STEPS} BATCH=${BATCH} NUM_GENS=${NUM_GENS}"
+echo "[entry] copying source from /code -> /workspace"
+mkdir -p /workspace
+cp -r /code/. /workspace/
+cd /workspace
+
+echo "[entry] python: $(python --version)"
+echo "[entry] gpu:"
+nvidia-smi || echo "no nvidia-smi"
+
+echo "[entry] installing deps"
+pip install --no-cache-dir --quiet --upgrade pip
+pip install --no-cache-dir --quiet \
+    "torch>=2.4.0" \
+    "transformers>=4.45.0" \
+    "trl>=1.2.0" \
+    "peft>=0.13.0" \
+    "accelerate>=1.0.0" \
+    "datasets>=2.20.0" \
+    "huggingface_hub>=0.25.0" \
+    "jsonschema>=4.20.0" \
+    "openenv-core>=0.1.0" \
+    "fastapi>=0.110.0" \
+    "uvicorn>=0.27.0" \
+    "pydantic>=2.0.0"
+
+export PROMPTOPS_LLM_BACKEND=transformers
+export PYTHONUTF8=1
+export TOKENIZERS_PARALLELISM=false
+
+echo "[entry] launching GRPO training"
+python scripts/train_grpo.py \
+    --steps "${STEPS}" \
+    --batch "${BATCH}" \
+    --num-generations "${NUM_GENS}" \
+    --out outputs/grpo-lora \
+    --log results/training_log.jsonl
+
+echo "[entry] training done. uploading adapter + log to ${MODEL_REPO}"
+python - <<'PY'
+import os
+from huggingface_hub import HfApi, create_repo
+
+api = HfApi()
+repo_id = f"{os.environ['HF_USERNAME']}/promptops-arena-agent"
+create_repo(repo_id, repo_type="model", exist_ok=True, private=False)
+
+api.upload_folder(
+    folder_path="outputs/grpo-lora",
+    repo_id=repo_id,
+    repo_type="model",
+    commit_message="GRPO-trained LoRA adapter",
+)
+# also upload training log so we can plot reward curves locally
+api.upload_file(
+    path_or_fileobj="results/training_log.jsonl",
+    path_in_repo="training_log.jsonl",
+    repo_id=repo_id,
+    repo_type="model",
+    commit_message="training reward log",
+)
+print(f"[entry] uploaded to https://huggingface.co/{repo_id}")
+PY
+
+echo "[entry] all done."

scripts/plot_results.py

@@ -0,0 +1,159 @@
+"""
+Phase 7: Build reward-curve plot + comparison artifact.
+
+Inputs (any subset that exists):
+  results/training_log.jsonl                 # per-step rewards from GRPO
+  results/baseline_zero_shot_real_subset.json
+  results/baseline_cot_real_subset.json
+  results/baseline_zero_shot_stub.json
+  results/baseline_cot_stub.json
+  results/trained_agent.json                 # eval of the trained agent (Phase 6)
+
+Outputs:
+  results/comparison.json
+  docs/reward_curve.png
+  docs/baseline_comparison.png
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+from pathlib import Path
+from typing import Any, Dict, List
+
+
+def load_json(p: Path) -> dict | None:
+    if not p.exists():
+        return None
+    try:
+        return json.loads(p.read_text(encoding="utf-8"))
+    except Exception as e:
+        print(f"[plot] WARN failed to load {p}: {e}")
+        return None
+
+
+def load_jsonl(p: Path) -> List[dict]:
+    if not p.exists():
+        return []
+    rows: List[dict] = []
+    for line in p.read_text(encoding="utf-8").splitlines():
+        line = line.strip()
+        if not line:
+            continue
+        try:
+            rows.append(json.loads(line))
+        except Exception:
+            pass
+    return rows
+
+
+def smooth(values: List[float], window: int = 10) -> List[float]:
+    out: List[float] = []
+    for i in range(len(values)):
+        lo = max(0, i - window + 1)
+        out.append(sum(values[lo:i + 1]) / max(1, i + 1 - lo))
+    return out
+
+
+def main():
+    p = argparse.ArgumentParser()
+    p.add_argument("--results-dir", default="results")
+    p.add_argument("--docs-dir", default="docs")
+    args = p.parse_args()
+
+    res = Path(args.results_dir)
+    docs = Path(args.docs_dir)
+    docs.mkdir(parents=True, exist_ok=True)
+
+    import matplotlib
+    matplotlib.use("Agg")
+    import matplotlib.pyplot as plt
+
+    # ---- 1. reward curve ----
+    log_rows = load_jsonl(res / "training_log.jsonl")
+    if log_rows:
+        rewards = [r["reward"]["total"] for r in log_rows if "reward" in r]
+        smoothed = smooth(rewards, window=20)
+        fig, ax = plt.subplots(figsize=(8, 4.5))
+        ax.plot(rewards, alpha=0.25, label="raw reward")
+        ax.plot(smoothed, linewidth=2, label="rolling avg (20)")
+        ax.set_xlabel("training rollout #")
+        ax.set_ylabel("reward")
+        ax.set_title("GRPO training reward curve  ·  PromptOps Arena")
+        ax.grid(alpha=0.3)
+        ax.legend()
+        fig.tight_layout()
+        out = docs / "reward_curve.png"
+        fig.savefig(out, dpi=140)
+        plt.close(fig)
+        print(f"[plot] wrote {out}  ({len(rewards)} points)")
+    else:
+        print("[plot] no training_log.jsonl yet -> skip reward curve")
+
+    # ---- 2. baseline comparison ----
+    files = {
+        "zero_shot (stub)": res / "baseline_zero_shot_stub.json",
+        "cot (stub)": res / "baseline_cot_stub.json",
+        "zero_shot (real LLM)": res / "baseline_zero_shot_real_subset.json",
+        "cot (real LLM)": res / "baseline_cot_real_subset.json",
+        "trained agent (real LLM)": res / "trained_agent.json",
+    }
+
+    rows: Dict[str, Dict[str, Any]] = {}
+    for label, path in files.items():
+        d = load_json(path)
+        if d is None:
+            continue
+        ov = d.get("overall", {})
+        rows[label] = {
+            "n": ov.get("n", 0),
+            "correct": ov.get("correct", 0),
+            "format": ov.get("format", 0),
+            "mean_reward": ov.get("mean_reward", 0.0),
+            "by_type": d.get("by_type", {}),
+            "backend": d.get("llm_backend", "unknown"),
+        }
+
+    comparison = {
+        "policies": rows,
+        "ranking_by_mean_reward": sorted(
+            rows.items(),
+            key=lambda kv: kv[1]["mean_reward"],
+            reverse=True,
+        ),
+    }
+    (res / "comparison.json").write_text(
+        json.dumps(comparison, indent=2), encoding="utf-8"
+    )
+    print(f"[plot] wrote {res/'comparison.json'}")
+
+    # ---- 3. comparison bar chart ----
+    if rows:
+        labels = list(rows.keys())
+        means = [rows[l]["mean_reward"] for l in labels]
+        accs = [rows[l]["correct"] / max(1, rows[l]["n"]) for l in labels]
+
+        fig, axes = plt.subplots(1, 2, figsize=(11, 4.5))
+        axes[0].barh(labels, means, color="#4c72b0")
+        axes[0].set_xlabel("mean reward")
+        axes[0].set_title("Mean reward by policy")
+        axes[0].grid(axis="x", alpha=0.3)
+        axes[0].invert_yaxis()
+
+        axes[1].barh(labels, accs, color="#55a868")
+        axes[1].set_xlabel("fraction correct")
+        axes[1].set_title("Correctness by policy")
+        axes[1].set_xlim(0, 1)
+        axes[1].grid(axis="x", alpha=0.3)
+        axes[1].invert_yaxis()
+
+        fig.tight_layout()
+        out = docs / "baseline_comparison.png"
+        fig.savefig(out, dpi=140)
+        plt.close(fig)
+        print(f"[plot] wrote {out}")
+
+
+if __name__ == "__main__":
+    main()