| |
| """Independent source/algebra auditor. Does not import build.py or its oracle.""" |
| import argparse |
| import collections |
| from decimal import Decimal, ROUND_HALF_UP |
| import hashlib |
| import json |
| import pathlib |
|
|
| EXPECTED = { |
| "SP.POP.TOTL": ("persons", "quantity"), |
| "NY.GDP.MKTP.CD": ("current_USD", "quantity"), |
| "NY.GDP.PCAP.CD": ("current_USD_per_person", "quantity"), |
| "NY.GDP.MKTP.KD.ZG": ("percent_annual_GDP_growth", "rate"), |
| "SP.DYN.LE00.IN": ("years", "quantity"), |
| "EG.ELC.ACCS.ZS": ("percent_population_electricity", "rate"), |
| "FP.CPI.TOTL.ZG": ("percent_annual_CPI_inflation", "rate"), |
| "SP.URB.TOTL.IN.ZS": ("percent_population_urban", "rate"), |
| } |
|
|
|
|
| def normalized_decimal(value, round_derived=False): |
| value = Decimal(value) |
| if round_derived: |
| value = value.quantize(Decimal("0.000001"), rounding=ROUND_HALF_UP) |
| if value.is_zero(): |
| return "0" |
| text = format(value, "f") |
| return text.rstrip("0").rstrip(".") if "." in text else text |
|
|
|
|
| def evaluate(operator, rows): |
| """A separate algebra implementation over model-visible rows only.""" |
| assert rows and len({r["cell_id"] for r in rows}) == len(rows), "empty/repeated evidence cells" |
| if operator == "incompatible_sum": |
| assert len(rows) == 2 and rows[0]["unit_code"] != rows[1]["unit_code"], "compatible sum mislabeled" |
| return dict(status="incompatible_units", value=None, unit=None) |
| unit = rows[0]["unit_code"] |
| if operator == "lookup": |
| assert len(rows) == 1 |
| return dict(status="missing" if rows[0]["value"] is None else "ok", value=rows[0]["value"], unit=unit) |
| assert all(r["value"] is not None for r in rows), "non-lookup task uses missing source value" |
| amounts = [Decimal(r["value"]) for r in rows] |
| if operator == "gdp_per_capita_join": |
| assert len(rows) == 2 |
| assert rows[0]["indicator_code"] == "NY.GDP.MKTP.CD" and rows[1]["indicator_code"] == "SP.POP.TOTL" |
| assert rows[0]["year"] == rows[1]["year"] and rows[0]["economy_code"] == rows[1]["economy_code"] |
| assert amounts[1] > 0 |
| return dict(status="ok", value=normalized_decimal(amounts[0] / amounts[1], True), unit="current_USD_per_person_calculated") |
| assert len({r["indicator_code"] for r in rows}) == 1, "unrelated indicators compared" |
| if operator in ("maximum_years", "minimum_years", "second_highest_years"): |
| assert len({r["economy_code"] for r in rows}) == 1 |
| assert len({r["year"] for r in rows}) == len(rows) |
| distinct = sorted(set(amounts)) |
| if operator == "minimum_years": |
| chosen = distinct[0] |
| elif operator == "maximum_years": |
| chosen = distinct[-1] |
| else: |
| assert len(distinct) >= 2 |
| chosen = distinct[-2] |
| years = sorted(row["year"] for row, value in zip(rows, amounts) if value == chosen) |
| return dict(status="ok", value=years, unit="year") |
| assert len(rows) == 2 and rows[0]["unit_code"] == rows[1]["unit_code"] |
| if operator == "greater_than": |
| assert rows[0]["economy_code"] == rows[1]["economy_code"] or rows[0]["year"] == rows[1]["year"] |
| return dict(status="ok", value=amounts[0] > amounts[1], unit="boolean") |
| assert rows[0]["economy_code"] == rows[1]["economy_code"] |
| assert int(rows[0]["year"]) < int(rows[1]["year"]) |
| if operator == "difference": |
| assert rows[0]["measure_kind"] == "quantity" |
| result, output_unit = amounts[1] - amounts[0], unit |
| elif operator == "percentage_point_difference": |
| assert rows[0]["measure_kind"] == "rate" |
| result, output_unit = amounts[1] - amounts[0], "percentage_points" |
| elif operator == "relative_change": |
| assert rows[0]["measure_kind"] == "quantity" and amounts[0] > 0 |
| result, output_unit = Decimal(100) * (amounts[1] / amounts[0] - Decimal(1)), "percent_change" |
| else: |
| raise AssertionError("Unknown operator: " + operator) |
| return dict(status="ok", value=normalized_decimal(result, True), unit=output_unit) |
|
|
|
|
| def read_lines(path): |
| return [json.loads(line) for line in path.read_text().splitlines() if line] |
|
|
|
|
| def audit(release, raw=None): |
| release = pathlib.Path(release) |
| raw = pathlib.Path(raw) if raw else release / "raw" |
| manifest = json.loads((raw / "manifest.json").read_text()) |
| assert set(manifest["series"]) == set(EXPECTED) |
| for entry in manifest["files"]: |
| assert hashlib.sha256((raw / entry["file"]).read_bytes()).hexdigest() == entry["sha256"], "raw digest mismatch" |
| source = {} |
| for code in EXPECTED: |
| meta = json.loads((raw / f"{code}.metadata.json").read_text()) |
| fields = {m["id"]: m["value"] for m in meta["source"][0]["concept"][0]["variable"][0]["metatype"]} |
| assert fields["License_Type"] == "CC BY-4.0" and fields["License_URL"] == "https://datacatalog.worldbank.org/public-licenses#cc-by" |
| assert fields["Source"] and fields["Unitofmeasure"] |
| path = raw / f"{code}.observations.json" |
| snapshot_sha = hashlib.sha256(path.read_bytes()).hexdigest() |
| header, rows = json.loads(path.read_text(), parse_float=Decimal) |
| assert str(header["sourceid"]) == "2" and header["pages"] == 1 and header["total"] == len(rows) |
| assert len(rows) == 550 |
| for row in rows: |
| source[(row["countryiso3code"], code, row["date"])] = (row, snapshot_sha) |
| observation_rows, questions, tables = [], [], [] |
| for split in ("train", "validation", "test"): |
| for config, target in [("observations", observation_rows), ("questions", questions), ("tables", tables)]: |
| rows = read_lines(release / "jsonl" / config / f"{split}.jsonl") |
| assert all(row["split"] == split for row in rows) |
| target.extend(rows) |
| import pyarrow.parquet as pq |
| loaded = pq.read_table(release / "data" / config / f"{split}-00000-of-00001.parquet").to_pylist() |
| assert loaded == rows, "Parquet differs from corresponding JSONL" |
| assert len(observation_rows) == len(source) == 4400 |
| assert len({x["cell_id"] for x in observation_rows}) == len(observation_rows) |
| observed = {x["cell_id"]: x for x in observation_rows} |
| economy_splits = collections.defaultdict(set) |
| source_keys = set() |
| for row in observation_rows: |
| key = (row["economy_code"], row["indicator_code"], row["year"]) |
| assert key not in source_keys |
| source_keys.add(key) |
| upstream, sha = source[key] |
| expected_value = None if upstream["value"] is None else normalized_decimal(upstream["value"]) |
| assert row["value"] == expected_value and row["source_snapshot_sha256"] == sha |
| expected_id = "c_" + hashlib.sha256(json.dumps(["2", key[1], key[0], key[2], sha], ensure_ascii=False, sort_keys=True, separators=(",", ":")).encode()).hexdigest()[:24] |
| assert row["cell_id"] == expected_id |
| assert row["economy_ar"] == upstream["country"]["value"] and row["source_obs_status"] == upstream["obs_status"] |
| assert (row["unit_code"], row["measure_kind"]) == EXPECTED[row["indicator_code"]] |
| economy_splits[row["economy_code"]].add(row["split"]) |
| assert all(len(value) == 1 for value in economy_splits.values()), "economy crosses splits" |
| table_map = {row["table_id"]: row for row in tables} |
| assert len(table_map) == len(tables) |
| assert len({q["id"] for q in questions}) == len(questions) |
| fingerprints, family_splits, used_cells = set(), collections.defaultdict(set), collections.defaultdict(set) |
| visible_keys = {"cell_id", "economy_code", "economy_ar", "indicator_code", "indicator_ar", "year", "value", "unit_code", "unit_ar", "measure_kind"} |
| operations = collections.Counter() |
| for q in questions: |
| assert "gold" not in q["context"] and "program" not in q["context"] |
| context = json.loads(q["context"]) |
| assert set(context) == {"caption_ar", "source", "cells"} |
| table = table_map[q["table_id"]] |
| assert table["context"] == q["context"] and table["split"] == q["split"] |
| for cell in context["cells"]: |
| assert set(cell) == visible_keys |
| assert cell == {key: observed[cell["cell_id"]][key] for key in visible_keys}, "context differs from source observation" |
| assert observed[cell["cell_id"]]["split"] == q["split"], "source cell crosses task splits" |
| used_cells[cell["cell_id"]].add(q["split"]) |
| program = json.loads(q["program"]) |
| assert program["operator"] == q["operation"] |
| assert program["derived_decimal_places"] == 6 and program["rounding"] == "ROUND_HALF_UP" |
| assert program["cells"] == [r["cell_id"] for r in context["cells"]] == q["gold_evidence_ids"] |
| answer = evaluate(q["operation"], context["cells"]) |
| assert json.loads(q["gold_answer"]) == answer, "independent answer mismatch: " + q["id"] |
| if q["structure_holdout_diagnostic"]: |
| assert q["split"] == "test" and q["operation"] == "second_highest_years" |
| if q["operation"] == "second_highest_years": |
| assert q["structure_holdout_diagnostic"] |
| fingerprint = (q["context"], q["question_ar"]) |
| assert fingerprint not in fingerprints, "duplicate input" |
| fingerprints.add(fingerprint) |
| family_splits[q["family_id"]].add(q["split"]) |
| operations[q["operation"]] += 1 |
| from model_input import model_input |
| allowed_input = model_input(q) |
| assert set(allowed_input) == {"question_ar", "table"} and allowed_input["table"] == context |
| assert all(len(x) == 1 for x in used_cells.values()) and all(len(x) == 1 for x in family_splits.values()) |
| return {"passed": True, "source_observations": len(source), "questions": len(questions), "tables": len(tables), |
| "source_cells_used_in_questions": len(used_cells), "source_cell_split_overlap": 0, |
| "economy_split_overlap": 0, "exact_duplicate_inputs": 0, "independent_answer_mismatches": 0, |
| "parquet_jsonl_equal": True, "operations": dict(operations), |
| "scope": "Software and source-contract verification only; no human linguistic/statistical review or learned-model accuracy claim."} |
|
|
|
|
| def main(): |
| parser = argparse.ArgumentParser() |
| parser.add_argument("--release", type=pathlib.Path, required=True) |
| parser.add_argument("--raw", type=pathlib.Path) |
| parser.add_argument("--output", type=pathlib.Path) |
| args = parser.parse_args() |
| report = audit(args.release, args.raw) |
| if args.output: |
| args.output.parent.mkdir(parents=True, exist_ok=True) |
| args.output.write_text(json.dumps(report, indent=2) + "\n") |
| print(json.dumps(report, indent=2)) |
|
|
|
|
| if __name__ == "__main__": |
| main() |
|
|
