Download scripts/evaluate.py from anonymous-quantinv/quantinvbench: direct link, hf CLI and curl.
- Browser
- Download file 4.46 kB
-
https://huggingface.co/datasets/anonymous-quantinv/quantinvbench/resolve/8f8fb44cee5cf380ea315fdeef2e2d2df4b99ace/scripts/evaluate.py
- Command line
-
hf download hf://datasets/anonymous-quantinv/quantinvbench@8f8fb44cee5cf380ea315fdeef2e2d2df4b99ace/scripts/evaluate.py
-
curl -L -o evaluate.py https://huggingface.co/datasets/anonymous-quantinv/quantinvbench/resolve/8f8fb44cee5cf380ea315fdeef2e2d2df4b99ace/scripts/evaluate.py
4.46 kB
| #!/usr/bin/env python3 | |
| """Evaluate QuantInvBench baselines or submitted portfolio weights.""" | |
| from __future__ import annotations | |
| import argparse | |
| import json | |
| from pathlib import Path | |
| import numpy as np | |
| from common import ASSETS, TRANSACTION_COST, read_jsonl, validated_weights | |
| def parse_args() -> argparse.Namespace: | |
| parser = argparse.ArgumentParser(description=__doc__) | |
| parser.add_argument("--data", type=Path, default=Path(__file__).resolve().parents[1] / "data" / "test.jsonl") | |
| group = parser.add_mutually_exclusive_group(required=True) | |
| group.add_argument("--baseline", choices=("equal_weight", "simple_avg")) | |
| group.add_argument("--predictions", type=Path, help="JSONL records with id and weights") | |
| parser.add_argument("--transaction-cost", type=float, default=TRANSACTION_COST) | |
| return parser.parse_args() | |
| def baseline_weights(record: dict, baseline: str) -> list[float]: | |
| if baseline == "equal_weight": | |
| return [1.0 / len(ASSETS)] * len(ASSETS) | |
| proposals = [proposal["weights"] for proposal in record["strategy_proposals"]] | |
| return validated_weights(np.mean(proposals, axis=0).tolist(), label="simple_avg") | |
| def load_predictions(path: Path) -> dict[str, list[float]]: | |
| predictions = {} | |
| for index, record in enumerate(read_jsonl(path)): | |
| if set(record) != {"id", "weights"}: | |
| raise ValueError(f"prediction {index}: expected only id and weights") | |
| identifier = record["id"] | |
| if not isinstance(identifier, str) or identifier in predictions: | |
| raise ValueError(f"prediction {index}: invalid or duplicate id") | |
| predictions[identifier] = validated_weights(record["weights"], label=identifier) | |
| return predictions | |
| def evaluate(records: list[dict], weights_by_id: dict[str, list[float]], transaction_cost: float) -> dict: | |
| if not 0 <= transaction_cost < 1: | |
| raise ValueError("transaction cost must be in [0, 1)") | |
| capital = 1.0 | |
| peak = capital | |
| maximum_drawdown = 0.0 | |
| previous_weights = np.full(len(ASSETS), 1.0 / len(ASSETS)) | |
| period_returns = [] | |
| turnovers = [] | |
| for record in records: | |
| identifier = record["id"] | |
| if identifier not in weights_by_id: | |
| raise ValueError(f"missing prediction for {identifier}") | |
| weights = np.asarray(weights_by_id[identifier], dtype=float) | |
| asset_returns = np.asarray(record["next_7d_returns"], dtype=float) | |
| turnover = float(np.abs(weights - previous_weights).sum() / 2.0) | |
| gross_return = float(weights @ asset_returns) | |
| net_growth = (1.0 - transaction_cost * turnover) * (1.0 + gross_return) | |
| if net_growth <= 0: | |
| raise ValueError(f"{identifier}: portfolio value became non-positive") | |
| net_return = net_growth - 1.0 | |
| capital *= net_growth | |
| peak = max(peak, capital) | |
| maximum_drawdown = max(maximum_drawdown, 1.0 - capital / peak) | |
| period_returns.append(net_return) | |
| turnovers.append(turnover) | |
| previous_weights = weights | |
| returns = np.asarray(period_returns, dtype=float) | |
| volatility = float(returns.std(ddof=1)) if len(returns) > 1 else 0.0 | |
| sharpe = float(returns.mean() / volatility * np.sqrt(52)) if volatility > 0 else 0.0 | |
| return { | |
| "samples": len(records), | |
| "cumulative_return": round(capital - 1.0, 10), | |
| "annualized_sharpe": round(sharpe, 10), | |
| "max_drawdown": round(maximum_drawdown, 10), | |
| "average_turnover": round(float(np.mean(turnovers)), 10), | |
| "transaction_cost": transaction_cost, | |
| } | |
| def main() -> None: | |
| args = parse_args() | |
| records = read_jsonl(args.data.resolve()) | |
| if not records: | |
| raise ValueError(f"empty dataset: {args.data}") | |
| if args.baseline: | |
| weights_by_id = { | |
| record["id"]: baseline_weights(record, args.baseline) | |
| for record in records | |
| } | |
| method = args.baseline | |
| else: | |
| weights_by_id = load_predictions(args.predictions.resolve()) | |
| expected_ids = {record["id"] for record in records} | |
| extra_ids = set(weights_by_id) - expected_ids | |
| if extra_ids: | |
| raise ValueError(f"predictions contain unknown ids: {sorted(extra_ids)[:3]}") | |
| method = str(args.predictions) | |
| metrics = evaluate(records, weights_by_id, args.transaction_cost) | |
| print(json.dumps({"method": method, **metrics}, indent=2, allow_nan=False)) | |
| if __name__ == "__main__": | |
| main() | |