| from __future__ import annotations |
|
|
| import argparse |
| from pathlib import Path |
| from typing import Any |
|
|
| from src.data.io_utils import read_jsonl, write_csv, write_jsonl |
| from src.data.normalize_text import normalize_whitespace |
|
|
|
|
| DATASET_SPECS: dict[str, dict[str, Any]] = { |
| "healthver": { |
| "protocol": "P6_pair_verification", |
| "id_field": "pair_id", |
| "splits": { |
| "train": "data_processed/healthver/pairs_train.jsonl", |
| "dev": "data_processed/healthver/pairs_dev.jsonl", |
| "test": "data_processed/healthver/pairs_test.jsonl", |
| }, |
| "candidate_template": "outputs/retrieval/healthver/candidate_pool_{split}.jsonl", |
| }, |
| "vifactcheck": { |
| "protocol": "P1_full_context_retrieval", |
| "id_field": "claim_id", |
| "splits": { |
| "train": "data_processed/vifactcheck/claims_train.jsonl", |
| "dev": "data_processed/vifactcheck/claims_dev.jsonl", |
| "test": "data_processed/vifactcheck/claims_test.jsonl", |
| }, |
| "candidate_template": "outputs/retrieval/vifactcheck/candidate_pool_{split}.jsonl", |
| }, |
| "averitec": { |
| "protocol": "P4_open_retrieval", |
| "id_field": "claim_id", |
| "qa_evidence": "data_processed/averitec/qa_evidence.jsonl", |
| "splits": { |
| "train_inner": "data_processed/averitec/claims_train_inner.jsonl", |
| "dev_inner": "data_processed/averitec/claims_dev_inner.jsonl", |
| "local_test": "data_processed/averitec/claims_local_test.jsonl", |
| }, |
| "candidate_template": "outputs/retrieval/averitec/candidate_pool_{split}.jsonl", |
| }, |
| } |
|
|
|
|
| def candidate_summary(candidate: dict[str, Any]) -> dict[str, Any]: |
| metadata = candidate.get("metadata") if isinstance(candidate.get("metadata"), dict) else {} |
| return { |
| "candidate_id": candidate.get("candidate_id"), |
| "text": candidate.get("text", ""), |
| "final_rank": candidate.get("final_rank"), |
| "reranker_score": candidate.get("reranker_score"), |
| "is_gold": candidate.get("is_gold"), |
| "source_type": candidate.get("source_type"), |
| "question": candidate.get("question") or metadata.get("question"), |
| "answer": candidate.get("answer") or metadata.get("answer"), |
| } |
|
|
|
|
| def select_evidence(dataset: str, candidates: list[dict[str, Any]], top_k: int) -> list[dict[str, Any]]: |
| selected = candidates[:top_k] |
| if dataset != "healthver": |
| return selected |
|
|
| anchors = [row for row in candidates if row.get("source_type") == "paired_evidence"] |
| if not anchors: |
| return selected |
| anchor = anchors[0] |
| selected_ids = {anchor.get("candidate_id")} |
| augmentations = [row for row in candidates if row.get("candidate_id") not in selected_ids] |
| return [anchor] + augmentations[: max(0, top_k - 1)] |
|
|
|
|
| def format_input_text(dataset: str, claim: str, evidence: list[dict[str, Any]], input_format: str = "flat") -> str: |
| claim = normalize_whitespace(claim) |
| if dataset == "vifactcheck": |
| parts = [f"[STATEMENT] {claim}"] |
| for idx, item in enumerate(evidence, start=1): |
| parts.append(f"[CONTEXT_CHUNK_{idx}] {normalize_whitespace(item.get('text', ''))}") |
| return "\n".join(parts) |
|
|
| if dataset == "healthver": |
| parts = [f"[CLAIM] {claim}"] |
| aug_idx = 1 |
| for item in evidence: |
| text = normalize_whitespace(item.get("text", "")) |
| if item.get("source_type") == "paired_evidence": |
| parts.append(f"[EVIDENCE] {text}") |
| else: |
| parts.append(f"[AUGMENTED_EVIDENCE_{aug_idx}] {text}") |
| aug_idx += 1 |
| return "\n".join(parts) |
|
|
| parts = [f"[CLAIM] {claim}"] |
| if dataset == "averitec" and input_format == "qa": |
| for idx, item in enumerate(evidence, start=1): |
| question = normalize_whitespace(item.get("question", "")) |
| answer = normalize_whitespace(item.get("answer", "")) |
| text = normalize_whitespace(item.get("text", "")) |
| if question: |
| parts.append(f"[QUESTION_{idx}] {question}") |
| if answer: |
| parts.append(f"[ANSWER_{idx}] {answer}") |
| parts.append(f"[EVIDENCE_{idx}] {text}") |
| return "\n".join(parts) |
|
|
| for idx, item in enumerate(evidence, start=1): |
| parts.append(f"[EVIDENCE_{idx}] {normalize_whitespace(item.get('text', ''))}") |
| return "\n".join(parts) |
|
|
|
|
| def load_candidate_rows(path: Path) -> dict[str, dict[str, Any]]: |
| rows: dict[str, dict[str, Any]] = {} |
| for row in read_jsonl(path): |
| rows[row["query_id"]] = row |
| return rows |
|
|
|
|
| def load_averitec_qa_by_evidence(path: Path) -> dict[str, dict[str, Any]]: |
| rows: dict[str, dict[str, Any]] = {} |
| if not path.exists(): |
| return rows |
| for row in read_jsonl(path): |
| metadata = row.get("metadata") if isinstance(row.get("metadata"), dict) else {} |
| evidence_id = metadata.get("evidence_id") |
| if evidence_id: |
| rows[str(evidence_id)] = row |
| return rows |
|
|
|
|
| def enrich_averitec_qa(candidates: list[dict[str, Any]], qa_by_evidence: dict[str, dict[str, Any]]) -> list[dict[str, Any]]: |
| if not qa_by_evidence: |
| return candidates |
| enriched: list[dict[str, Any]] = [] |
| for candidate in candidates: |
| updated = dict(candidate) |
| metadata = dict(updated.get("metadata") if isinstance(updated.get("metadata"), dict) else {}) |
| qa_row = qa_by_evidence.get(str(updated.get("candidate_id"))) |
| if qa_row: |
| updated["question"] = qa_row.get("question") |
| updated["answer"] = qa_row.get("answer") |
| metadata.setdefault("question_id", qa_row.get("question_id")) |
| metadata.setdefault("answer_type", (qa_row.get("metadata") or {}).get("answer_type")) |
| metadata.setdefault("source_url", qa_row.get("source_url")) |
| updated["metadata"] = metadata |
| enriched.append(updated) |
| return enriched |
|
|
|
|
| def build_dataset_split( |
| dataset: str, |
| split: str, |
| source_path: Path, |
| candidate_path: Path, |
| output_path: Path, |
| top_k: int, |
| protocol: str, |
| id_field: str, |
| input_format: str, |
| qa_by_evidence: dict[str, dict[str, Any]] | None = None, |
| ) -> dict[str, Any]: |
| source_rows = read_jsonl(source_path) |
| candidates_by_id = load_candidate_rows(candidate_path) |
| output_rows: list[dict[str, Any]] = [] |
| missing_candidates = 0 |
| missing_labels = 0 |
| anchor_missing = 0 |
|
|
| for row in source_rows: |
| query_id = row.get(id_field) or row.get("claim_id") |
| label = row.get("label") |
| if label is None: |
| missing_labels += 1 |
| continue |
| candidate_row = candidates_by_id.get(query_id) |
| if candidate_row is None: |
| missing_candidates += 1 |
| continue |
|
|
| evidence = select_evidence(dataset, candidate_row.get("candidates", []), top_k=top_k) |
| if dataset == "averitec" and input_format == "qa": |
| evidence = enrich_averitec_qa(evidence, qa_by_evidence or {}) |
| if dataset == "healthver" and not any(item.get("source_type") == "paired_evidence" for item in evidence): |
| anchor_missing += 1 |
| evidence_summaries = [candidate_summary(item) for item in evidence] |
| output_rows.append( |
| { |
| "id": query_id, |
| "dataset": dataset, |
| "split": split, |
| "claim": row.get("claim", ""), |
| "label": label, |
| "input_text": format_input_text(dataset, row.get("claim", ""), evidence, input_format=input_format), |
| "evidence": evidence_summaries, |
| "protocol": protocol, |
| "top_k": top_k, |
| "input_format": input_format, |
| } |
| ) |
|
|
| write_jsonl(output_path, output_rows) |
| return { |
| "dataset": dataset, |
| "split": split, |
| "top_k": top_k, |
| "input_format": input_format, |
| "source_rows": len(source_rows), |
| "output_rows": len(output_rows), |
| "missing_labels": missing_labels, |
| "missing_candidates": missing_candidates, |
| "healthver_anchor_missing": anchor_missing, |
| "output": str(output_path), |
| } |
|
|
|
|
| def build_dataset(dataset: str, top_k: int, output_root: Path, input_format: str) -> list[dict[str, Any]]: |
| spec = DATASET_SPECS[dataset] |
| rows: list[dict[str, Any]] = [] |
| dataset_dir = output_root / dataset |
| qa_by_evidence: dict[str, dict[str, Any]] = {} |
| if dataset == "averitec" and input_format == "qa": |
| qa_by_evidence = load_averitec_qa_by_evidence(Path(spec["qa_evidence"])) |
| for split, source in spec["splits"].items(): |
| source_path = Path(source) |
| candidate_path = Path(spec["candidate_template"].format(split=split)) |
| format_suffix = "_qa" if input_format == "qa" else "" |
| output_path = dataset_dir / f"{split}_top{top_k}{format_suffix}.jsonl" |
| rows.append( |
| build_dataset_split( |
| dataset=dataset, |
| split=split, |
| source_path=source_path, |
| candidate_path=candidate_path, |
| output_path=output_path, |
| top_k=top_k, |
| protocol=spec["protocol"], |
| id_field=spec["id_field"], |
| input_format=input_format, |
| qa_by_evidence=qa_by_evidence, |
| ) |
| ) |
| return rows |
|
|
|
|
| def main() -> None: |
| parser = argparse.ArgumentParser() |
| parser.add_argument("--datasets", nargs="*", choices=sorted(DATASET_SPECS), default=sorted(DATASET_SPECS)) |
| parser.add_argument("--top-k", type=int, action="append", required=True) |
| parser.add_argument("--format", choices=["flat", "qa"], default="flat") |
| parser.add_argument("--output-root", type=Path, default=Path("outputs/verifier_inputs")) |
| parser.add_argument("--summary-output", type=Path, default=Path("outputs/stats/verifier_input_summary.csv")) |
| args = parser.parse_args() |
|
|
| summary_rows: list[dict[str, Any]] = [] |
| for top_k in args.top_k: |
| for dataset in args.datasets: |
| summary_rows.extend( |
| build_dataset(dataset, top_k=top_k, output_root=args.output_root, input_format=args.format) |
| ) |
|
|
| write_csv(args.summary_output, summary_rows) |
| print(f"Wrote {len(summary_rows)} verifier input split summaries to {args.summary_output}") |
|
|
|
|
| if __name__ == "__main__": |
| main() |
|
|
