# -*- coding: utf-8 -*- """check_a11.py - independent re-verification of SUPERBRAIN-1 Packet A11 (Arabic-instruction Python coding). Checks (exit 0 only if all pass): 1. counts: train == 6021, exam == 1026 (A11_NTRAIN/A11_NEXAM x 27 generators), 27 generators present in both, schema fields present, no duplicate prompts inside a split. 2. reference solutions: random sample (>=300 train + 100 exam code items) re-run through a11_score.score() on their gold completion (subprocess + hidden tests, 5 s timeout) -> must be 100%; fix_bug items in the sample: the buggy version must FAIL. 3. predict_output: random sample (150 train + 50 exam) snippets re-executed in a subprocess -> stdout must equal the stored answer; the gold completion and a bare "الناتج: ..." answer must score True. 4. negative control: completions of OTHER items must score < 5%. 5. leakage train<->exam: exact / normalized prompt, normalized question, question hash, code -> all 0. """ import os, sys, json, random, hashlib, collections, time from concurrent.futures import ThreadPoolExecutor os.environ["CUDA_VISIBLE_DEVICES"] = "" try: sys.stdout.reconfigure(encoding="utf-8", errors="replace") except Exception: pass sys.path.insert(0, os.path.dirname(os.path.abspath(__file__))) from a11_score import score, run_py, norm_out, CODE_KINDS # noqa: E402 from build_packet_a11 import norm, question_of, code_norm, GENS # noqa: E402 T = os.environ.get("A11_DIR", r"E:\ABU\02_PROJECTS\AHMAD-1\train") NG = len(GENS) EXP_TRAIN = NG * int(os.environ.get("A11_NTRAIN", "223")) EXP_EXAM = NG * int(os.environ.get("A11_NEXAM", "38")) N_REF_TRAIN, N_REF_EXAM, N_PRED_TRAIN, N_PRED_EXAM, N_NEG = 300, 100, 150, 50, 100 WORKERS = int(os.environ.get("A11_WORKERS", "6")) FIELDS = ["task", "src", "kind", "topic", "template", "prompt", "completion", "answer", "qhash"] def load(p): with open(p, encoding="utf-8") as f: return [json.loads(l) for l in f if l.strip()] def main(): t0 = time.time() ok_all = True tr = load(os.path.join(T, "packet_a11_train.jsonl")) ex = load(os.path.join(T, "packet_a11_exam.jsonl")) # 1. counts / schema gtr = {x["template"].split("#")[0] for x in tr} gex = {x["template"].split("#")[0] for x in ex} miss = sum(1 for x in tr + ex for k in FIELDS if k not in x) + \ sum(1 for x in tr + ex if x["kind"] in CODE_KINDS and not x.get("test_code")) dups = (len(tr) - len({x["prompt"] for x in tr})) + (len(ex) - len({x["prompt"] for x in ex})) exam_phr = collections.Counter(x["template"].split("#")[1] for x in ex) c_ok = (len(tr) == EXP_TRAIN and len(ex) == EXP_EXAM and len(gtr) == NG and len(gex) == NG and miss == 0 and dups == 0 and set(exam_phr) == {"2"}) print(f"[counts] train={len(tr)} (expect {EXP_TRAIN}) exam={len(ex)} (expect {EXP_EXAM}) " f"generators train={len(gtr)} exam={len(gex)} (expect {NG}) missing_fields={miss} dup_prompts={dups} " f"exam_phrasings={dict(exam_phr)} -> {'OK' if c_ok else 'FAIL'}") print(f"[counts] train by kind {dict(sorted(collections.Counter(x['kind'] for x in tr).items()))}") print(f"[counts] exam by kind {dict(sorted(collections.Counter(x['kind'] for x in ex).items()))}") ok_all &= c_ok rng = random.Random(1111) code_tr = [x for x in tr if x["kind"] in CODE_KINDS] code_ex = [x for x in ex if x["kind"] in CODE_KINDS] pred_tr = [x for x in tr if x["kind"] == "predict_output"] pred_ex = [x for x in ex if x["kind"] == "predict_output"] ref_sample = rng.sample(code_tr, N_REF_TRAIN) + rng.sample(code_ex, N_REF_EXAM) pred_sample = rng.sample(pred_tr, N_PRED_TRAIN) + rng.sample(pred_ex, N_PRED_EXAM) # 2. reference solutions pass hidden tests; buggy versions fail def ref_job(x): good = score(x["completion"], x, timeout=5.0) bad = None if x["kind"] == "fix_bug": bad = score(f"```python\n{x['buggy']}\n```", x, timeout=5.0) return good, bad with ThreadPoolExecutor(WORKERS) as pool: res = list(pool.map(ref_job, ref_sample)) n_ref = len(res) ref_pass = sum(1 for g, _ in res if g) fix = [b for _, b in res if b is not None] fix_bad_pass = sum(1 for b in fix if b) by_kind = collections.Counter(x["kind"] for x in ref_sample) r_ok = ref_pass == n_ref and fix_bad_pass == 0 print(f"[reference] sample={n_ref} {dict(by_kind)} pass={ref_pass}/{n_ref} ({100 * ref_pass / n_ref:.2f}%) | " f"fix_bug buggy versions passing={fix_bad_pass}/{len(fix)} (must be 0) -> {'OK' if r_ok else 'FAIL'}") ok_all &= r_ok # 3. predict_output gold re-execution def pred_job(x): rc, out, _ = run_py(x["code"], timeout=5.0) same = rc == 0 and norm_out(out) == norm_out(x["answer"]) return same, score(x["completion"], x), score("الناتج: " + x["answer"], x) with ThreadPoolExecutor(WORKERS) as pool: pres = list(pool.map(pred_job, pred_sample)) n_p = len(pres) rerun = sum(a for a, _, _ in pres) gold = sum(b for _, b, _ in pres) bare = sum(c for _, _, c in pres) p_ok = rerun == gold == bare == n_p print(f"[predict] sample={n_p} re-executed_match={rerun}/{n_p} gold_completion_scores={gold}/{n_p} " f"bare_answer_scores={bare}/{n_p} -> {'OK' if p_ok else 'FAIL'}") ok_all &= p_ok # 4. negative control neg_items = rng.sample(code_ex, N_NEG // 2) + rng.sample(pred_ex, N_NEG // 2) pairs = [] # pair each item with a completion from a different generator (drawn serially: rng not thread-safe) for x in neg_items: pool_ = code_tr if x["kind"] in CODE_KINDS else pred_tr while True: y = pool_[rng.randrange(len(pool_))] if y["template"].split("#")[0] != x["template"].split("#")[0]: pairs.append((x, y)) break with ThreadPoolExecutor(WORKERS) as pool: negs = list(pool.map(lambda xy: score(xy[1]["completion"], xy[0], timeout=5.0), pairs)) neg_rate = 100 * sum(negs) / len(negs) n_ok = neg_rate < 5 print(f"[negative] other-item completions scored correct: {sum(negs)}/{len(negs)} ({neg_rate:.1f}%, must be <5%) " f"-> {'OK' if n_ok else 'FAIL'}") ok_all &= n_ok # 5. leakage def sets(items): ps = [x["prompt"] for x in items] qs = [question_of(p) for p in ps] return {"exact": set(ps), "norm": {norm(p) for p in ps}, "qnorm": {norm(q) for q in qs}, "qhash": {hashlib.sha1(q.encode("utf-8")).hexdigest()[:16] for q in qs}, "code": {code_norm(x.get("code") or x.get("reference")) for x in items}} A, B = sets(tr), sets(ex) leak = {k: len(A[k] & B[k]) for k in A} total = sum(leak.values()) l_ok = total == 0 print(f"[leakage] train_vs_exam {leak} LEAKAGE={total} -> {'OK' if l_ok else 'FAIL'}") ok_all &= l_ok print(f"CHECK_A11 {'PASS' if ok_all else 'FAIL'} ({time.time() - t0:.0f}s)") return 0 if ok_all else 1 if __name__ == "__main__": sys.exit(main())