code/scripts/build_selector_v5_pairs.py

"""
Phase 1b — Construct pairwise pair records from BIRD-train candidate file.

Reads:  data/qwen72b_candidates_bird_train.jsonl  (from gen_qwen72b_candidates_bird_train.py)
Writes: data/selector_v5_pairs_raw.jsonl

Each pair record carries everything needed to render the student prompt and
later ask the teacher for reasoning. Labels:
  - 0  = sql_a correct, sql_b wrong
  - 1  = sql_b correct, sql_a wrong
  - -1 = both wrong (neither)

Pair selection per question (with ≥1 YES and ≥1 NO):
  - Up to MAX_YN (4) (YES, NO) hard-neg pairs ranked by Jaccard overlap.
  - Up to MAX_NN (1) (NO, NO) pair.
  - For each raw pair, emit TWO records (swap A/B) for label balance.

GOLD AUGMENTATION (--inject_gold): If a question has no YES candidate (or just
to add a strong YES signal), inject the gold SQL as a synthetic YES candidate.
This counters BIRD's strict grading where Qwen-72B produces semantically
correct SQL that misses gold's exact conventions (LIMIT 1, IS NOT NULL).
"""
import argparse
import json
import os
import re
import sys

os.environ.setdefault("PYTHONNOUSERSITE", "1")
os.environ.setdefault("DB_EXEC_API_DISABLE", "1")
ROOT = "/weka/s225250685/mats-tist"
os.chdir(ROOT)
sys.path.insert(0, ROOT)

from validator_data.validator import _execute_sql


def gold_exec_str(db_path, sql, timeout=10):
    if not sql or not sql.strip():
        return "Error: empty SQL"
    try:
        r, err = _execute_sql("./" + db_path if not db_path.startswith("./") else db_path, sql, timeout=timeout)
    except Exception as e:
        return f"Error: {str(e)[:160]}"
    if err:
        return f"Error: {str(r)[:160]}"
    rows = str(r)[:260]
    if rows.strip() and rows.strip() != "[]":
        return f"OK. Rows preview: {rows}"
    return "OK. (no rows returned)"


def tokens(sql):
    return set(re.findall(r"[a-zA-Z_][a-zA-Z0-9_]+|[<>=!]+", (sql or "").lower()))


def jaccard(a, b):
    if not a or not b:
        return 0.0
    return len(a & b) / max(len(a | b), 1)


def main():
    ap = argparse.ArgumentParser()
    ap.add_argument("--input", default="data/qwen72b_candidates_bird_train.jsonl")
    ap.add_argument("--out", default="data/selector_v5_pairs_raw.jsonl")
    ap.add_argument("--max_yn", type=int, default=4, help="max (YES,NO) raw pairs per Q")
    ap.add_argument("--max_nn", type=int, default=1, help="max (NO,NO) raw pairs per Q")
    ap.add_argument("--inject_gold", action="store_true", default=True,
                    help="Inject gold SQL as a YES candidate (default True). Use --no-inject_gold to disable.")
    ap.add_argument("--no-inject_gold", dest="inject_gold", action="store_false")
    args = ap.parse_args()

    n_q = 0
    n_yes_only = 0
    n_no_only = 0
    n_both = 0
    n_emitted = 0
    n_gold_added = 0

    out_f = open(args.out, "w")
    with open(args.input) as f:
        for line in f:
            line = line.strip()
            if not line:
                continue
            r = json.loads(line)
            n_q += 1
            cands = r.get("candidates", [])
            # dedupe by normalized SQL
            seen = set()
            uniq = []
            for c in cands:
                norm = re.sub(r"\s+", " ", (c.get("sql") or "").strip().lower())
                if not norm or norm in seen:
                    continue
                seen.add(norm)
                uniq.append(c)

            # Optionally inject gold as a synthetic YES candidate.
            if args.inject_gold and r.get("sql"):
                gold_norm = re.sub(r"\s+", " ", r["sql"].strip().lower())
                if gold_norm not in seen:
                    gold_exec = gold_exec_str(r["db_path"], r["sql"])
                    if not gold_exec.startswith("Error"):
                        uniq.append({
                            "sql": r["sql"],
                            "exec_str": gold_exec,
                            "is_correct": True,
                            "exec_ok": True,
                            "_from_gold": True,
                        })
                        seen.add(gold_norm)
                        n_gold_added += 1
            yes = [c for c in uniq if c.get("is_correct")]
            no = [c for c in uniq if not c.get("is_correct")]
            has_y, has_n = bool(yes), bool(no)
            if has_y and not has_n:
                n_yes_only += 1
            if has_n and not has_y:
                n_no_only += 1
            if has_y and has_n:
                n_both += 1
            if not (has_y and has_n) and not (len(no) >= 2 and args.max_nn > 0):
                continue

            # (YES, NO) hard-neg pairs
            yn_pairs = []
            if has_y and has_n:
                yes_toks = [tokens(y["sql"]) for y in yes]
                no_scored = []
                for ni, nc in enumerate(no):
                    tnc = tokens(nc["sql"])
                    best = max((jaccard(tnc, ty) for ty in yes_toks), default=0.0)
                    no_scored.append((best, ni))
                no_scored.sort(reverse=True)
                ranked_no = [no[i] for _, i in no_scored]
                for ys in yes:
                    for nc in ranked_no[: args.max_yn]:
                        yn_pairs.append((ys, nc))
                        if len(yn_pairs) >= args.max_yn:
                            break
                    if len(yn_pairs) >= args.max_yn:
                        break

            # (NO, NO) "neither" pairs
            nn_pairs = []
            if len(no) >= 2 and args.max_nn > 0:
                # hardest = top-2 by mutual jaccard distance (most different) — but for now random first-2
                nn_pairs.append((no[0], no[1]))

            for kind, pair_list in (("yn", yn_pairs), ("nn", nn_pairs)):
                for c_y, c_n in pair_list:
                    # Define A=c_y, B=c_n.
                    # Label idx: 0 if A correct, 1 if B correct, -1 if neither.
                    a_correct = bool(c_y.get("is_correct"))
                    b_correct = bool(c_n.get("is_correct"))
                    if a_correct and not b_correct:
                        idx_ab = 0
                    elif b_correct and not a_correct:
                        idx_ab = 1
                    else:
                        idx_ab = -1  # both wrong (kind == 'nn'), or both right (shouldn't occur here)
                    rec_ab = {
                        "question": r["question"],
                        "db_id": r["db_id"],
                        "db_path": r["db_path"],
                        "evidence": r.get("evidence", ""),
                        "schema": r.get("schema", {}),
                        "matched_contents": r.get("matched_contents", {}),
                        "sql_a": c_y["sql"],
                        "exec_a": c_y["exec_str"],
                        "sql_b": c_n["sql"],
                        "exec_b": c_n["exec_str"],
                        "gold_idx": idx_ab,
                        "kind": kind,
                    }
                    out_f.write(json.dumps(rec_ab) + "\n")
                    n_emitted += 1
                    # Swap A/B
                    idx_ba = -1 if idx_ab == -1 else (1 - idx_ab)
                    rec_ba = dict(rec_ab)
                    rec_ba["sql_a"], rec_ba["sql_b"] = rec_ab["sql_b"], rec_ab["sql_a"]
                    rec_ba["exec_a"], rec_ba["exec_b"] = rec_ab["exec_b"], rec_ab["exec_a"]
                    rec_ba["gold_idx"] = idx_ba
                    out_f.write(json.dumps(rec_ba) + "\n")
                    n_emitted += 1

    out_f.close()
    print(f"questions read: {n_q}", flush=True)
    print(f"  has YES & NO: {n_both}", flush=True)
    print(f"  YES only:     {n_yes_only}", flush=True)
    print(f"  NO only:      {n_no_only}", flush=True)
    print(f"  gold injected: {n_gold_added}", flush=True)
    print(f"pair records emitted: {n_emitted}", flush=True)


if __name__ == "__main__":
    main()