| """Stage 3: per-task integrity matching.
|
|
|
| Tiers (each individually testable, overlapping by construction):
|
| exact_row same canonical sequence + name + label + task
|
| exact_sequence case-insensitive identical nucleotide string
|
| reverse_complement test sequence equals revcomp of a train sequence
|
| exact_locus same (chrom, start, end) parsed from `name`
|
| interval_overlap positive genomic overlap (any / >=50% / >=90% of either interval)
|
| near_sequence k-mer candidate then edlib-verified alignment (>=98% id, >=95% cov;
|
| sensitivity tier at >=95% id), excluding byte-identical pairs
|
| label_conflict same-task identical sequence or same locus with incompatible labels
|
|
|
| Outputs per task:
|
| work/out/{task}_test_status.parquet one row per real test row
|
| work/out/{task}_matches.parquet evidence-linked pairs
|
| work/out/{task}_summary.json counters + denominators + coverage
|
| """
|
| from __future__ import annotations
|
|
|
| import argparse
|
| import json
|
| import math
|
| import sys
|
| import time
|
| from collections import Counter, defaultdict
|
| from pathlib import Path
|
|
|
| import edlib
|
| import numpy as np
|
| import polars as pl
|
|
|
| sys.path.insert(0, str(Path(__file__).resolve().parent))
|
| from common import (StageLog, canon, json_dump, parse_coord, revcomp,
|
| row_uid, sha256_text)
|
|
|
| LUT = np.full(256, 4, dtype=np.uint8)
|
| for _b, _v in zip(b"ACGT", range(4)):
|
| LUT[_b] = _v
|
|
|
| K = 21
|
| SKETCH = 32
|
| MIN_SHARED = 6
|
| MAX_CANDIDATES = 25
|
| MAX_DF = 600
|
| IDENT_MAIN = 0.98
|
| IDENT_SENS = 0.95
|
| COV_MAIN = 0.95
|
|
|
|
|
|
|
| def prepare_split(df: pl.DataFrame, task: str, split: str) -> pl.DataFrame:
|
| seqs = df["sequence"].to_list()
|
| names = df["name"].to_list()
|
| labels = df["label"].to_list()
|
| coords = [parse_coord(n) for n in names]
|
| canon_seqs = [canon(s) for s in seqs]
|
| rc_seqs = [revcomp(s) for s in canon_seqs]
|
| recs = {
|
| "uid": [row_uid(task, split, i) for i in range(len(seqs))],
|
| "row_index": list(range(len(seqs))),
|
| "name": names,
|
| "label": labels,
|
| "sequence": seqs,
|
| "canon": canon_seqs,
|
| "canon_sha": [sha256_text(s) for s in canon_seqs],
|
| "rc_sha": [sha256_text(s) for s in rc_seqs],
|
| "strand_sha": [sha256_text(min(s, r)) for s, r in zip(canon_seqs, rc_seqs)],
|
| "seq_len": [len(s) for s in canon_seqs],
|
| "palindrome": [s == r for s, r in zip(canon_seqs, rc_seqs)],
|
| "chrom": [c.chrom if c.ok else None for c in coords],
|
| "start": [c.start if c.ok else None for c in coords],
|
| "end": [c.end if c.ok else None for c in coords],
|
| "coord_ok": [c.ok for c in coords],
|
| "coord_tier": [c.tier for c in coords],
|
| "coord_error": [c.error for c in coords],
|
| "suffix": [c.suffix for c in coords],
|
| }
|
| return pl.DataFrame(recs, schema_overrides={
|
| "chrom": pl.String, "start": pl.Int64, "end": pl.Int64,
|
| "suffix": pl.String, "coord_ok": pl.Boolean, "coord_tier": pl.String,
|
| "coord_error": pl.String, "palindrome": pl.Boolean,
|
| "row_index": pl.Int64, "label": pl.Int64, "seq_len": pl.Int64,
|
| })
|
|
|
|
|
|
|
| def kmer_bottomk(seq: str, k: int = K, size: int = SKETCH) -> np.ndarray:
|
| n = len(seq)
|
| if n < k:
|
| return np.zeros(0, dtype=np.uint64)
|
| codes = LUT[np.frombuffer(seq.encode("ascii", "replace"), dtype=np.uint8)]
|
| m = n - k + 1
|
| fwd = np.zeros(m, dtype=np.uint64)
|
| bad = np.zeros(m, dtype=np.int32)
|
| for j in range(k):
|
| c = codes[j:j + m].astype(np.uint64)
|
| fwd = (fwd << np.uint64(2)) | c
|
| bad += (codes[j:j + m] >= 4).astype(np.int32)
|
| rseq = revcomp(seq)
|
| rcodes = LUT[np.frombuffer(rseq.encode("ascii", "replace"), dtype=np.uint8)]
|
| rev = np.zeros(m, dtype=np.uint64)
|
| for j in range(k):
|
| c = rcodes[j:j + m].astype(np.uint64)
|
| rev = (rev << np.uint64(2)) | c
|
| rev = rev[::-1]
|
| vals = np.minimum(fwd, rev)
|
| vals = vals[bad == 0]
|
| if vals.size == 0:
|
| return np.zeros(0, dtype=np.uint64)
|
| u = np.unique(vals)
|
| return u[:size]
|
|
|
|
|
| def build_index(train: pl.DataFrame):
|
| seqs = train["canon"].to_list()
|
| index: dict[int, list[int]] = defaultdict(list)
|
| sketches = []
|
| for i, s in enumerate(seqs):
|
| sk = kmer_bottomk(s)
|
| sketches.append(sk)
|
| for h in sk:
|
| index[int(h)].append(i)
|
|
|
| dropped = {h: len(v) for h, v in index.items() if len(v) > MAX_DF}
|
| for h in dropped:
|
| del index[h]
|
| return index, sketches, dropped
|
|
|
|
|
| def candidates_for(sk: np.ndarray, index: dict, cap: int = MAX_CANDIDATES):
|
| if sk.size == 0:
|
| return []
|
| counts: Counter = Counter()
|
| for h in sk:
|
| lst = index.get(int(h))
|
| if lst:
|
| for i in lst:
|
| counts[i] += 1
|
| if not counts:
|
| return []
|
| ranked = sorted(counts.items(), key=lambda kv: (-kv[1], kv[0]))
|
| ranked = [kv for kv in ranked if kv[1] >= MIN_SHARED]
|
| return ranked[:cap]
|
|
|
|
|
|
|
| def align_hw(query: str, target: str):
|
| """edlib infix alignment: whole query aligned to a substring of target."""
|
| r = edlib.align(query, target, mode="HW", task="locations")
|
| if r["editDistance"] < 0:
|
| return None
|
| span = r["locations"][0][1] - r["locations"][0][0] + 1 if r["locations"] else 0
|
| L = len(query)
|
| matches = L - r["editDistance"]
|
| return {
|
| "identity": matches / L if L else 0.0,
|
| "q_cov": 1.0,
|
| "r_cov": span / len(target) if target else 0.0,
|
| "edits": r["editDistance"],
|
| }
|
|
|
|
|
| def near_verify(test_seq: str, train_seq: str):
|
| best = None
|
| for orient, target in (("forward", train_seq), ("opposite", revcomp(train_seq))):
|
| a = align_hw(test_seq, target)
|
| if a is None:
|
| continue
|
| a["orientation"] = orient
|
| if best is None or (a["identity"], a["r_cov"]) > (best["identity"], best["r_cov"]):
|
| best = a
|
| return best
|
|
|
|
|
|
|
| def interval_pairs(test: pl.DataFrame, train: pl.DataFrame, cap_pairs: int = 300000):
|
| """Interval-tree overlap per chromosome. Returns (pairs, totals)."""
|
| from intervaltree import IntervalTree
|
|
|
| pairs = []
|
| truncated = False
|
| trees = defaultdict(IntervalTree)
|
| for r in train.select("row_index", "chrom", "start", "end").iter_rows(named=True):
|
| if r["chrom"] is not None:
|
| trees[r["chrom"]][r["start"]:r["end"]] = r["row_index"]
|
| for r in test.select("row_index", "chrom", "start", "end").iter_rows(named=True):
|
| if r["chrom"] is None:
|
| continue
|
| tree = trees.get(r["chrom"])
|
| if tree is None:
|
| continue
|
| for iv in sorted(tree.overlap(r["start"], r["end"])):
|
| ti = iv.data
|
| ov = min(iv.end, r["end"]) - max(iv.begin, r["start"])
|
| if ov <= 0:
|
| continue
|
| pairs.append((r["row_index"], ti, ov,
|
| ov / max(1, r["end"] - r["start"]),
|
| ov / max(1, iv.end - iv.begin),
|
| r["chrom"], r["start"], r["end"]))
|
| if len(pairs) > cap_pairs:
|
| truncated = True
|
| break
|
| if truncated:
|
| break
|
| return pairs, truncated
|
|
|
|
|
|
|
| def match_task(task: str, work: Path, pkg: Path, log: StageLog) -> dict:
|
| data = work / "data" / task
|
| outdir = work / "out"
|
| outdir.mkdir(parents=True, exist_ok=True)
|
| tr = prepare_split(pl.read_parquet(data / "train.parquet"), task, "train")
|
| te = prepare_split(pl.read_parquet(data / "test.parquet"), task, "test")
|
| prepdir = work / "prep"
|
| prepdir.mkdir(parents=True, exist_ok=True)
|
| pl.concat([tr.with_columns(pl.lit("train").alias("split")),
|
| te.with_columns(pl.lit("test").alias("split"))]).write_parquet(
|
| prepdir / f"{task}.parquet", compression="zstd")
|
|
|
| train_rows = tr.to_dicts()
|
| test_rows = te.to_dicts()
|
|
|
|
|
| by_sha = defaultdict(list)
|
| by_rcsha = defaultdict(list)
|
| by_row = defaultdict(list)
|
| by_locus = defaultdict(list)
|
| for r in train_rows:
|
| by_sha[r["canon_sha"]].append(r)
|
| by_rcsha[r["rc_sha"]].append(r)
|
| by_row[(r["canon_sha"], r["name"], r["label"])].append(r)
|
| if r["coord_ok"]:
|
| by_locus[(r["chrom"], r["start"], r["end"])].append(r)
|
|
|
| matches = []
|
| flags = defaultdict(dict)
|
| for r in test_rows:
|
| f = flags[r["uid"]]
|
| for t in ("exact_row", "exact_sequence", "reverse_complement", "exact_locus",
|
| "interval_overlap_any", "interval_overlap_50", "interval_overlap_90",
|
| "near_sequence_98", "near_sequence_95", "label_conflict"):
|
| f[t] = False
|
| f["coordinate_parsed"] = r["coord_ok"]
|
| f["coordinate_error"] = r["coord_error"]
|
| if not r["coord_ok"]:
|
| for t in ("exact_locus", "interval_overlap_any", "interval_overlap_50",
|
| "interval_overlap_90"):
|
| f[t] = None
|
| for r in test_rows:
|
| uid = r["uid"]
|
| f = flags[uid]
|
| exact = by_sha.get(r["canon_sha"], [])
|
| if exact:
|
| f["exact_sequence"] = True
|
| for t in exact:
|
| matches.append(_m(task, "exact_sequence", r, t, note="identical canonical sequence"))
|
| if (t["name"], t["label"]) == (r["name"], r["label"]):
|
| f["exact_row"] = True
|
| matches.append(_m(task, "exact_row", r, t, note="sequence+name+label equal"))
|
| else:
|
| f["exact_sequence"] = False
|
| rc = by_rcsha.get(r["canon_sha"], [])
|
| rc_hits = [t for t in rc if t["canon_sha"] != r["canon_sha"]]
|
| if rc_hits:
|
| f["reverse_complement"] = True
|
| for t in rc_hits:
|
| matches.append(_m(task, "reverse_complement", r, t,
|
| orientation="opposite", note="test = revcomp(train)"))
|
| else:
|
| f["reverse_complement"] = False
|
| f["palindrome"] = r["palindrome"]
|
| if r["coord_ok"]:
|
| loc = by_locus.get((r["chrom"], r["start"], r["end"]), [])
|
| f["exact_locus"] = bool(loc)
|
| for t in loc:
|
| matches.append(_m(task, "exact_locus", r, t, chrom=r["chrom"],
|
| note="same parsed interval"))
|
| else:
|
| f["exact_locus"] = None
|
|
|
|
|
| pairs, truncated = interval_pairs(te, tr)
|
| test_by_idx = {r["row_index"]: r for r in test_rows}
|
| train_by_idx = {r["row_index"]: r for r in train_rows}
|
| ov_any = defaultdict(int)
|
| ov50 = defaultdict(int)
|
| ov90 = defaultdict(int)
|
| for (ti, tri, ov, ft, fr, chrom, s, e) in pairs:
|
| r, t = test_by_idx[ti], train_by_idx[tri]
|
| ov_any[ti] += 1
|
| if ft >= 0.5 and fr >= 0.5:
|
| ov50[ti] += 1
|
| if ft >= 0.9 and fr >= 0.9:
|
| ov90[ti] += 1
|
| matches.append(_m(task, "interval_overlap", r, t, chrom=chrom, overlap_bp=ov,
|
| frac_test=round(ft, 6), frac_train=round(fr, 6),
|
| note="positive interval overlap"))
|
| for r in test_rows:
|
| f = flags[r["uid"]]
|
| f["interval_overlap_any"] = bool(ov_any.get(r["row_index"])) if r["coord_ok"] else None
|
| f["interval_overlap_50"] = bool(ov50.get(r["row_index"])) if r["coord_ok"] else None
|
| f["interval_overlap_90"] = bool(ov90.get(r["row_index"])) if r["coord_ok"] else None
|
|
|
|
|
| index, train_sketches, dropped = build_index(tr)
|
| near_counts = defaultdict(int)
|
| near_sens = defaultdict(int)
|
| cand_rows = 0
|
| for r in test_rows:
|
| sk = kmer_bottomk(r["canon"])
|
| cands = candidates_for(sk, index)
|
| cand_rows += len(cands)
|
| for ci, shared in cands:
|
| t = train_rows[ci]
|
| if t["canon_sha"] == r["canon_sha"]:
|
| continue
|
| v = near_verify(r["canon"], t["canon"])
|
| if v is None:
|
| continue
|
| ok_main = (v["identity"] >= IDENT_MAIN and v["q_cov"] >= COV_MAIN
|
| and v["r_cov"] >= COV_MAIN)
|
| ok_sens = (v["identity"] >= IDENT_SENS and v["q_cov"] >= COV_MAIN
|
| and v["r_cov"] >= COV_MAIN)
|
| if ok_sens:
|
| near_sens[r["uid"]] += 1
|
| if ok_main:
|
| near_counts[r["uid"]] += 1
|
| if ok_sens:
|
| matches.append(_m(task, "near_sequence_98" if ok_main else "near_sequence_95",
|
| r, t,
|
| identity=round(v["identity"], 6),
|
| q_cov=round(v["q_cov"], 6), r_cov=round(v["r_cov"], 6),
|
| orientation=v["orientation"],
|
| note=f"shared_sketch={shared}"))
|
| for r in test_rows:
|
| f = flags[r["uid"]]
|
| f["near_sequence_98"] = near_counts.get(r["uid"], 0) > 0
|
| f["near_sequence_95"] = near_sens.get(r["uid"], 0) > 0
|
| f["n_near_98_matches"] = near_counts.get(r["uid"], 0)
|
| f["n_near_95_matches"] = near_sens.get(r["uid"], 0)
|
|
|
|
|
| conflict_pairs = 0
|
| for r in test_rows:
|
| for t in by_sha.get(r["canon_sha"], []):
|
| if t["label"] != r["label"]:
|
| flags[r["uid"]]["label_conflict"] = True
|
| conflict_pairs += 1
|
| matches.append(_m(task, "label_conflict", r, t,
|
| note=f"identical sequence, labels {t['label']} vs {r['label']}"))
|
| if r["coord_ok"]:
|
| for t in by_locus.get((r["chrom"], r["start"], r["end"]), []):
|
| if t["label"] != r["label"]:
|
| flags[r["uid"]]["label_conflict"] = True
|
|
|
|
|
| tiers = ["exact_row", "exact_sequence", "reverse_complement", "exact_locus",
|
| "interval_overlap_any", "interval_overlap_50", "interval_overlap_90",
|
| "near_sequence_98", "near_sequence_95", "label_conflict"]
|
| status_rows = []
|
| for r in test_rows:
|
| f = flags[r["uid"]]
|
| row = {"uid": r["uid"], "task": task, "split": "test",
|
| "row_index": r["row_index"], "name": r["name"], "label": r["label"],
|
| "seq_len": r["seq_len"], "chrom": r["chrom"], "start": r["start"],
|
| "end": r["end"], "coord_ok": r["coord_ok"],
|
| "coord_tier": r["coord_tier"], "coord_error": r["coord_error"]}
|
| for t in tiers:
|
| v = f.get(t)
|
| row[t] = bool(v) if v is not None else None
|
| row[f"{t}_not_evaluated"] = v is None
|
| union = any(bool(f.get(t)) for t in
|
| ["exact_sequence", "reverse_complement", "exact_locus",
|
| "interval_overlap_any", "near_sequence_98"])
|
| row["any_within_task_match"] = union
|
| row["chromosome_in_train"] = None
|
| status_rows.append(row)
|
| status = pl.DataFrame(status_rows, schema_overrides={
|
| t: pl.Boolean for t in tiers + [f"{x}_not_evaluated" for x in tiers]
|
| } | {"coordinate_parsed": pl.Boolean, "any_within_task_match": pl.Boolean,
|
| "coord_ok": pl.Boolean, "chromosome_in_train": pl.Boolean})
|
|
|
|
|
| n_test = te.height
|
| n_train = tr.height
|
| summary = {
|
| "task": task,
|
| "train_rows": n_train,
|
| "test_rows": n_test,
|
| "coordinate_parsed_train": int(tr["coord_ok"].sum()),
|
| "coordinate_parsed_test": int(te["coord_ok"].sum()),
|
| "coordinate_coverage_test": round(float(te["coord_ok"].sum()) / n_test, 6) if n_test else None,
|
| "interval_overlap_pairs": len(pairs),
|
| "interval_truncated": truncated,
|
| "near_candidate_pairs": cand_rows,
|
| "near_sketch_hashes_dropped_common": len(dropped),
|
| "label_conflict_pairs_identical_sequence": conflict_pairs,
|
| "tiers": {},
|
| }
|
| for t in tiers:
|
| if t in ("near_sequence_98", "near_sequence_95"):
|
| summary["tiers"][t] = int(sum(1 for r in test_rows
|
| if flags[r["uid"]].get(t) is True))
|
| elif t == "label_conflict":
|
| summary["tiers"][t] = int(sum(1 for r in test_rows
|
| if flags[r["uid"]].get(t) is True))
|
| elif t in ("interval_overlap_any", "interval_overlap_50", "interval_overlap_90"):
|
| summary["tiers"][t] = int(sum(1 for r in test_rows
|
| if flags[r["uid"]].get(t) is True))
|
| elif t == "exact_locus":
|
| summary["tiers"][t] = int(sum(1 for r in test_rows
|
| if flags[r["uid"]].get(t) is True))
|
| else:
|
| summary["tiers"][t] = int(sum(1 for r in test_rows
|
| if flags[r["uid"]].get(t) is True))
|
| summary["union_any_tier_test_rows"] = int(status["any_within_task_match"].sum())
|
|
|
|
|
| tr_chroms = set(tr.filter(pl.col("coord_ok"))["chrom"].to_list())
|
| te_chroms = set(te.filter(pl.col("coord_ok"))["chrom"].to_list())
|
| inter = sorted(tr_chroms & te_chroms)
|
| summary["chromosomes"] = {
|
| "train_set": sorted(tr_chroms), "test_set": sorted(te_chroms),
|
| "intersection": inter,
|
| "intersection_size": len(inter),
|
| "train_denominator_rows": int(tr["coord_ok"].sum()),
|
| "test_denominator_rows": int(te["coord_ok"].sum()),
|
| "holdout_contradicted_by_chromosome_sets": len(inter) > 0,
|
| }
|
| if inter:
|
| m = te.filter(pl.col("coord_ok") & pl.col("chrom").is_in(inter))
|
| summary["chromosomes"]["test_rows_on_shared_chromosomes"] = m.height
|
| summary["chromosomes"]["test_rows_on_shared_chromosomes_fraction"] = round(m.height / n_test, 6)
|
|
|
|
|
| status = status.with_columns(
|
| pl.when(pl.col("coord_ok"))
|
| .then(pl.col("chrom").is_in(sorted(tr_chroms)))
|
| .otherwise(None)
|
| .alias("chromosome_in_train")
|
| )
|
|
|
|
|
| status.write_parquet(outdir / f"{task}_test_status.parquet")
|
| if matches:
|
| mdf = pl.DataFrame(matches, schema=MATCH_SCHEMA, strict=False)
|
| else:
|
| mdf = pl.DataFrame(schema=MATCH_SCHEMA)
|
| mdf.write_parquet(outdir / f"{task}_matches.parquet")
|
| summary["match_rows"] = mdf.height
|
| summary["match_rows_by_tier"] = dict(Counter(mdf["tier"].to_list())) if mdf.height else {}
|
| summary["test_rows_with_any_match"] = int(status["any_within_task_match"].sum())
|
| json_dump(summary, outdir / f"{task}_summary.json")
|
| log.info("task matched", task=task, test=n_test,
|
| matches=mdf.height, union=summary["test_rows_with_any_match"],
|
| near98=summary["tiers"]["near_sequence_98"],
|
| chrom_inter=len(inter))
|
| return summary
|
|
|
|
|
| MATCH_SCHEMA = {
|
| "task": pl.String, "tier": pl.String, "test_uid": pl.String, "train_uid": pl.String,
|
| "test_name": pl.String, "train_name": pl.String,
|
| "test_label": pl.Int64, "train_label": pl.Int64,
|
| "identity": pl.Float64, "q_cov": pl.Float64, "r_cov": pl.Float64,
|
| "orientation": pl.String, "overlap_bp": pl.Int64,
|
| "frac_test": pl.Float64, "frac_train": pl.Float64,
|
| "chrom": pl.String, "note": pl.String,
|
| }
|
|
|
|
|
| def _m(task, tier, test, train, identity=None, q_cov=None, r_cov=None,
|
| orientation=None, overlap_bp=None, frac_test=None, frac_train=None,
|
| chrom=None, note=None):
|
| return {
|
| "task": task, "tier": tier,
|
| "test_uid": test["uid"], "train_uid": train["uid"],
|
| "test_name": test["name"], "train_name": train["name"],
|
| "test_label": test["label"], "train_label": train["label"],
|
| "identity": identity, "q_cov": q_cov, "r_cov": r_cov,
|
| "orientation": orientation, "overlap_bp": overlap_bp,
|
| "frac_test": frac_test, "frac_train": frac_train,
|
| "chrom": chrom, "note": note,
|
| }
|
|
|
|
|
| def main() -> int:
|
| ap = argparse.ArgumentParser()
|
| ap.add_argument("--task", required=True)
|
| ap.add_argument("--work", default="/workspace/nt-audit")
|
| ap.add_argument("--pkg", default="/workspace/nt-revised-audit")
|
| args = ap.parse_args()
|
| log = StageLog(Path(args.pkg) / "logs" / "stage.jsonl", f"match:{args.task}")
|
| s = match_task(args.task, Path(args.work), Path(args.pkg), log)
|
| log.done(test_rows=s["test_rows"])
|
| return 0
|
|
|
|
|
| if __name__ == "__main__":
|
| raise SystemExit(main())
|
|
|
