Upload repro.py with huggingface_hub

repro.py

@@ -0,0 +1,388 @@
+"""
+JustGRPO reproduction script (single-GPU, no distributed).
+Adapted from the official JustGRPO repo (eval.py, generate.py, grader.py, parser.py).
+
+Claims addressed:
+  C1: JustGRPO 89.1% on GSM8K (gen_length=256, steps=256, block_length=32)
+  C2: Retains parallel decoding + improves reasoning on math (MATH-500) and code (HumanEval/MBPP)
+  C3: Arbitrary order (AO) limits reasoning potential vs AR order (Pass@k / solution coverage)
+
+Run on a single GPU (no torchrun needed). Supports --max_examples for budget control.
+Results saved as JSON to --output.
+"""
+import os
+import sys
+import re
+import ast
+import json
+import gzip
+import argparse
+import time
+import random
+from pathlib import Path
+
+import torch
+import torch.nn.functional as F
+from tqdm import tqdm
+from datasets import load_dataset
+from transformers import AutoModel, AutoTokenizer
+
+# Make the JustGRPO package importable
+HERE = Path(__file__).resolve().parent
+sys.path.insert(0, str(HERE / "JustGRPO"))
+
+from utils.generate import generate, add_gumbel_noise, get_num_transfer_tokens
+from utils.grader import math_equal
+from utils.parser import extract_answer, parse_ground_truth
+from data.math import extract_answer_gsm8k, collate_fn_gsm8k, collate_fn_math
+
+DEVICE = "cuda" if torch.cuda.is_available() else "cpu"
+MASK_ID = 126336
+
+
+# ---------------- LoRA merge (from eval.py) ----------------
+def merge_lora(model, adapter_dir):
+    from safetensors.torch import load_file
+    with open(os.path.join(adapter_dir, "adapter_config.json")) as f:
+        cfg = json.load(f)
+    scaling = cfg["lora_alpha"] / cfg["r"]
+    state = load_file(os.path.join(adapter_dir, "adapter_model.safetensors"))
+    for key in [k for k in state if ".lora_A." in k]:
+        target = key.split(".lora_A.")[0].removeprefix("base_model.model.")
+        weight = model.get_submodule(target).weight
+        delta = (state[key.replace(".lora_A.", ".lora_B.")].float() @ state[key].float()) * scaling
+        weight.data += delta.to(weight.dtype)
+
+
+def load_model(ckpt_path, base_path="GSAI-ML/LLaDA-8B-Instruct"):
+    tokenizer = AutoTokenizer.from_pretrained(base_path, trust_remote_code=True)
+    if os.path.exists(os.path.join(ckpt_path, "adapter_config.json")):
+        model = AutoModel.from_pretrained(base_path, trust_remote_code=True, torch_dtype=torch.bfloat16)
+        merge_lora(model, ckpt_path)
+    else:
+        model = AutoModel.from_pretrained(ckpt_path, trust_remote_code=True, torch_dtype=torch.bfloat16)
+    model.eval().requires_grad_(False).to(DEVICE)
+    return model, tokenizer
+
+
+# ---------------- Math eval (GSM8K / MATH-500) ----------------
+def eval_math(model, tokenizer, task, gen_length, steps, block_length, max_examples, temperature=0.0, seed=113):
+    if task == "gsm8k":
+        ds = load_dataset("gsm8k", "main", split="test")
+        collate_fn = collate_fn_gsm8k
+        problems = [ex["question"] for ex in ds]
+        answers = [ex["answer"] for ex in ds]
+        extract_gt = extract_answer_gsm8k
+    else:
+        ds = load_dataset("ankner/math-500", split="test")
+        instruct = r"(Please put the final answer in \boxed{} tag, i.e. $\boxed{answer here}$)"
+        problems = [ex["problem"] + instruct for ex in ds]
+        answers = [ex["solution"] for ex in ds]
+        extract_gt = lambda a: extract_answer(a)
+
+    n = len(problems)
+    if max_examples and max_examples < n:
+        # deterministic subset
+        rng = random.Random(seed)
+        idx = rng.sample(range(n), max_examples)
+        problems = [problems[i] for i in idx]
+        answers = [answers[i] for i in idx]
+
+    correct = 0
+    total = 0
+    t0 = time.time()
+    details = []
+    for i in tqdm(range(len(problems)), desc=f"eval {task}", disable=True):
+        p = problems[i]
+        msgs = [[{"role": "user", "content": p}]]
+        prompt_text = tokenizer.apply_chat_template(msgs, add_generation_prompt=True, tokenize=False)
+        prompt_ids = tokenizer(prompt_text, return_tensors="pt")["input_ids"].to(DEVICE)
+        gen_ids = generate(model=model, prompt=prompt_ids, steps=steps, gen_length=gen_length,
+                           block_length=block_length, temperature=temperature)
+        resp = tokenizer.batch_decode(gen_ids[:, prompt_ids.shape[1]:], skip_special_tokens=True)[0]
+        gt = extract_gt(answers[i])
+        pred = extract_answer(resp) if task != "gsm8k" else extract_answer(resp)
+        ok = math_equal(gt, pred, timeout=(task != "gsm8k"))
+        correct += int(ok)
+        total += 1
+        if (i + 1) % 10 == 0:
+            elapsed = time.time() - t0
+            print(f"  [{task}] {i+1}/{len(problems)} acc={correct/total*100:.2f}% elapsed={elapsed:.0f}s", flush=True)
+        if i < 5:
+            details.append({"idx": i, "correct": bool(ok), "gt": str(gt)[:80], "pred": str(pred)[:80]})
+
+    acc = correct / total
+    elapsed = time.time() - t0
+    print(f"\n{task} Accuracy: {correct}/{total} = {acc*100:.2f}%  ({elapsed:.0f}s)", flush=True)
+    summary = {"task": task, "accuracy": acc, "correct": correct, "total": total,
+            "gen_length": gen_length, "steps": steps, "block_length": block_length,
+            "temperature": temperature, "elapsed_s": elapsed, "details": details}
+    print(f"RESULT_MARKER {task}: {json.dumps(summary)}", flush=True)
+    return summary
+
+
+# ---------------- Code eval (HumanEval / MBPP) ----------------
+def _format_humaneval(problems):
+    formatted = {}
+    for tid, p in problems.items():
+        formatted[tid] = dict(p)
+        formatted[tid]["prompt"] = (
+            "You are an expert Python programmer. Your task is to complete the "
+            f"implementation of a function named `{p['entry_point']}`.\n\n"
+            f"Here is the function to complete:\n```python\n{p['prompt'].rstrip()}\n```\n"
+        )
+    return formatted
+
+
+def _format_mbpp_prompt(ex):
+    func_name = ex["test_list"][0].split(" ")[1].split("(")[0]
+    tests_str = "\n".join(f"    {t}" for t in ex["test_list"])
+    try:
+        tree = ast.parse(ex["test_list"][0].strip())
+        n_args = 0
+        for node in ast.walk(tree):
+            if isinstance(node, ast.Call) and getattr(node.func, "id", "") == func_name:
+                n_args = len(node.args)
+                break
+    except Exception:
+        n_args = 2
+    params = ", ".join(f"input_param_{i + 1}" for i in range(n_args))
+    return (
+        "You are an expert Python programmer. Your task is to complete the "
+        f"implementation of a function named `{func_name}`.\n\n"
+        f"** TARGET FUNCTION **\n{ex['text']}\n\n"
+        "** UNIT TESTS **\n"
+        f"Your code should pass unit tests like:\n{tests_str}\n\n"
+        "Here is the function to complete:\n"
+        f"```python\ndef {func_name}({params}):\n"
+        f"    \"\"\"{ex['text']}\n    \"\"\"\n```\n"
+    )
+
+
+def _load_code_tasks(task, max_examples):
+    from utils.code_exec import read_problems, stream_jsonl
+    if task == "humaneval":
+        probs = _format_humaneval(read_problems(str(HERE / "JustGRPO/datasets/HumanEval.jsonl.gz")))
+        items = list(probs.items())
+    else:
+        examples = list(stream_jsonl(str(HERE / "JustGRPO/datasets/mbpp.jsonl")))
+        probs = {ex["task_id"]: {"task_id": ex["task_id"], "prompt": _format_mbpp_prompt(ex)}
+                 for ex in examples[10:510]}
+        items = list(probs.items())
+    if max_examples and max_examples < len(items):
+        items = items[:max_examples]
+    return probs, items
+
+
+def eval_code(model, tokenizer, task, gen_length, steps, block_length, max_examples):
+    from utils.code_exec import write_jsonl, evaluate_functional_correctness, stream_jsonl
+    probs, items = _load_code_tasks(task, max_examples)
+    samples = []
+    t0 = time.time()
+    for tid, _ in tqdm(items, desc=f"eval {task}"):
+        prompt = probs[tid]["prompt"]
+        msgs = [[{"role": "user", "content": prompt}]]
+        prompt_text = tokenizer.apply_chat_template(msgs, add_generation_prompt=True, tokenize=False)
+        prompt_ids = tokenizer(prompt_text, return_tensors="pt")["input_ids"].to(DEVICE)
+        gen_ids = generate(model=model, prompt=prompt_ids, steps=steps, gen_length=gen_length,
+                           block_length=block_length, temperature=0.0)
+        completion = tokenizer.batch_decode(gen_ids[:, prompt_ids.shape[1]:], skip_special_tokens=True)[0]
+        row = {"task_id": tid, "completion": completion}
+        if task == "mbpp":
+            row["prompt"] = prompt
+        samples.append(row)
+
+    out_dir = HERE / "code_results"
+    out_dir.mkdir(exist_ok=True)
+    merged_path = str(out_dir / f"{task}_samples.jsonl")
+    write_jsonl(merged_path, samples)
+    problem_file = str(HERE / "JustGRPO/datasets/HumanEval.jsonl.gz") if task == "humaneval" \
+        else str(HERE / "JustGRPO/datasets/mbpp_test.jsonl")
+    result = evaluate_functional_correctness(
+        input_file=merged_path, problem_file=problem_file,
+        is_mbpp=(task == "mbpp"), n_workers=8, timeout=3.0, k=(1,),
+    )
+    elapsed = time.time() - t0
+    print(f"\n{task}: {result}  ({elapsed:.0f}s)")
+    return {"task": task, "metrics": result, "pass@1": result.get("pass@1"),
+            "elapsed_s": elapsed, "n_samples": len(samples)}
+
+
+# ---------------- C3: Pass@k (AR vs AO) ----------------
+def eval_pass_at_k(model, tokenizer, task, gen_length, steps, n_problems, k, temperature, seed=113):
+    """Compare AR order (block_length=1) vs Arbitrary Order (block_length=gen_length)."""
+    if task == "gsm8k":
+        ds = load_dataset("gsm8k", "main", split="test")
+        problems = [ex["question"] for ex in ds]
+        answers = [ex["answer"] for ex in ds]
+        extract_gt = extract_answer_gsm8k
+        use_timeout = False
+    else:
+        ds = load_dataset("ankner/math-500", split="test")
+        instruct = r"(Please put the final answer in \boxed{} tag, i.e. $\boxed{answer here}$)"
+        problems = [ex["problem"] + instruct for ex in ds]
+        answers = [ex["solution"] for ex in ds]
+        extract_gt = lambda a: extract_answer(a)
+        use_timeout = True
+
+    rng = random.Random(seed)
+    idx = rng.sample(range(len(problems)), min(n_problems, len(problems)))
+    problems = [problems[i] for i in idx]
+    answers = [answers[i] for i in idx]
+
+    modes = {
+        "AR": {"block_length": 1, "steps": gen_length},        # strictly left-to-right (1 token/step)
+        "AO": {"block_length": gen_length, "steps": steps},     # arbitrary order (full parallel, low-conf remasking)
+    }
+
+    results = {}
+    per_problem = {}  # mode -> list of 0/1 per problem
+    for mode_name, cfg in modes.items():
+        t0 = time.time()
+        solved_list = []  # per problem: 1 if any of k samples correct
+        n_correct_samples = 0
+        n_total_samples = 0
+        for i in range(len(problems)):
+            p = problems[i]
+            gt = extract_gt(answers[i])
+            msgs = [[{"role": "user", "content": p}]]
+            prompt_text = tokenizer.apply_chat_template(msgs, add_generation_prompt=True, tokenize=False)
+            prompt_ids = tokenizer(prompt_text, return_tensors="pt")["input_ids"].to(DEVICE)
+            # generate k samples (temperature>0 for diversity)
+            prompt_batch = prompt_ids.repeat(k, 1)
+            gen_ids = generate(model=model, prompt=prompt_batch, steps=cfg["steps"],
+                               gen_length=gen_length, block_length=cfg["block_length"],
+                               temperature=temperature)
+            resps = tokenizer.batch_decode(gen_ids[:, prompt_ids.shape[1]:], skip_special_tokens=True)
+            solved = False
+            for resp in resps:
+                pred = extract_answer(resp)
+                ok = math_equal(gt, pred, timeout=use_timeout)
+                n_total_samples += 1
+                if ok:
+                    n_correct_samples += 1
+                    solved = True
+            solved_list.append(int(solved))
+            if (i + 1) % 5 == 0:
+                print(f"  [Pass@k {mode_name}] {i+1}/{len(problems)} pass@{k}={sum(solved_list)/len(solved_list)*100:.1f}% elapsed={time.time()-t0:.0f}s", flush=True)
+        pass_k_acc = sum(solved_list) / len(solved_list)
+        sample_acc = n_correct_samples / max(n_total_samples, 1)
+        elapsed = time.time() - t0
+        results[mode_name] = {
+            "pass@k": pass_k_acc, "k": k, "n_problems": len(problems),
+            "sample_accuracy": sample_acc, "n_correct_samples": n_correct_samples,
+            "n_total_samples": n_total_samples, "block_length": cfg["block_length"],
+            "steps": cfg["steps"], "temperature": temperature, "elapsed_s": elapsed,
+            "solved_list": solved_list,
+        }
+        per_problem[mode_name] = solved_list
+        print(f"\n[{mode_name}] Pass@{k} = {pass_k_acc*100:.2f}%  sample_acc={sample_acc*100:.2f}%  ({elapsed:.0f}s)", flush=True)
+
+    # solution coverage overlap: problems solved by AR not AO, and vice versa
+    ar_s = set(i for i, v in enumerate(per_problem["AR"]) if v)
+    ao_s = set(i for i, v in enumerate(per_problem["AO"]) if v)
+    coverage = {
+        "ar_only_count": len(ar_s - ao_s),
+        "ao_only_count": len(ao_s - ar_s),
+        "both_count": len(ar_s & ao_s),
+        "neither_count": len(set(range(len(per_problem["AR"]))) - ar_s - ao_s),
+        "ar_only_pct": len(ar_s - ao_s) / max(len(ar_s), 1) * 100,
+        "ao_only_pct": len(ao_s - ar_s) / max(len(ao_s), 1) * 100,
+    }
+    results["coverage_overlap"] = coverage
+    print(f"Coverage: AR-only={coverage['ar_only_count']} AO-only={coverage['ao_only_count']} both={coverage['both_count']} ({coverage['ar_only_pct']:.1f}% of AR solutions not in AO)", flush=True)
+    print(f"RESULT_MARKER pass_at_k: {json.dumps(results)}", flush=True)
+    return results
+
+
+def main():
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--claim", type=str, required=True, choices=["c1", "c2", "c3", "all"])
+    parser.add_argument("--ckpt_path", type=str, default="nzl-thu/LLaDA-Instruct-JustGRPO-GSM8K")
+    parser.add_argument("--math500_ckpt", type=str, default="nzl-thu/LLaDA-Instruct-JustGRPO-Math500")
+    parser.add_argument("--code_ckpt", type=str, default="nzl-thu/LLaDA-Instruct-JustGRPO-Code")
+    parser.add_argument("--base_ckpt", type=str, default="GSAI-ML/LLaDA-8B-Instruct")
+    parser.add_argument("--gen_length", type=int, default=256)
+    parser.add_argument("--steps", type=int, default=256)
+    parser.add_argument("--block_length", type=int, default=32)
+    parser.add_argument("--max_examples", type=int, default=0, help="0 = full set")
+    parser.add_argument("--k", type=int, default=4, help="Pass@k samples")
+    parser.add_argument("--n_problems", type=int, default=30, help="problems for Pass@k")
+    parser.add_argument("--temperature", type=float, default=0.7, help="temp for Pass@k sampling")
+    parser.add_argument("--output", type=str, default="results")
+    args = parser.parse_args()
+
+    os.makedirs(args.output, exist_ok=True)
+    torch.manual_seed(113)
+    print(f"Device: {DEVICE} | claim={args.claim}", flush=True)
+
+    if args.claim in ("c1", "all"):
+        print("\n===== C1: GSM8K eval (JustGRPO) =====", flush=True)
+        model, tokenizer = load_model(args.ckpt_path, base_path=args.base_ckpt)
+        res = eval_math(model, tokenizer, "gsm8k", args.gen_length, args.steps,
+                        args.block_length, args.max_examples or 0)
+        with open(os.path.join(args.output, "c1_gsm8k.json"), "w") as f:
+            json.dump(res, f, indent=2)
+        # also AR mode (block_length=1) on a smaller subset for C2 parallel-decoding comparison
+        if args.claim == "all" or args.claim == "c1":
+            n_ar = 100
+            print("\n===== C2a: GSM8K AR mode (block_length=1) for parallel-decoding check =====", flush=True)
+            res_ar = eval_math(model, tokenizer, "gsm8k", args.gen_length, args.gen_length,
+                               1, n_ar, temperature=0.0)
+            with open(os.path.join(args.output, "c2_gsm8k_ar.json"), "w") as f:
+                json.dump(res_ar, f, indent=2)
+        del model
+        torch.cuda.empty_cache()
+
+    if args.claim in ("c2", "all"):
+        n_math = min(args.max_examples or 150, 100)
+        print(f"\n===== C2b: MATH-500 eval ({n_math} ex, JustGRPO-Math500) =====", flush=True)
+        try:
+            model, tokenizer = load_model(args.math500_ckpt, base_path=args.base_ckpt)
+            res = eval_math(model, tokenizer, "math500", args.gen_length, args.steps,
+                            args.block_length, n_math)
+            with open(os.path.join(args.output, "c2_math500.json"), "w") as f:
+                json.dump(res, f, indent=2)
+            del model
+            torch.cuda.empty_cache()
+        except Exception as e:
+            print(f"MATH-500 eval failed: {e}", flush=True)
+
+        n_code = 80
+        print(f"\n===== C2c: HumanEval eval ({n_code} ex, JustGRPO-Code) =====", flush=True)
+        try:
+            model, tokenizer = load_model(args.code_ckpt, base_path=args.base_ckpt)
+            res = eval_code(model, tokenizer, "humaneval", args.gen_length, args.steps,
+                            args.block_length, n_code)
+            with open(os.path.join(args.output, "c2_humaneval.json"), "w") as f:
+                json.dump(res, f, indent=2)
+            del model
+            torch.cuda.empty_cache()
+        except Exception as e:
+            print(f"HumanEval eval failed: {e}", flush=True)
+
+    if args.claim in ("c3", "all"):
+        print("\n===== C3: Pass@k AR vs AO (base LLaDA-Instruct) =====", flush=True)
+        model, tokenizer = load_model(args.base_ckpt, base_path=args.base_ckpt)
+        res = eval_pass_at_k(model, tokenizer, "gsm8k", args.gen_length, args.steps,
+                              args.n_problems, args.k, args.temperature)
+        with open(os.path.join(args.output, "c3_pass_at_k.json"), "w") as f:
+            json.dump(res, f, indent=2)
+        del model
+        torch.cuda.empty_cache()
+
+    # Best-effort upload of results to HF dataset repo for persistence
+    try:
+        from huggingface_hub import HfApi
+        api = HfApi()
+        repo_id = "feliksier/justgrpo-repro-results"
+        api.create_repo(repo_id, repo_type="dataset", exist_ok=True, private=False)
+        api.upload_folder(folder_path=args.output, repo_id=repo_id, repo_type="dataset")
+        print(f"Uploaded results to hf://datasets/{repo_id}", flush=True)
+    except Exception as e:
+        print(f"Upload failed (non-fatal): {e}", flush=True)
+    print("\n===== DONE =====", flush=True)
+
+
+if __name__ == "__main__":
+    main()