quantinvbench / scripts /validate.py
anonymous-quantinv's picture
Publish QuantInvBench dataset
bcc98e7 verified
Raw History Blame
14.1 kB
#!/usr/bin/env python3
"""Strict validation for a generated QuantInvBench release."""
from __future__ import annotations
import argparse
import json
import math
import re
import sys
from datetime import datetime, timedelta
from pathlib import Path
import pandas as pd
from common import (
ASSETS,
ATTACK_PROTOCOL_VERSION,
BENCHMARK_VERSION,
EVALUATION_PROTOCOL,
EXPECTED_SPLIT_COUNTS,
EXPECTED_SPLIT_RANGES,
REBALANCE_DAYS,
STRATEGIES,
TRANSACTION_COST,
WEIGHT_TOLERANCE,
read_jsonl,
sha256_file,
)
ID_PATTERN = re.compile(r"^quantinv_(train|validation|test)_\d{4}_\d{8}$")
REQUIRED_FIELDS = {
"id",
"split",
"as_of",
"execution_at",
"label_end_at",
"assets",
"strategy_proposals",
"next_7d_daily_returns",
"next_7d_returns",
}
class Validation:
def __init__(self) -> None:
self.checks = 0
self.errors: list[str] = []
def check(self, condition: bool, message: str) -> None:
self.checks += 1
if not condition:
self.errors.append(message)
def parse_timestamp(value: object, label: str) -> datetime:
if not isinstance(value, str):
raise ValueError(f"{label}: timestamp must be a string")
parsed = datetime.fromisoformat(value.replace("Z", "+00:00"))
if parsed.tzinfo is None:
raise ValueError(f"{label}: timestamp must include a timezone")
return parsed
def validate_weights(values: object, label: str, result: Validation) -> None:
result.check(isinstance(values, list), f"{label}: weights must be a list")
if not isinstance(values, list):
return
result.check(len(values) == len(ASSETS), f"{label}: expected five weights")
if len(values) != len(ASSETS):
return
numeric = all(isinstance(value, (int, float)) and not isinstance(value, bool) for value in values)
result.check(numeric, f"{label}: weights must be numeric")
if not numeric:
return
finite = all(math.isfinite(float(value)) for value in values)
result.check(finite, f"{label}: weights contain NaN or Infinity")
if not finite:
return
result.check(all(value >= 0 for value in values), f"{label}: weights must be non-negative")
result.check(
abs(sum(values) - 1.0) <= WEIGHT_TOLERANCE,
f"{label}: weights sum to {sum(values)}, not 1",
)
def validate_record(
record: dict,
split: str,
index: int,
result: Validation,
) -> tuple[datetime | None, datetime | None]:
label = f"{split}[{index}]"
result.check(set(record) == REQUIRED_FIELDS, f"{label}: fields do not match schema")
result.check(record.get("split") == split, f"{label}: wrong split value")
identifier = record.get("id")
result.check(isinstance(identifier, str) and bool(ID_PATTERN.fullmatch(identifier)), f"{label}: invalid id")
result.check(record.get("assets") == list(ASSETS), f"{label}: asset roster/order changed")
try:
as_of = parse_timestamp(record.get("as_of"), f"{label}.as_of")
execution = parse_timestamp(record.get("execution_at"), f"{label}.execution_at")
label_end = parse_timestamp(record.get("label_end_at"), f"{label}.label_end_at")
result.check(as_of < execution, f"{label}: as_of must precede execution_at")
result.check(execution - as_of <= timedelta(seconds=1), f"{label}: unexpected decision gap")
result.check(
label_end - execution == timedelta(days=REBALANCE_DAYS),
f"{label}: label horizon is not seven days",
)
if isinstance(identifier, str):
expected_id = f"quantinv_{split}_{index:04d}_{execution:%Y%m%d}"
result.check(identifier == expected_id, f"{label}: id does not match split/index/date")
except (TypeError, ValueError) as exc:
result.check(False, str(exc))
execution = None
label_end = None
proposals = record.get("strategy_proposals")
result.check(isinstance(proposals, list), f"{label}: strategy_proposals must be a list")
if isinstance(proposals, list):
result.check(
len(proposals) == len(STRATEGIES),
f"{label}: expected {len(STRATEGIES)} strategies",
)
names = [proposal.get("strategy") for proposal in proposals if isinstance(proposal, dict)]
result.check(names == list(STRATEGIES), f"{label}: strategy roster/order changed")
for proposal_index, proposal in enumerate(proposals):
proposal_label = f"{label}.strategy_proposals[{proposal_index}]"
result.check(isinstance(proposal, dict), f"{proposal_label}: must be an object")
if isinstance(proposal, dict):
result.check(set(proposal) == {"strategy", "weights"}, f"{proposal_label}: invalid fields")
validate_weights(proposal.get("weights"), proposal_label, result)
returns = record.get("next_7d_returns")
result.check(isinstance(returns, list) and len(returns) == len(ASSETS), f"{label}: invalid returns")
endpoint_returns_valid = False
if isinstance(returns, list) and len(returns) == len(ASSETS):
endpoint_returns_valid = all(
isinstance(value, (int, float))
and not isinstance(value, bool)
and math.isfinite(float(value))
and float(value) > -1.0
for value in returns
)
result.check(endpoint_returns_valid, f"{label}: returns contain invalid values")
daily_returns = record.get("next_7d_daily_returns")
result.check(
isinstance(daily_returns, list) and len(daily_returns) == REBALANCE_DAYS,
f"{label}: next_7d_daily_returns must contain seven rows",
)
daily_returns_valid = False
if isinstance(daily_returns, list) and len(daily_returns) == REBALANCE_DAYS:
rows_valid = []
for day_index, row in enumerate(daily_returns):
row_valid = (
isinstance(row, list)
and len(row) == len(ASSETS)
and all(
isinstance(value, (int, float))
and not isinstance(value, bool)
and math.isfinite(float(value))
and float(value) > -1.0
for value in row
)
)
result.check(row_valid, f"{label}.next_7d_daily_returns[{day_index}]: invalid row")
rows_valid.append(row_valid)
daily_returns_valid = all(rows_valid)
if endpoint_returns_valid and daily_returns_valid:
for asset_index, asset in enumerate(ASSETS):
compounded = math.prod(
1.0 + float(daily_returns[day_index][asset_index])
for day_index in range(REBALANCE_DAYS)
) - 1.0
result.check(
abs(compounded - float(returns[asset_index])) <= 1e-8,
f"{label}: {asset} endpoint return does not compound from daily returns",
)
return execution, label_end
def main() -> int:
parser = argparse.ArgumentParser(description=__doc__)
parser.add_argument("data_dir", type=Path, nargs="?", default=Path(__file__).resolve().parents[1] / "data")
parser.add_argument(
"--source-data-dir",
type=Path,
help="Optional original hourly data directory for replaying next_7d_returns",
)
args = parser.parse_args()
data_dir = args.data_dir.resolve()
result = Validation()
manifest_path = data_dir / "manifest.json"
result.check(manifest_path.exists(), f"missing {manifest_path}")
manifest = {}
if manifest_path.exists():
try:
manifest = json.loads(manifest_path.read_text(encoding="utf-8"))
except (OSError, json.JSONDecodeError) as exc:
result.check(False, f"invalid manifest: {exc}")
result.check(manifest.get("dataset") == "QuantInvBench", "manifest: wrong dataset name")
result.check(manifest.get("version") == BENCHMARK_VERSION, f"manifest: expected benchmark version {BENCHMARK_VERSION}")
result.check(manifest.get("assets") == list(ASSETS), "manifest: asset roster/order changed")
result.check(manifest.get("strategies") == list(STRATEGIES), "manifest: strategy roster/order changed")
result.check(manifest.get("rebalance_days") == REBALANCE_DAYS, "manifest: wrong rebalance period")
result.check(manifest.get("label_horizon_days") == REBALANCE_DAYS, "manifest: wrong label horizon")
result.check(manifest.get("transaction_cost") == TRANSACTION_COST, "manifest: wrong transaction cost")
result.check(manifest.get("splits") == EXPECTED_SPLIT_COUNTS, "manifest: wrong fixed split counts")
result.check(manifest.get("split_ranges") == EXPECTED_SPLIT_RANGES, "manifest: wrong fixed split ranges")
result.check(manifest.get("evaluation_protocol") == EVALUATION_PROTOCOL, "manifest: wrong evaluation protocol")
result.check(manifest.get("attack_protocol") == ATTACK_PROTOCOL_VERSION, "manifest: wrong attack protocol")
seen_ids = set()
split_ranges = {}
all_records = []
for split in ("train", "validation", "test"):
path = data_dir / f"{split}.jsonl"
result.check(path.exists(), f"missing {path}")
if not path.exists():
continue
try:
records = read_jsonl(path)
except ValueError as exc:
result.check(False, str(exc))
continue
all_records.extend(records)
result.check(bool(records), f"{split}: split is empty")
periods = []
for index, record in enumerate(records):
result.check(isinstance(record, dict), f"{split}[{index}]: record must be an object")
if not isinstance(record, dict):
continue
execution, label_end = validate_record(record, split, index, result)
if execution is not None and label_end is not None:
periods.append((execution, label_end))
identifier = record.get("id")
result.check(identifier not in seen_ids, f"duplicate id: {identifier}")
seen_ids.add(identifier)
execution_times = [execution for execution, _ in periods]
result.check(execution_times == sorted(execution_times), f"{split}: records are not sorted")
for (left_execution, left_end), (right_execution, _) in zip(periods, periods[1:]):
result.check(
right_execution - left_execution == timedelta(days=REBALANCE_DAYS),
f"{split}: rebalance interval is not seven days",
)
result.check(
left_end == right_execution,
f"{split}: holding periods are not contiguous",
)
if periods:
split_ranges[split] = (periods[0][0], periods[-1][1])
expected_count = EXPECTED_SPLIT_COUNTS[split]
result.check(expected_count == len(records), f"{split}: manifest count does not match")
expected_hash = manifest.get("data_sha256", {}).get(path.name)
result.check(expected_hash == sha256_file(path), f"{split}: SHA-256 does not match manifest")
if periods:
expected_range = {
"execution_start": records[0]["execution_at"],
"execution_end": records[-1]["execution_at"],
"label_end": records[-1]["label_end_at"],
}
result.check(
manifest.get("split_ranges", {}).get(split) == expected_range,
f"{split}: manifest range does not match records",
)
ordered_ranges = [split_ranges.get(split) for split in ("train", "validation", "test")]
if all(ordered_ranges):
result.check(ordered_ranges[0][1] < ordered_ranges[1][0], "train labels overlap validation")
result.check(ordered_ranges[1][1] < ordered_ranges[2][0], "validation labels overlap test")
if args.source_data_dir:
from generate import load_daily_data, scalar_at
frames = load_daily_data(args.source_data_dir.resolve())
for record in all_records:
execution = parse_timestamp(record["execution_at"], record["id"])
execution_date = pd.Timestamp(execution)
exit_date = execution_date + pd.Timedelta(days=REBALANCE_DAYS)
label_end = parse_timestamp(record["label_end_at"], record["id"])
result.check(pd.Timestamp(label_end) == exit_date, f"{record['id']}: wrong label_end_at")
for asset_index, coin in enumerate(("bitcoin", "ethereum", "tether", "xrp", "bnb")):
entry = scalar_at(frames[coin], execution_date, "open")
exit_price = scalar_at(frames[coin], exit_date, "open")
expected = exit_price / entry - 1.0
actual = record["next_7d_returns"][asset_index]
result.check(
abs(expected - actual) <= 1e-9,
f"{record['id']}: {ASSETS[asset_index]} next_7d_returns does not match source",
)
for day_index in range(REBALANCE_DAYS):
day_start = execution_date + pd.Timedelta(days=day_index)
day_end = day_start + pd.Timedelta(days=1)
start_price = scalar_at(frames[coin], day_start, "open")
end_price = scalar_at(frames[coin], day_end, "open")
expected_daily = end_price / start_price - 1.0
actual_daily = record["next_7d_daily_returns"][day_index][asset_index]
result.check(
abs(expected_daily - actual_daily) <= 1e-9,
f"{record['id']}: {ASSETS[asset_index]} day {day_index} return does not match source",
)
if result.errors:
for error in result.errors:
print(f"[FAIL] {error}", file=sys.stderr)
print(f"Validation failed: {len(result.errors)} errors across {result.checks} checks", file=sys.stderr)
return 1
print(f"Validation passed: {result.checks} checks, {len(seen_ids)} records")
return 0
if __name__ == "__main__":
raise SystemExit(main())