| |
| """Measure answer-string coverage and question-query retrieval recall. |
| |
| These are noisy diagnostics, not answer accuracy: aliases and paraphrases can |
| be valid when the normalized gold string is absent, while common strings can |
| occur in irrelevant documents. |
| """ |
|
|
| from __future__ import annotations |
|
|
| import argparse |
| import json |
| import re |
| import unicodedata |
| from collections import Counter, defaultdict |
| from functools import lru_cache |
| from pathlib import Path |
| from typing import Any |
|
|
| try: |
| from .common import read_jsonl, write_jsonl |
| from .corpus_db import connect, fts_counts, fts_exists, search_docids |
| except ImportError: |
| from common import read_jsonl, write_jsonl |
| from corpus_db import connect, fts_counts, fts_exists, search_docids |
|
|
|
|
| def normalize_for_match(text: str) -> str: |
| decomposed = unicodedata.normalize("NFKD", text or "") |
| without_marks = "".join(character for character in decomposed if not unicodedata.combining(character)) |
| return re.sub(r"[^\w]+", " ", without_marks.casefold(), flags=re.UNICODE).strip() |
|
|
|
|
| def is_lexically_evaluable(answer: str) -> bool: |
| normalized = normalize_for_match(answer) |
| return normalized not in {"yes", "no", "true", "false"} and len(normalized.replace(" ", "")) >= 3 |
|
|
|
|
| def contains_answer(text: str, answer: str) -> bool: |
| needle = normalize_for_match(answer) |
| return bool(needle) and needle in normalize_for_match(text) |
|
|
|
|
| def provenance_documents(connection, qid: str) -> list[dict[str, Any]]: |
| return [ |
| dict(row) |
| for row in connection.execute( |
| """ |
| SELECT d.url_id AS docid, d.canonical_url AS url |
| FROM document_qids AS q JOIN documents AS d USING(url_id) |
| WHERE q.qid=? AND d.status='success' |
| """, |
| (qid,), |
| ) |
| ] |
|
|
|
|
| def failure_category(source: str, error: str) -> str: |
| value = f"{source} {error}".casefold() |
| if "robots.txt disallows" in value: |
| return "robots_disallowed" |
| if "robots.txt" in value: |
| return "robots_unavailable_or_invalid" |
| if "challenge" in value or "captcha" in value or "security verification" in value: |
| return "challenge_or_captcha" |
| status = re.search(r"http\s+([45]\d\d)", value) |
| if status: |
| return f"http_{status.group(1)}" |
| if "timeout" in value: |
| return "timeout" |
| if "too large" in value or "exceeded byte limit" in value: |
| return "response_too_large" |
| if "unsupported content" in value or "non-text content" in value: |
| return "unsupported_or_non_text" |
| if "pdf" in value: |
| return "pdf_extraction" |
| if "extracted only" in value: |
| return "too_little_text" |
| if "connect" in value or "name or service not known" in value: |
| return "connection_or_dns" |
| return "other" |
|
|
|
|
| def corpus_statistics(connection) -> dict[str, Any]: |
| status = dict(connection.execute("SELECT status, count(*) FROM documents GROUP BY status").fetchall()) |
| sources = dict( |
| connection.execute( |
| "SELECT source, count(*) FROM documents WHERE status='success' GROUP BY source ORDER BY count(*) DESC" |
| ).fetchall() |
| ) |
| content_types = dict( |
| connection.execute( |
| """ |
| SELECT content_type, count(*) |
| FROM documents |
| WHERE status='success' |
| GROUP BY content_type |
| ORDER BY count(*) DESC |
| LIMIT 20 |
| """ |
| ).fetchall() |
| ) |
| text = connection.execute( |
| """ |
| SELECT count(*) AS documents, coalesce(sum(length(text)), 0) AS characters, |
| count(DISTINCT content_hash) AS unique_hashes |
| FROM documents WHERE status='success' |
| """ |
| ).fetchone() |
| failure_categories: Counter[str] = Counter() |
| failure_details = [] |
| for row in connection.execute( |
| """ |
| SELECT source, error, count(*) AS count |
| FROM documents WHERE status='failed' |
| GROUP BY source, error |
| ORDER BY count(*) DESC |
| """ |
| ): |
| failure_categories[failure_category(row["source"], row["error"])] += row["count"] |
| if len(failure_details) < 30: |
| failure_details.append(dict(row)) |
| index_counts = None |
| if fts_exists(connection): |
| index_counts = fts_counts(connection) |
| return { |
| "status": status, |
| "successful_sources": sources, |
| "successful_content_types_top_20": content_types, |
| "successful_text_characters": int(text["characters"]), |
| "successful_unique_content_hashes": int(text["unique_hashes"]), |
| "exact_duplicate_successes_excluded_from_fts": int(text["documents"] - text["unique_hashes"]), |
| "fts_documents": index_counts["documents"] if index_counts else None, |
| "fts_chunks": index_counts["chunks"] if index_counts else None, |
| "failure_categories": dict(failure_categories.most_common()), |
| "top_failure_details": failure_details, |
| } |
|
|
|
|
| def audit( |
| database: Path, |
| data_paths: list[Path], |
| *, |
| k: int, |
| limit: int = 0, |
| only_with_fetched_provenance: bool = False, |
| ) -> tuple[dict, list[dict]]: |
| samples = [record for path in data_paths for record in read_jsonl(path)] |
| connection = connect(database, readonly=True) |
|
|
| @lru_cache(maxsize=32768) |
| def normalized_document(docid: str) -> str: |
| row = connection.execute( |
| "SELECT text FROM documents WHERE url_id=? AND status='success'", |
| (docid,), |
| ).fetchone() |
| return normalize_for_match(row["text"]) if row else "" |
|
|
| provenance_by_qid: defaultdict[str, list[dict[str, Any]]] = defaultdict(list) |
| provenance_status_by_qid: defaultdict[str, Counter[str]] = defaultdict(Counter) |
| for row in connection.execute( |
| """ |
| SELECT q.qid, d.url_id AS docid, d.canonical_url AS url, d.status |
| FROM document_qids AS q JOIN documents AS d USING(url_id) |
| """ |
| ): |
| provenance_status_by_qid[row["qid"]][row["status"]] += 1 |
| if row["status"] == "success": |
| provenance_by_qid[row["qid"]].append({"docid": row["docid"], "url": row["url"]}) |
|
|
| input_samples = len(samples) |
| if only_with_fetched_provenance: |
| fetched_qids = set(provenance_by_qid) |
| samples = [ |
| sample |
| for sample in samples |
| if (sample["metadata"].get("manifest_qid") or sample["metadata"]["qid"]) in fetched_qids |
| ] |
| if limit: |
| samples = samples[:limit] |
| results: list[dict[str, Any]] = [] |
| aggregate: Counter[str] = Counter() |
| by_difficulty: defaultdict[str, Counter[str]] = defaultdict(Counter) |
|
|
| for sample in samples: |
| metadata = sample["metadata"] |
| qid = metadata.get("manifest_qid") or metadata["qid"] |
| question = metadata["question"] |
| answer = metadata.get("answer") or sample.get("label", "") |
| evaluable = is_lexically_evaluable(answer) |
| normalized_answer = normalize_for_match(answer) |
| provenance = provenance_by_qid[qid] |
| provenance_status = provenance_status_by_qid[qid] |
| provenance_hit = evaluable and any( |
| normalized_answer in normalized_document(document["docid"]) for document in provenance |
| ) |
| try: |
| retrieved_docids = search_docids(connection, question, k) |
| except ValueError: |
| retrieved_docids = [] |
| retrieval_hit = evaluable and any( |
| normalized_answer in normalized_document(docid) for docid in retrieved_docids |
| ) |
| result = { |
| "qid": metadata["qid"], |
| "manifest_qid": qid, |
| "difficulty": int(metadata["difficulty"]), |
| "lexically_evaluable": evaluable, |
| "manifest_provenance_documents": sum(provenance_status.values()), |
| "fetched_provenance_documents": len(provenance), |
| "failed_provenance_documents": provenance_status["failed"], |
| "pending_provenance_documents": provenance_status["pending"], |
| "answer_in_fetched_provenance": bool(provenance_hit), |
| f"answer_in_question_search_top_{k}": bool(retrieval_hit), |
| "retrieved_documents": len(retrieved_docids), |
| } |
| results.append(result) |
| counters = (aggregate, by_difficulty[str(metadata["difficulty"])]) |
| for counter in counters: |
| counter["questions"] += 1 |
| counter["lexically_evaluable"] += evaluable |
| counter["has_manifest_provenance"] += bool(provenance_status) |
| counter["has_fetched_provenance"] += bool(provenance) |
| counter["answer_in_fetched_provenance"] += provenance_hit |
| counter[f"answer_in_question_search_top_{k}"] += retrieval_hit |
|
|
| def summarize(counter: Counter[str]) -> dict[str, Any]: |
| evaluable = counter["lexically_evaluable"] |
| return { |
| **dict(counter), |
| "provenance_answer_coverage": counter["answer_in_fetched_provenance"] / evaluable if evaluable else None, |
| f"question_search_recall_at_{k}": counter[f"answer_in_question_search_top_{k}"] / evaluable |
| if evaluable |
| else None, |
| } |
|
|
| summary = { |
| "database": str(database), |
| "top_k": k, |
| "input_questions": input_samples, |
| "selected_questions": len(samples), |
| "only_with_fetched_provenance": only_with_fetched_provenance, |
| "corpus": corpus_statistics(connection), |
| "normalized_document_cache": { |
| "hits": normalized_document.cache_info().hits, |
| "misses": normalized_document.cache_info().misses, |
| "maxsize": normalized_document.cache_info().maxsize, |
| "currsize": normalized_document.cache_info().currsize, |
| }, |
| "overall": summarize(aggregate), |
| "by_difficulty": {difficulty: summarize(counter) for difficulty, counter in sorted(by_difficulty.items())}, |
| "interpretation": ( |
| "Normalized answer-string matching is a noisy proxy, not a lower or upper bound. " |
| "It excludes yes/no answers and misses aliases or paraphrases, while common answers can occur incidentally. " |
| "Provenance coverage asks whether a fetched teacher-visited page contains the answer; retrieval recall asks whether " |
| "the original question retrieves a document containing the answer string. When only_with_fetched_provenance is " |
| "true, the report " |
| "is a fetch/search smoke test and is selection-biased, not a corpus-wide coverage estimate." |
| ), |
| } |
| connection.close() |
| return summary, results |
|
|
|
|
| def main() -> None: |
| parser = argparse.ArgumentParser(description=__doc__) |
| parser.add_argument("--database", type=Path, required=True) |
| parser.add_argument("--data", type=Path, nargs="+", required=True, help="prepared train/test JSONL") |
| parser.add_argument("--top-k", type=int, default=20) |
| parser.add_argument("--limit", type=int, default=0) |
| parser.add_argument( |
| "--only-with-fetched-provenance", |
| action="store_true", |
| help="biased smoke mode: audit only qids having at least one successfully fetched visited page", |
| ) |
| parser.add_argument("--output-dir", type=Path, required=True) |
| args = parser.parse_args() |
| if args.top_k < 1 or args.limit < 0: |
| parser.error("--top-k must be >= 1 and --limit must be non-negative") |
| summary, per_question = audit( |
| args.database, |
| args.data, |
| k=args.top_k, |
| limit=args.limit, |
| only_with_fetched_provenance=args.only_with_fetched_provenance, |
| ) |
| args.output_dir.mkdir(parents=True, exist_ok=True) |
| (args.output_dir / "summary.json").write_text( |
| json.dumps(summary, indent=2, sort_keys=True) + "\n", encoding="utf-8" |
| ) |
| write_jsonl(args.output_dir / "per_question.jsonl", per_question) |
| print(json.dumps(summary, indent=2, sort_keys=True)) |
|
|
|
|
| if __name__ == "__main__": |
| main() |
|
|
