Upload folder using huggingface_hub

scripts/build_fixer_replanner_iter2.py

@@ -0,0 +1,102 @@
+"""Build fixer ORPO iter-2 're-planner' dataset.
+
+Insight: the current fixer is too conservative — it changes planner_sql only 1.4%
+of the time and rescues 0/533 hard questions on BIRD-dev. The fixer architecture
+needs to be re-framed: instead of 'apply small critique-driven edit', train it as
+a re-planner that produces a COMPLETE correct alternative when given a failed
+attempt.
+
+Data source: K=4 BIRD-train rollouts. For each question, find a (wrong-trajectory,
+correct-trajectory) pair within the K=4 samples. Use:
+- chosen = correct trajectory's planner_sql (the alternative that works)
+- rejected = wrong trajectory's planner_sql or the fixer's mistaken output
+- prompt = fixer's standard prompt with the wrong trajectory as the input
+
+Output: data/llm_alignment/scaleup_iter2_v3/hf_fixer_replanner
+"""
+import json
+import os
+import random
+import re
+from datasets import Dataset, DatasetDict
+
+OUT_DIR = "/home/datht/mats-sql-tist/data/llm_alignment/scaleup_iter2_v3/hf_fixer_replanner"
+
+SRC_PATHS = [
+    "/home/datht/mats-sql-tist/data/rollouts/bird_train_3stage_K4.jsonl",
+    "/home/datht/mats-sql-tist/data/rollouts/scaleup_bird_train_3stage_K4.jsonl",
+    "/home/datht/mats-sql-tist/data/rollouts/iter2_bird_train_3stage_K8.jsonl",
+    "/home/datht/mats-sql-tist/data/rollouts/scaleup_bird_train_2stage_K4.jsonl",
+]
+
+
+def normalize_sql(sql):
+    return re.sub(r"\s+", " ", sql or "").lower().strip()
+
+
+def main():
+    rng = random.Random(42)
+    pairs = []
+    seen_keys = set()  # (question_hash, wrong_sql_hash) → dedup
+
+    for p in SRC_PATHS:
+        if not os.path.exists(p):
+            continue
+        with open(p) as f:
+            for line in f:
+                s = json.loads(line)
+                traj = s.get("trajectories", [])
+                if len(traj) < 2:
+                    continue
+                correct_trajs = [t for t in traj if t.get("is_planner_correct")]
+                wrong_trajs = [t for t in traj if not t.get("is_planner_correct")]
+                if not correct_trajs or not wrong_trajs:
+                    continue
+                # Build (wrong → correct) pairs within the K samples
+                for wt in wrong_trajs:
+                    wsql = (wt.get("planner_sql") or "").strip()
+                    if not wsql:
+                        continue
+                    # Pick the shortest correct planner_sql as the "preferred" alternative
+                    correct_trajs_sorted = sorted(correct_trajs, key=lambda t: len(t.get("planner_sql") or ""))
+                    csql = (correct_trajs_sorted[0].get("planner_sql") or "").strip()
+                    if not csql or normalize_sql(csql) == normalize_sql(wsql):
+                        continue
+                    fixer_prompt = (wt.get("fixer_prompt") or "").strip()
+                    if not fixer_prompt:
+                        continue
+                    key = (hash(s.get("question", "")), hash(normalize_sql(wsql)))
+                    if key in seen_keys:
+                        continue
+                    seen_keys.add(key)
+                    chosen_text = f"```sql\n{csql}\n```"
+                    rejected_text = f"```sql\n{wsql}\n```"
+                    pairs.append({
+                        "prompt": fixer_prompt,
+                        "chosen": chosen_text,
+                        "rejected": rejected_text,
+                        "db_path": s.get("db_path", ""),
+                        "question": s.get("question", ""),
+                        "db_id": s.get("db_id", ""),
+                    })
+
+    rng.shuffle(pairs)
+
+    n_test = max(40, len(pairs) // 30)
+    test = pairs[:n_test]
+    train = pairs[n_test:]
+
+    dd = DatasetDict({
+        "train_dpo": Dataset.from_list(train),
+        "test_dpo": Dataset.from_list(test),
+    })
+    dd.save_to_disk(OUT_DIR)
+
+    print(f"=== Fixer ORPO iter-2 RE-PLANNER dataset ===")
+    print(f"  total pairs: {len(pairs)}")
+    print(f"  train: {len(train)}, test: {len(test)}")
+    print(f"  Saved to {OUT_DIR}")
+
+
+if __name__ == "__main__":
+    main()

scripts/build_validator_2agents_v3.py

@@ -0,0 +1,109 @@
+"""Split v3 unified validator data into 2 specialized SFT datasets:
+- Validator Selection (v_s): critique only the SELECT clause
+- Validator Condition (v_c): critique only the WHERE/HAVING/CASE conditions
+
+Per the paper (approach.tex §Combined Validator), the multi-agent design has
+2 specialized validators, not one unified validator. This script extracts the
+<select>...</select> and <condition>...</condition> sections from v3 unified
+completions and emits 2 SFT datasets with section-specific prompts.
+
+Outputs:
+- data/multi-agents/fixed/sft-validator-selection-v3
+- data/multi-agents/fixed/sft-validator-condition-v3
+"""
+import re
+from datasets import load_from_disk, Dataset, DatasetDict
+
+
+SEL_INSTR = "You are a SQL SELECT-clause critique agent. Output ONE critique section <select>...</select> analysing the SELECT clause of the SQL query below; do NOT output any SQL. Use 'None' if the SELECT clause looks correct."
+COND_INSTR = "You are a SQL CONDITION critique agent. Output ONE critique section <condition>...</condition> analysing the WHERE/HAVING/CASE-WHEN conditions of the SQL query below; do NOT output any SQL. Use 'None' if the conditions look correct."
+
+
+SEC_RE = {
+    "select": re.compile(r"<select>(.*?)</select>", re.DOTALL),
+    "condition": re.compile(r"<condition>(.*?)</condition>", re.DOTALL),
+}
+
+
+def replace_header_block(prompt_unified, new_header_line):
+    """Replace the leading 'You are a SQL critique agent...' line with a section-specific one."""
+    # The unified prompts begin with: "You are a SQL critique agent. Output FOUR critique sections (...). do NOT output any SQL.\n\n..."
+    # Strip everything before the first blank line; keep the rest (schema + question + sql).
+    # Use a safe split on the first \n\n.
+    parts = prompt_unified.split("\n\n", 1)
+    rest = parts[1] if len(parts) > 1 else parts[0]
+    return new_header_line + "\n\n" + rest
+
+
+def main():
+    v3 = load_from_disk("/home/datht/mats-sql-tist/data/multi-agents/fixed/sft-validator-diverse-v3")
+    sel_train, sel_test = [], []
+    cond_train, cond_test = [], []
+
+    for split, train_list, test_list in [("train", sel_train, cond_train), ("test", sel_test, cond_test)]:
+        target_sel = train_list
+        target_cond = test_list  # placeholder; will reassign below
+    # redo:
+    sel_train, sel_test = [], []
+    cond_train, cond_test = [], []
+
+    for split_name, sel_out, cond_out in [("train", sel_train, cond_train), ("test", sel_test, cond_test)]:
+        ds = v3[split_name]
+        for ex in ds:
+            prompt = ex["prompt"]
+            completion = ex["completion"]
+            sel_match = SEC_RE["select"].search(completion)
+            cond_match = SEC_RE["condition"].search(completion)
+            if not sel_match or not cond_match:
+                continue
+            sel_body = sel_match.group(0).strip()  # full <select>...</select>
+            cond_body = cond_match.group(0).strip()
+
+            # Build section-specific prompt
+            sel_prompt = replace_header_block(prompt, SEL_INSTR)
+            cond_prompt = replace_header_block(prompt, COND_INSTR)
+
+            # NOTE: SFT trainer in alignment-handbook reads `messages` column via dict access
+            # (chat_template uses messages['prompt'] / messages['completion']), so store as dict.
+            sel_out.append({
+                "prompt": sel_prompt,
+                "completion": sel_body,
+                "messages": {"prompt": sel_prompt, "completion": sel_body},
+            })
+            cond_out.append({
+                "prompt": cond_prompt,
+                "completion": cond_body,
+                "messages": {"prompt": cond_prompt, "completion": cond_body},
+            })
+
+    sel_dd = DatasetDict({
+        "train": Dataset.from_list(sel_train),
+        "test": Dataset.from_list(sel_test),
+    })
+    cond_dd = DatasetDict({
+        "train": Dataset.from_list(cond_train),
+        "test": Dataset.from_list(cond_test),
+    })
+
+    sel_dir = "/home/datht/mats-sql-tist/data/multi-agents/fixed/sft-validator-selection-v3"
+    cond_dir = "/home/datht/mats-sql-tist/data/multi-agents/fixed/sft-validator-condition-v3"
+    sel_dd.save_to_disk(sel_dir)
+    cond_dd.save_to_disk(cond_dir)
+
+    # Distribution
+    def stats(rows, key):
+        n_none = sum(1 for r in rows if r["completion"].strip().lower().endswith("none") or "None\n</" in r["completion"] or "No issues" in r["completion"])
+        return f"{len(rows)} total, {n_none} all-OK ({100*n_none/max(len(rows),1):.1f}%)"
+
+    print(f"=== Validator Selection (v_s) ===")
+    print(f"  train: {stats(sel_train, 'sel')}")
+    print(f"  test:  {stats(sel_test, 'sel')}")
+    print(f"  Saved to {sel_dir}")
+    print(f"\n=== Validator Condition (v_c) ===")
+    print(f"  train: {stats(cond_train, 'cond')}")
+    print(f"  test:  {stats(cond_test, 'cond')}")
+    print(f"  Saved to {cond_dir}")
+
+
+if __name__ == "__main__":
+    main()

scripts/build_validator_sft_v3_balanced.py

@@ -0,0 +1,168 @@
+"""Build v3 validator SFT data with balanced all-OK + critique rows.
+
+v2 had 8.1% all-OK rows → validator hallucinates critiques at inference.
+v3 supplements v2 with ~5000 all-OK rows mined from real planner_correct
+trajectories on BIRD-TRAIN, so the validator learns to stay silent when
+the planner SQL is already correct.
+
+Output: data/multi-agents/fixed/sft-validator-diverse-v3
+"""
+import json
+import random
+from datasets import load_from_disk, Dataset, DatasetDict
+
+OK_TEMPLATES = [
+    """<select>
+SELECT.
+No issues with SELECT.
+</select>
+
+<condition>
+CONDITION.
+No issues with WHERE/HAVING.
+</condition>
+
+<join>
+JOIN.
+Tables and join keys look correct.
+</join>
+
+<order>
+ORDER BY.
+None
+</order>""",
+    """<select>
+SELECT.
+The SELECT clause is correct.
+</select>
+
+<condition>
+CONDITION.
+Filter conditions look correct.
+</condition>
+
+<join>
+JOIN.
+No issues with JOIN.
+</join>
+
+<order>
+ORDER BY.
+None
+</order>""",
+    """<select>
+SELECT.
+None
+</select>
+
+<condition>
+CONDITION.
+None
+</condition>
+
+<join>
+JOIN.
+None
+</join>
+
+<order>
+ORDER BY.
+None
+</order>""",
+    """<select>
+SELECT.
+The projection list matches the question.
+</select>
+
+<condition>
+CONDITION.
+WHERE/HAVING clauses are correct.
+</condition>
+
+<join>
+JOIN.
+Tables and join keys are correct.
+</join>
+
+<order>
+ORDER BY.
+The ordering is correct.
+</order>""",
+]
+
+
+def main():
+    rng = random.Random(42)
+
+    # Load existing v2 (force plain-dict copy; drop "messages" because v2 stores it as a non-list dict that breaks arrow)
+    v2 = load_from_disk("/home/datht/mats-sql-tist/data/multi-agents/fixed/sft-validator-diverse-v2")
+    v2_train = [{"prompt": r["prompt"], "completion": r["completion"]} for r in v2["train"]]
+    v2_test = [{"prompt": r["prompt"], "completion": r["completion"]} for r in v2["test"]]
+
+    # Mine all-OK rows from K=4 train rollouts (planner_correct trajectories)
+    src = "/home/datht/mats-sql-tist/data/rollouts/scaleup_bird_train_2stage_K4.jsonl"
+    ok_rows = []
+    seen_prompts = set()
+    with open(src) as f:
+        for line in f:
+            s = json.loads(line)
+            for t in s.get("trajectories", []):
+                if not t.get("is_planner_correct"):
+                    continue
+                vp = (t.get("validator_prompt") or "").strip()
+                if not vp:
+                    # rebuild from planner_prompt
+                    pp = (t.get("planner_prompt") or "").strip()
+                    psql = (t.get("planner_sql") or "").strip()
+                    if not pp or not psql:
+                        continue
+                    vp = pp + "\n\nSQL query:\n" + psql
+                # dedup on full vp
+                if vp in seen_prompts:
+                    continue
+                seen_prompts.add(vp)
+                ok_rows.append(vp)
+
+    rng.shuffle(ok_rows)
+
+    # Aim: balance such that all-OK ≈ critique. v2 has ~5208 critique rows.
+    target_ok = 5200
+    ok_rows = ok_rows[:target_ok]
+
+    # Add additional sft-style critique training: use v2 + new all-OK
+    new_rows = []
+    for vp in ok_rows:
+        completion = rng.choice(OK_TEMPLATES)
+        new_rows.append({"prompt": vp, "completion": completion})
+
+    # Test split: keep v2 test + small mined sample
+    test_ok = ok_rows[target_ok:target_ok + 100] if len(ok_rows) > target_ok else []
+    new_test_rows = []
+    for vp in test_ok:
+        completion = rng.choice(OK_TEMPLATES)
+        new_test_rows.append({"prompt": vp, "completion": completion})
+
+    # Combine
+    train_combined = v2_train + new_rows
+    test_combined = v2_test + new_test_rows
+    rng.shuffle(train_combined)
+
+    dd = DatasetDict({
+        "train": Dataset.from_list(train_combined),
+        "test": Dataset.from_list(test_combined),
+    })
+
+    out_dir = "/home/datht/mats-sql-tist/data/multi-agents/fixed/sft-validator-diverse-v3"
+    dd.save_to_disk(out_dir)
+
+    # Stats
+    n_train = len(train_combined)
+    n_train_ok = sum(1 for r in train_combined if "No issues" in r["completion"] or r["completion"].count("None") >= 3)
+    print(f"v3 built:")
+    print(f"  train: {n_train} ({n_train_ok} all-OK, {n_train - n_train_ok} critique)")
+    print(f"  test:  {len(test_combined)}")
+    print(f"  Saved to {out_dir}")
+
+
+if __name__ == "__main__":
+    main()

scripts/compute_bestofn_metrics.py

@@ -0,0 +1,158 @@
+"""
+Compute Best-of-N metrics from a 3-stage pipeline rollout JSONL:
+  - greedy:    EX of the first trajectory (K=1 baseline)
+  - pass@N:    EX if ANY of the N trajectories is correct (oracle upper bound)
+  - majority:  EX of the SQL whose execution result is the most common non-empty
+               result among executable trajectories (rule-based selector,
+               no extra trained selection agent needed).
+
+Usage:
+    python scripts/compute_bestofn_metrics.py <rollout.jsonl> <label>
+"""
+import json
+import sys
+import os
+from collections import Counter
+from concurrent.futures import ThreadPoolExecutor
+
+ROOT = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+os.chdir(ROOT)
+sys.path.insert(0, ROOT)
+from validator_data.validator import _execute_sql
+from data_processing.planner import is_execution_correct
+
+
+def safe_execute(db_path, sql):
+    if not sql or sql.strip() == "":
+        return ("", True)
+    try:
+        return _execute_sql("./" + db_path, sql)
+    except Exception as e:
+        return (str(e), True)
+
+
+def hash_result(result):
+    """Hash the execution result for majority voting (handles DataFrame, list, str, None)."""
+    if result is None:
+        return None
+    try:
+        # DataFrames need to be converted via .values to be hashable
+        import pandas as pd
+        if isinstance(result, pd.DataFrame):
+            return str(tuple(map(tuple, result.values.tolist())))
+    except Exception:
+        pass
+    return str(result)
+
+
+def is_empty_result(result):
+    """Check if execution result is effectively empty."""
+    if result is None:
+        return True
+    try:
+        import pandas as pd
+        if isinstance(result, pd.DataFrame):
+            return result.empty
+    except Exception:
+        pass
+    s = str(result).strip()
+    return s == "" or "(no rows)" in s or s == "[]"
+
+
+def select_majority(traj_list, db_path):
+    """
+    Rule-based selector: among executable trajectories with NON-empty result,
+    pick the SQL whose result hash is most common. Return (selected_sql, selected_idx).
+    Tie-breaking: first by frequency, then by trajectory order.
+    """
+    candidates = []  # (idx, sql, result_hash, is_empty)
+    for i, t in enumerate(traj_list):
+        sql = t.get("fixed_sql") or t.get("planner_sql")
+        if not sql or sql.strip() == "":
+            continue
+        exec_result, has_err = safe_execute(db_path, sql)
+        if has_err:
+            continue
+        empty = is_empty_result(exec_result)
+        candidates.append((i, sql, hash_result(exec_result), empty))
+
+    if not candidates:
+        # Nothing executable; fall back to first trajectory
+        return traj_list[0].get("fixed_sql") or traj_list[0].get("planner_sql"), 0
+
+    # Prefer non-empty results
+    non_empty = [c for c in candidates if not c[3]]
+    pool = non_empty if non_empty else candidates
+
+    # Majority vote on result hash
+    counter = Counter(c[2] for c in pool)
+    best_hash, _ = counter.most_common(1)[0]
+    # Pick the first trajectory with this hash
+    for i, sql, h, _ in pool:
+        if h == best_hash:
+            return sql, i
+    return pool[0][1], pool[0][0]
+
+
+def main():
+    if len(sys.argv) != 3:
+        print("Usage: compute_bestofn_metrics.py <rollout.jsonl> <label>")
+        sys.exit(1)
+
+    rollout_path, label = sys.argv[1], sys.argv[2]
+
+    n_q = 0
+    n_greedy_correct = 0
+    n_pass_at_N = 0
+    n_majority_correct = 0
+    K_used = None
+
+    with open(rollout_path) as f:
+        for line in f:
+            line = line.strip()
+            if not line:
+                continue
+            sample = json.loads(line)
+            traj = sample.get("trajectories", [])
+            if not traj:
+                continue
+            n_q += 1
+            if K_used is None:
+                K_used = len(traj)
+
+            # Greedy = first trajectory's correctness
+            if traj[0].get("is_fixed_correct"):
+                n_greedy_correct += 1
+
+            # pass@N = any trajectory correct
+            if any(t.get("is_fixed_correct") for t in traj):
+                n_pass_at_N += 1
+
+            # Majority-vote selector
+            db_path = sample["db_path"]
+            gold_sql = sample["sql"]
+            gold_exec = safe_execute(db_path, gold_sql)
+            if gold_exec[1]:
+                continue  # skip if gold has error
+
+            selected_sql, _idx = select_majority(traj, db_path)
+            sel_exec = safe_execute(db_path, selected_sql)
+            if not sel_exec[1] and is_execution_correct(gold_exec[0], sel_exec[0]):
+                n_majority_correct += 1
+
+    if n_q == 0:
+        print(f"{label}: no questions evaluated")
+        return
+
+    print()
+    print(f"=== {label} ===")
+    print(f"  questions evaluated: {n_q}")
+    print(f"  K used per question: {K_used}")
+    print(f"  greedy (1st traj):   {n_greedy_correct}/{n_q} = {100*n_greedy_correct/n_q:.2f}%")
+    print(f"  selector-majority:   {n_majority_correct}/{n_q} = {100*n_majority_correct/n_q:.2f}%")
+    print(f"  pass@{K_used} (oracle):    {n_pass_at_N}/{n_q} = {100*n_pass_at_N/n_q:.2f}%")
+    print()
+
+
+if __name__ == "__main__":
+    main()

scripts/compute_bestofn_with_selector.py

@@ -0,0 +1,228 @@
+"""
+Compute Best-of-N metrics with a TRAINED selector (binary YES/NO classifier).
+
+For each question, run the selector on each of N candidates and pick the one
+with the highest YES probability. Also compute greedy / pass@N for comparison.
+
+Usage:
+    python scripts/compute_bestofn_with_selector.py <rollout.jsonl> <selector_ckpt> <label> [--selector_host URL]
+
+If --selector_host given (a vLLM endpoint), use it. Otherwise load model in-process.
+"""
+import argparse
+import json
+import os
+import re
+import sys
+from collections import Counter
+from concurrent.futures import ThreadPoolExecutor
+
+# Bypass HTTP proxy for local vLLM endpoints
+os.environ["NO_PROXY"] = "localhost,127.0.0.1"
+os.environ["no_proxy"] = "localhost,127.0.0.1"
+
+ROOT = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+os.chdir(ROOT)
+sys.path.insert(0, ROOT)
+
+from validator_data.validator import _execute_sql
+from data_processing.planner import is_execution_correct
+import requests
+
+
+PROMPT_TEMPLATE = (
+    "You are a SQL correctness judge.\n"
+    "Schema:\n{schema}\n\n"
+    "Question: {question}\n"
+    "External knowledge: {evidence}\n\n"
+    "Candidate SQL:\n{sql}\n\n"
+    "Execution result:\n{exec_result}\n\n"
+    "Is this SQL correct for the question? Answer YES or NO."
+)
+
+
+def qwen_chat(prompt: str) -> str:
+    return f"<|im_start|>user\n{prompt}<|im_end|>\n<|im_start|>assistant\n"
+
+
+def safe_truncate(s, n=400):
+    if s is None:
+        return "(empty)"
+    s = str(s)
+    return s if len(s) <= n else s[:n] + "..."
+
+
+def safe_execute(db_path, sql):
+    if not sql or sql.strip() == "":
+        return ("", True)
+    try:
+        return _execute_sql("./" + db_path, sql)
+    except Exception:
+        return ("", True)
+
+
+def score_via_vllm(host, prompt_chat, model_name="selector"):
+    """Get P(YES) − P(NO) via vLLM completions with logprobs."""
+    payload = {
+        "model": model_name,
+        "prompt": prompt_chat,
+        "max_tokens": 1,
+        "n": 1,
+        "temperature": 0.0,
+        "logprobs": 20,
+    }
+    try:
+        r = requests.post(f"{host}/v1/completions", json=payload, timeout=60)
+        r.raise_for_status()
+        choice = r.json()["choices"][0]
+        # Look at logprobs of top tokens; find YES vs NO
+        if "logprobs" in choice and choice["logprobs"]:
+            top = choice["logprobs"]["top_logprobs"][0]
+            yes_lp = max((top[k] for k in (" YES", "YES", " yes", "yes", " Yes", "Yes") if k in top), default=-100.0)
+            no_lp = max((top[k] for k in (" NO", "NO", " no", "no", " No", "No") if k in top), default=-100.0)
+            return yes_lp - no_lp
+        # Fallback: text match
+        text = choice.get("text", "").strip().upper()
+        return 1.0 if text.startswith("YES") else (-1.0 if text.startswith("NO") else -100.0)
+    except Exception as e:
+        sys.stderr.write(f"score_via_vllm err: {type(e).__name__}: {e}\n")
+        return -100.0
+
+
+def build_prompt_chat(sample, t, exec_result_str=None):
+    """Build selector prompt.
+
+    `exec_result_str` MUST be the actual SQL execution result preview (or error message).
+    Do NOT pass the gold-graded label — that leaks the correctness label into the prompt
+    and makes the selector trivially match the oracle.
+    """
+    schema = sample.get("schema", "")
+    question = sample.get("question", "")
+    evidence = sample.get("evidence", "") or "None"
+    fixed_sql = t.get("fixed_sql") or t.get("planner_sql") or ""
+    if exec_result_str is None:
+        # Safe default at inference time: signal unknown (selector must judge from SQL alone)
+        exec_result_str = "(execution result not available)"
+    prompt = PROMPT_TEMPLATE.format(
+        schema=safe_truncate(schema, 3000),
+        question=question,
+        evidence=evidence,
+        sql=safe_truncate(fixed_sql, 800),
+        exec_result=safe_truncate(exec_result_str, 300),
+    )
+    return qwen_chat(prompt)
+
+
+def main():
+    parser = argparse.ArgumentParser()
+    parser.add_argument("rollout_jsonl")
+    parser.add_argument("label")
+    parser.add_argument("--selector_host", default="http://localhost:8103")
+    args = parser.parse_args()
+
+    n_q = 0
+    n_greedy = 0
+    n_pass_at_N = 0
+    n_majority = 0  # rule-based majority (for compare)
+    n_selector = 0  # trained selector pick
+    K_used = None
+
+    samples = []
+    with open(args.rollout_jsonl) as f:
+        for line in f:
+            line = line.strip()
+            if line:
+                samples.append(json.loads(line))
+
+    print(f"Loaded {len(samples)} samples")
+
+    for sample in samples:
+        traj = sample.get("trajectories", [])
+        if not traj:
+            continue
+        n_q += 1
+        if K_used is None:
+            K_used = len(traj)
+
+        # Greedy = first traj
+        if traj[0].get("is_fixed_correct"):
+            n_greedy += 1
+
+        # pass@N = any correct
+        if any(t.get("is_fixed_correct") for t in traj):
+            n_pass_at_N += 1
+
+        # Rule-based majority: pick most-common non-empty execution result
+        db_path = sample["db_path"]
+        gold_sql = sample["sql"]
+        true_exec = safe_execute(db_path, gold_sql)
+        if true_exec[1]:
+            continue  # gold has error; skip
+
+        # Execute all candidates' fixed SQLs once
+        with ThreadPoolExecutor(max_workers=8) as exe:
+            exec_results = list(exe.map(
+                lambda t: safe_execute(db_path, t.get("fixed_sql") or t.get("planner_sql") or ""),
+                traj
+            ))
+
+        # Rule-based majority
+        majority_picks = []
+        for i, (er, t) in enumerate(zip(exec_results, traj)):
+            if er[1]:
+                continue
+            res_str = str(er[0]).strip()
+            if not res_str or "(no rows)" in res_str or res_str == "[]":
+                continue
+            majority_picks.append((i, res_str))
+        if majority_picks:
+            counter = Counter(s for _, s in majority_picks)
+            top_res, _ = counter.most_common(1)[0]
+            for i, s in majority_picks:
+                if s == top_res:
+                    if traj[i].get("is_fixed_correct"):
+                        n_majority += 1
+                    break
+        else:
+            if traj[0].get("is_fixed_correct"):
+                n_majority += 1
+
+        # Trained selector: score each candidate using REAL execution result (no gold-label leak).
+        # Re-use the exec_results computed above for rule-based majority.
+        scores = []
+        with ThreadPoolExecutor(max_workers=8) as exe:
+            def _make_prompt(idx, t_):
+                er = exec_results[idx]
+                if er[1]:
+                    exec_str = f"Error: {er[0]}"
+                else:
+                    rows_str = str(er[0])
+                    if not rows_str.strip() or rows_str.strip() == "[]":
+                        exec_str = "OK. Result rows (preview): (no rows)"
+                    else:
+                        exec_str = f"OK. Result rows (preview): {rows_str[:300]}"
+                return build_prompt_chat(sample, t_, exec_result_str=exec_str)
+            futs = [exe.submit(score_via_vllm, args.selector_host, _make_prompt(i, t)) for i, t in enumerate(traj)]
+            for f in futs:
+                scores.append(f.result())
+        best_idx = max(range(len(scores)), key=lambda i: scores[i])
+        if traj[best_idx].get("is_fixed_correct"):
+            n_selector += 1
+
+    if n_q == 0:
+        print(f"{args.label}: no questions evaluated")
+        return
+
+    print()
+    print(f"=== {args.label} ===")
+    print(f"  questions evaluated: {n_q}")
+    print(f"  K used per question: {K_used}")
+    print(f"  greedy (1st traj):       {n_greedy}/{n_q} = {100*n_greedy/n_q:.2f}%")
+    print(f"  rule-based majority:     {n_majority}/{n_q} = {100*n_majority/n_q:.2f}%")
+    print(f"  trained selector:        {n_selector}/{n_q} = {100*n_selector/n_q:.2f}%")
+    print(f"  pass@{K_used} (oracle):  {n_pass_at_N}/{n_q} = {100*n_pass_at_N/n_q:.2f}%")
+    print()
+
+
+if __name__ == "__main__":
+    main()

scripts/run_pipeline_rollouts.py

@@ -0,0 +1,477 @@
+"""
+Pipeline rollout driver for the 3-stage collaborative-ORPO experiment.
+
+Three-stage pipeline:
+    q  →  PLANNER (Qwen-Coder-0.5B SFT'd)         →  plan + first-cut SQL
+       →  VALIDATOR (Qwen-Coder-0.5B SFT'd)        →  free-form critique (4 sections)
+       →  FIXER (Qwen-Coder-0.5B SFT'd)            →  final SQL
+
+For each input question we sample K planner outputs with stochastic decoding,
+then for each planner output we sample K_val validator outputs, and for each
+(planner, validator) we sample K_fix fixer outputs. Each leaf trajectory is
+graded by execution of the fixer's final SQL.
+
+The output JSONL is consumed by build_rl_data_collaborative.py to construct
+preference pairs (planner-indep / planner-collab / validator-collab / fixer).
+
+Usage:
+    # Three vLLM endpoints, e.g.
+    #   GPU 0:8100 = planner
+    #   GPU 1:8101 = validator
+    #   GPU 1:8102 = fixer    (can co-locate validator+fixer on one GPU since both 0.5B)
+    python scripts/run_pipeline_rollouts.py \\
+        --input_file data/sft_bird_with_evidence_train_text2sql.json \\
+        --output_file data/rollouts/bird_train_3stage_K4.jsonl \\
+        --planner_host http://localhost:8100 \\
+        --validator_host http://localhost:8101 \\
+        --fixer_host http://localhost:8102 \\
+        --K 4 --K_val 2 --K_fix 1 \\
+        --temperature 0.7 --top_p 0.9 \\
+        --max_questions 1000
+"""
+
+import argparse
+import json
+import os
+import re
+import sys
+import time
+from concurrent.futures import ThreadPoolExecutor
+
+# Bypass HTTP proxy for local vLLM endpoints
+os.environ["NO_PROXY"] = "localhost,127.0.0.1"
+os.environ["no_proxy"] = "localhost,127.0.0.1"
+
+import requests
+from tqdm import tqdm
+
+ROOT = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+os.chdir(ROOT)
+sys.path.insert(0, ROOT)
+
+from validator_data.validator import _execute_sql
+from data_processing.planner import is_execution_correct
+
+
+PLANNER_PROMPT_TEMPLATE = (
+    "{schema}\n\n"
+    "Question: {question}\n"
+    "External knowledge: {evidence}\n\n"
+    "Planning:"
+)
+
+# Validator prompt — must match what the validator was SFT'd to expect.
+VALIDATOR_PROMPT_HEADER = (
+    "You are a SQL critique agent. Output FOUR critique sections "
+    "(<select>...</select>, <condition>...</condition>, <join>...</join>, <order>...</order>) "
+    "analysing the SQL query below; do NOT output any SQL.\n\n"
+)
+
+# Specialized 2-validator headers (match SFT data built in build_validator_2agents_v3.py).
+VALIDATOR_SEL_HEADER = (
+    "You are a SQL SELECT-clause critique agent. Output ONE critique section "
+    "<select>...</select> analysing the SELECT clause of the SQL query below; "
+    "do NOT output any SQL. Use 'None' if the SELECT clause looks correct.\n\n"
+)
+VALIDATOR_COND_HEADER = (
+    "You are a SQL CONDITION critique agent. Output ONE critique section "
+    "<condition>...</condition> analysing the WHERE/HAVING/CASE-WHEN conditions "
+    "of the SQL query below; do NOT output any SQL. Use 'None' if the conditions "
+    "look correct.\n\n"
+)
+
+VALIDATOR_PROMPT_BODY = (
+    "database schema:\n{schema}\n\n"
+    "Question: {question}\n"
+    "External knowledge: {evidence}\n\n"
+    "Generated SQL query: {sql_query}\n\n"
+    "Execution response:\n{execution_response}\n\n"
+)
+
+# Fixer prompt — must match what the fixer was SFT'd to expect.
+FIXER_PROMPT_HEADER = (
+    "You are a SQL fixer. Given the question, schema, original SQL query, "
+    "execution response, and the validator's critique below, output ONLY the corrected "
+    "final SQL inside ```sql ... ``` markers.\n\n"
+)
+
+
+def qwen_chat(prompt: str) -> str:
+    return f"<|im_start|>user\n{prompt}<|im_end|>\n<|im_start|>assistant\n"
+
+
+def vllm_complete(host, model, prompt, n, temperature, top_p, max_tokens, seed=100):
+    payload = {
+        "model": model,
+        "prompt": prompt,
+        "max_tokens": max_tokens,
+        "n": n,
+        "temperature": temperature,
+        "top_p": top_p,
+        "stop": ["<|im_end|>", "<|endoftext|>"],
+        "seed": seed,
+    }
+    for attempt in range(3):
+        try:
+            r = requests.post(f"{host}/v1/completions", json=payload, timeout=120)
+            r.raise_for_status()
+            return [c["text"] for c in r.json()["choices"]]
+        except Exception as e:
+            if attempt == 2:
+                print(f"vLLM call failed: {e}", file=sys.stderr)
+                return []
+            time.sleep(1)
+    return []
+
+
+def extract_sql_from_planner(text):
+    if text is None:
+        return ""
+    m = re.search(r"Final SQL query:\s*```(.+?)```", text, re.DOTALL)
+    if m:
+        s = m.group(1).strip()
+    else:
+        m = re.search(r"```(.+?)```", text, re.DOTALL)
+        if m:
+            s = m.group(1).strip()
+        else:
+            return text.strip()
+    if s.startswith("sql"):
+        s = s[3:].strip()
+    return s
+
+
+def extract_sql_from_fixer(text):
+    if text is None:
+        return ""
+    m = re.search(r"```sql\s*\n?(.+?)```", text, re.DOTALL | re.IGNORECASE)
+    if m:
+        return m.group(1).strip()
+    m = re.search(r"```(.+?)```", text, re.DOTALL)
+    if m:
+        s = m.group(1).strip()
+        if s.lower().startswith("sql"):
+            s = s[3:].strip()
+        return s
+    return text.strip().strip("`").strip()
+
+
+def parse_validator_sections(text):
+    sections = {"select": "", "condition": "", "join": "", "order": ""}
+    for tag in sections:
+        m = re.search(fr"<{tag}>(.*?)</{tag}>", text, re.DOTALL | re.IGNORECASE)
+        if m:
+            sections[tag] = m.group(1).strip()
+    return sections
+
+
+def safe_execute(db_path, sql):
+    if not sql or sql.strip() == "":
+        return ("", True)
+    try:
+        return _execute_sql("./" + db_path, sql)
+    except Exception as e:
+        return (str(e), True)
+
+
+def build_planner_prompt(sample):
+    return PLANNER_PROMPT_TEMPLATE.format(
+        schema=sample.get("schema_sequence") or sample.get("schema") or "",
+        question=sample.get("question", ""),
+        evidence=sample.get("evidence", "") or "None",
+    )
+
+
+def build_validator_prompt(sample, planner_sql, exec_response):
+    body = VALIDATOR_PROMPT_BODY.format(
+        schema=sample.get("schema_sequence") or sample.get("schema") or "",
+        question=sample.get("question", ""),
+        evidence=sample.get("evidence", "") or "None",
+        sql_query=planner_sql,
+        execution_response=exec_response,
+    )
+    return VALIDATOR_PROMPT_HEADER + body
+
+
+def build_validator_sel_prompt(sample, planner_sql, exec_response):
+    body = VALIDATOR_PROMPT_BODY.format(
+        schema=sample.get("schema_sequence") or sample.get("schema") or "",
+        question=sample.get("question", ""),
+        evidence=sample.get("evidence", "") or "None",
+        sql_query=planner_sql,
+        execution_response=exec_response,
+    )
+    return VALIDATOR_SEL_HEADER + body
+
+
+def build_validator_cond_prompt(sample, planner_sql, exec_response):
+    body = VALIDATOR_PROMPT_BODY.format(
+        schema=sample.get("schema_sequence") or sample.get("schema") or "",
+        question=sample.get("question", ""),
+        evidence=sample.get("evidence", "") or "None",
+        sql_query=planner_sql,
+        execution_response=exec_response,
+    )
+    return VALIDATOR_COND_HEADER + body
+
+
+def build_fixer_prompt(sample, planner_sql, exec_response, critique):
+    body = (
+        f"database schema:\n{sample.get('schema_sequence') or sample.get('schema') or ''}\n\n"
+        f"Question: {sample.get('question', '')}\n"
+        f"External knowledge: {sample.get('evidence','') or 'None'}\n\n"
+        f"Generated SQL query: {planner_sql}\n\n"
+        f"Execution response:\n{exec_response}\n\n"
+    )
+    return FIXER_PROMPT_HEADER + body + "\n\nValidator critique:\n" + critique + "\n\nFinal SQL:"
+
+
+def process_sample(sample, args):
+    db_path = sample["db_path"]
+    gold_sql = sample["sql"]
+    true_exec = safe_execute(db_path, gold_sql)
+    if true_exec[1]:
+        return None  # gold has error; skip
+
+    # Stage 1: planner — K samples (optionally split across temperatures via --mixed_temp)
+    planner_prompt_raw = build_planner_prompt(sample)
+    planner_chat = qwen_chat(planner_prompt_raw)
+    if getattr(args, "mixed_temp", "").strip():
+        temps = [float(x) for x in args.mixed_temp.split(",") if x.strip()]
+        # distribute args.K samples across temperatures
+        per_temp = max(1, args.K // len(temps))
+        remainder = args.K - per_temp * len(temps)
+        planner_outputs = []
+        for i, t in enumerate(temps):
+            n_t = per_temp + (1 if i < remainder else 0)
+            if n_t <= 0:
+                continue
+            outs = vllm_complete(
+                args.planner_host, "planner", planner_chat,
+                n=n_t, temperature=t, top_p=args.top_p,
+                max_tokens=args.max_planner_tokens, seed=args.seed + i * 31,
+            )
+            planner_outputs.extend(outs)
+    else:
+        planner_outputs = vllm_complete(
+            args.planner_host, "planner", planner_chat,
+            n=args.K, temperature=args.temperature, top_p=args.top_p,
+            max_tokens=args.max_planner_tokens, seed=args.seed,
+        )
+    if not planner_outputs:
+        return None
+
+    trajectories = []
+    for plan in planner_outputs:
+        planner_sql = extract_sql_from_planner(plan)
+        if not planner_sql:
+            continue
+        planner_exec = safe_execute(db_path, planner_sql)
+        exec_response = (
+            f"Error: {planner_exec[0]}" if planner_exec[1]
+            else f"OK. Result rows (preview): {str(planner_exec[0])[:300]}"
+        )
+
+        # Stage 2: validator — K_val samples per planner output (or skip if validator_host empty)
+        # Three modes:
+        # (a) Two specialized validators: --validator_sel_host + --validator_cond_host (per-paper design)
+        # (b) Legacy unified validator:    --validator_host (single 4-section model)
+        # (c) None: insert all-OK placeholder
+        v_sel = getattr(args, "validator_sel_host", "") or ""
+        v_cond = getattr(args, "validator_cond_host", "") or ""
+        if v_sel and v_sel.lower() != "none" and v_cond and v_cond.lower() != "none":
+            sel_prompt = build_validator_sel_prompt(sample, planner_sql, exec_response)
+            cond_prompt = build_validator_cond_prompt(sample, planner_sql, exec_response)
+            sel_outputs = vllm_complete(
+                v_sel, "validator_sel", qwen_chat(sel_prompt),
+                n=args.K_val, temperature=args.temperature, top_p=args.top_p,
+                max_tokens=args.max_validator_tokens, seed=args.seed,
+            )
+            cond_outputs = vllm_complete(
+                v_cond, "validator_cond", qwen_chat(cond_prompt),
+                n=args.K_val, temperature=args.temperature, top_p=args.top_p,
+                max_tokens=args.max_validator_tokens, seed=args.seed + 1,
+            )
+            # Pair selection+condition outputs index-wise, padding with "None" if one ran short.
+            validator_outputs = []
+            for i in range(args.K_val):
+                s_out = sel_outputs[i] if i < len(sel_outputs) else "<select>\nSELECT.\nNone\n</select>"
+                c_out = cond_outputs[i] if i < len(cond_outputs) else "<condition>\nCONDITION.\nNone\n</condition>"
+                combined = (
+                    s_out.strip() + "\n\n" +
+                    c_out.strip() + "\n\n" +
+                    "<join>\nJOIN.\nNone\n</join>\n\n"
+                    "<order>\nORDER BY.\nNone\n</order>"
+                )
+                validator_outputs.append(combined)
+            validator_prompt_raw = sel_prompt + "\n\n[+]\n\n" + cond_prompt  # for logging
+        elif args.validator_host and args.validator_host.lower() != "none":
+            validator_prompt_raw = build_validator_prompt(sample, planner_sql, exec_response)
+            validator_chat = qwen_chat(validator_prompt_raw)
+            validator_outputs = vllm_complete(
+                args.validator_host, "validator", validator_chat,
+                n=args.K_val, temperature=args.temperature, top_p=args.top_p,
+                max_tokens=args.max_validator_tokens, seed=args.seed,
+            )
+        else:
+            validator_prompt_raw = build_validator_prompt(sample, planner_sql, exec_response)
+            validator_outputs = [
+                "<select>\nSELECT.\nNone\n</select>\n\n"
+                "<condition>\nCONDITION.\nNone\n</condition>\n\n"
+                "<join>\nJOIN.\nNone\n</join>\n\n"
+                "<order>\nORDER BY.\nNone\n</order>"
+            ] * args.K_val
+
+        for val_out in validator_outputs:
+            sections = parse_validator_sections(val_out)
+            critique_text = val_out.strip()  # full critique as the validator's "completion"
+
+            # Stage 3: fixer — K_fix samples (skip when fixer_host=none → keep planner_sql)
+            fixer_prompt_raw = build_fixer_prompt(sample, planner_sql, exec_response, critique_text)
+            if args.fixer_host and args.fixer_host.lower() != "none":
+                fixer_chat = qwen_chat(fixer_prompt_raw)
+                fixer_outputs = vllm_complete(
+                    args.fixer_host, "fixer", fixer_chat,
+                    n=args.K_fix, temperature=args.temperature, top_p=args.top_p,
+                    max_tokens=args.max_fixer_tokens, seed=args.seed,
+                )
+            else:
+                fixer_outputs = [""] * args.K_fix  # empty → fixed_sql will fallback to planner_sql
+
+            for fix_out in fixer_outputs:
+                fixed_sql = extract_sql_from_fixer(fix_out) or planner_sql
+                trajectories.append({
+                    "planner_prompt": planner_prompt_raw,
+                    "planner_output": plan,
+                    "planner_sql": planner_sql,
+                    "planner_exec_ok": not planner_exec[1],
+                    "validator_prompt": validator_prompt_raw,
+                    "validator_output": critique_text,
+                    "fb_select": sections["select"],
+                    "fb_condition": sections["condition"],
+                    "fb_join": sections["join"],
+                    "fb_order": sections["order"],
+                    "fixer_prompt": fixer_prompt_raw,
+                    "fixer_output": fix_out,
+                    "fixed_sql": fixed_sql,
+                })
+
+    if not trajectories:
+        return None
+
+    # Grade each trajectory
+    with ThreadPoolExecutor(max_workers=8) as exe:
+        planner_execs = list(exe.map(
+            lambda t: safe_execute(db_path, t["planner_sql"]), trajectories
+        ))
+        fixed_execs = list(exe.map(
+            lambda t: safe_execute(db_path, t["fixed_sql"]), trajectories
+        ))
+
+    for i, t in enumerate(trajectories):
+        pe, fe = planner_execs[i], fixed_execs[i]
+        t["is_planner_correct"] = (
+            (not pe[1]) and is_execution_correct(true_exec[0], pe[0])
+        )
+        t["is_fixed_correct"] = (
+            (not fe[1]) and is_execution_correct(true_exec[0], fe[0])
+        )
+
+    return {
+        "question": sample["question"],
+        "evidence": sample.get("evidence", ""),
+        "db_path": db_path,
+        "db_id": sample.get("db_id", ""),
+        "schema": sample.get("schema_sequence") or sample.get("schema") or "",
+        "sql": gold_sql,
+        "trajectories": trajectories,
+    }
+
+
+def main():
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--input_file", required=True)
+    parser.add_argument("--output_file", required=True)
+    parser.add_argument("--planner_host", default="http://localhost:8100")
+    parser.add_argument("--validator_host", default="http://localhost:8101",
+                        help="Single unified validator host (legacy 4-section). "
+                             "Ignored when --validator_sel_host AND --validator_cond_host are set.")
+    parser.add_argument("--validator_sel_host", default="",
+                        help="Specialized SELECT-clause validator host (paper v_s). "
+                             "When both this and --validator_cond_host are set, the unified validator is bypassed.")
+    parser.add_argument("--validator_cond_host", default="",
+                        help="Specialized CONDITION validator host (paper v_c).")
+    parser.add_argument("--fixer_host", default="http://localhost:8102")
+    parser.add_argument("--K", type=int, default=4, help="planner samples per question")
+    parser.add_argument("--K_val", type=int, default=2, help="validator samples per planner output")
+    parser.add_argument("--K_fix", type=int, default=1, help="fixer samples per (planner, validator)")
+    parser.add_argument("--temperature", type=float, default=0.7)
+    parser.add_argument("--top_p", type=float, default=0.9)
+    parser.add_argument("--seed", type=int, default=100)
+    parser.add_argument("--max_planner_tokens", type=int, default=1024)
+    parser.add_argument("--max_validator_tokens", type=int, default=512)
+    parser.add_argument("--max_fixer_tokens", type=int, default=512)
+    parser.add_argument("--max_questions", type=int, default=-1)
+    parser.add_argument("--n_threads", type=int, default=8)
+    parser.add_argument("--mixed_temp", type=str, default="",
+                        help="Comma-separated temperatures to mix across K planner samples (e.g. '0.5,0.7,0.9,1.1'). "
+                             "If set, args.temperature is ignored for the planner stage. Used to boost pass@K diversity.")
+    args = parser.parse_args()
+
+    print(f"Loading {args.input_file}...")
+    with open(args.input_file) as f:
+        data = json.load(f)
+    if args.max_questions > 0:
+        data = data[: args.max_questions]
+    print(f"  {len(data)} questions")
+
+    os.makedirs(os.path.dirname(args.output_file), exist_ok=True)
+
+    seen = set()
+    if os.path.exists(args.output_file):
+        with open(args.output_file) as f:
+            for line in f:
+                try:
+                    d = json.loads(line)
+                    seen.add((d["question"], d.get("db_id", "")))
+                except Exception:
+                    pass
+        print(f"  resuming: skip {len(seen)} already-processed")
+
+    todo = [s for s in data if (s["question"], s.get("db_id", "")) not in seen]
+    print(f"  to process: {len(todo)}")
+
+    fout = open(args.output_file, "a")
+    n_ok = 0
+    n_winloss = 0
+
+    with ThreadPoolExecutor(max_workers=args.n_threads) as pool:
+        futures = {pool.submit(process_sample, s, args): s for s in todo}
+        pbar = tqdm(total=len(todo), desc="rollouts")
+        for fut in futures:
+            try:
+                result = fut.result()
+            except Exception as e:
+                print(f"sample failed: {e}", file=sys.stderr)
+                pbar.update(1)
+                continue
+            if result is None:
+                pbar.update(1)
+                continue
+            n_ok += 1
+            wins = sum(1 for t in result["trajectories"] if t["is_fixed_correct"])
+            losses = sum(1 for t in result["trajectories"] if not t["is_fixed_correct"])
+            if wins > 0 and losses > 0:
+                n_winloss += 1
+            fout.write(json.dumps(result) + "\n")
+            fout.flush()
+            pbar.update(1)
+            pbar.set_postfix(ok=n_ok, winloss=n_winloss)
+        pbar.close()
+
+    fout.close()
+    print(f"Done. processed={n_ok}, with_winloss={n_winloss} ({100*n_winloss/max(n_ok,1):.1f}%)")
+
+
+if __name__ == "__main__":
+    main()