Datasets:
File size: 7,806 Bytes
4bd5225 | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 | from __future__ import annotations
from copy import deepcopy
from dataclasses import asdict
import json
from pathlib import Path
from typing import Any
import numpy as np
import pandas as pd
from tqdm import tqdm
from .actions import decode_continuous_action, decode_discrete_action
from .agent.llm_client import make_llm_client
from .agent.wrappers import AgenticConfig, agentic_metrics, make_agentic_processor
from .config import BenchmarkConfig
from .data import load_benchmark_data
from .env import SolarChainBenchmarkEnv
from .metrics import summarize_episode
from .policies import Policy
def run_episode(
policy: Policy,
config: BenchmarkConfig,
seed: int,
episode: int,
policy_name: str | None = None,
) -> tuple[dict[str, Any], list[dict[str, Any]]]:
metrics, steps, _ = _run_episode_impl(policy, config, seed, episode, policy_name)
return metrics, steps
def _run_episode_impl(
policy: Policy,
config: BenchmarkConfig,
seed: int,
episode: int,
policy_name: str | None = None,
agentic_config: AgenticConfig | None = None,
llm_client: Any | None = None,
) -> tuple[dict[str, Any], list[dict[str, Any]], list[dict[str, Any]]]:
local_config = deepcopy(config)
name = policy_name or getattr(policy, "name", "policy")
local_config.action_mode = "discrete" if name == "dqn" else "continuous"
if hasattr(policy, "config"):
policy.config = local_config
env_config = deepcopy(local_config)
agentic_enabled = bool(agentic_config and agentic_config.agentic_mode != "none")
if agentic_enabled:
env_config.action_mode = "continuous"
data = load_benchmark_data(env_config.data_dir)
env = SolarChainBenchmarkEnv(config=env_config, data=data)
obs, _ = env.reset(seed=seed)
processor = None
if agentic_enabled:
needs_llm = agentic_config.planner == "llm" or agentic_config.auditor == "llm"
processor = make_agentic_processor(
config=env_config,
agentic_config=agentic_config,
llm_client=(llm_client or make_llm_client()) if needs_llm else None,
)
processor.reset(env)
done = False
step_rows: list[dict[str, Any]] = []
agentic_logs: list[dict[str, Any]] = []
while not done:
action, _ = policy.predict(obs, deterministic=True)
agentic_info: dict[str, Any] = {}
if processor is not None:
proposed_actual = _decode_policy_action(action, local_config)
previous_action = np.asarray(env._prev_action, dtype=np.float32)
action, agentic_info, log_row = processor.process(
obs=obs,
proposed_actual_action=proposed_actual,
previous_action=previous_action,
latest_info=env.latest_info(),
)
log_row.update({"policy": name, "episode": episode, "step": len(step_rows)})
agentic_logs.append(log_row)
obs, reward, terminated, truncated, info = env.step(action)
info.update(agentic_info)
row = {
"policy": name,
"episode": episode,
"step": len(step_rows),
"reward": float(reward),
**{key: value for key, value in info.items() if key != "city_rewards"},
"city_rewards": info.get("city_rewards", {}),
}
step_rows.append(row)
done = terminated or truncated
metrics = summarize_episode(step_rows)
metrics.update({"policy": name, "episode": episode, "seed": seed})
if processor is not None:
metrics.update(agentic_metrics(processor.stats, len(step_rows)))
return metrics, step_rows, agentic_logs
def evaluate_policies(
policies: list[Policy],
config: BenchmarkConfig,
episodes: int,
output_dir: str | Path,
agentic_config: AgenticConfig | None = None,
llm_client: Any | None = None,
show_progress: bool = False,
) -> tuple[pd.DataFrame, pd.DataFrame, pd.DataFrame]:
output = Path(output_dir)
output.mkdir(parents=True, exist_ok=True)
metric_rows: list[dict[str, Any]] = []
action_rows: list[dict[str, Any]] = []
city_hour_rows: list[dict[str, Any]] = []
agentic_log_rows: list[dict[str, Any]] = []
total_episodes = len(policies) * episodes
progress = tqdm(
total=total_episodes,
desc="Evaluating policies",
unit="episode",
disable=not show_progress,
dynamic_ncols=True,
)
try:
for policy in policies:
name = getattr(policy, "name", "policy")
for episode in range(episodes):
progress.set_postfix(policy=name, episode=f"{episode + 1}/{episodes}")
metrics, steps, agentic_logs = _run_episode_impl(
policy,
config,
config.seed + episode,
episode,
name,
agentic_config,
llm_client,
)
metric_rows.append(metrics)
agentic_log_rows.extend(agentic_logs)
for row in steps:
action_rows.append({key: value for key, value in row.items() if key != "city_rewards"})
for city, value in row.get("city_rewards", {}).items():
city_hour_rows.append(
{
"policy": name,
"episode": episode,
"hour": row["hour"],
"city": city,
"city_reward": float(value),
"reward_ratio": row["reward_ratio"],
"liquidity_ratio": row["liquidity_ratio"],
"burn_rate": row["burn_rate"],
}
)
progress.update(1)
finally:
progress.close()
metrics_frame = pd.DataFrame(metric_rows)
actions_frame = pd.DataFrame(action_rows)
city_hour_frame = pd.DataFrame(city_hour_rows)
metrics_frame.to_csv(output / "metrics.csv", index=False)
actions_frame.to_csv(output / "actions.csv", index=False)
city_hour_frame.to_csv(output / "city_hour_policy.csv", index=False)
summary = metrics_frame.groupby("policy", as_index=False).mean(numeric_only=True)
if "static" in set(summary["policy"]):
static_slippage = float(summary.loc[summary["policy"].eq("static"), "mean_slippage"].iloc[0])
summary["slippage_reduction_vs_static"] = (static_slippage - summary["mean_slippage"]) / max(static_slippage, 1e-9)
summary.to_json(output / "summary.json", orient="records", indent=2)
(output / "config_snapshot.json").write_text(_json_dumps_dataclass(config), encoding="utf-8")
if agentic_config and agentic_config.save_agentic_logs:
with (output / "agentic_logs.jsonl").open("w", encoding="utf-8") as handle:
for row in agentic_log_rows:
handle.write(json.dumps(row, ensure_ascii=False) + "\n")
return metrics_frame, actions_frame, city_hour_frame
def _json_dumps_dataclass(config: BenchmarkConfig) -> str:
import json
return json.dumps(asdict(config), indent=2)
class SB3Policy:
def __init__(self, model, name: str):
self.model = model
self.name = name
def predict(self, obs: np.ndarray, deterministic: bool = True):
return self.model.predict(obs, deterministic=deterministic)
def _decode_policy_action(action: Any, config: BenchmarkConfig) -> np.ndarray:
if config.action_mode == "discrete":
return decode_discrete_action(int(action), config)
return decode_continuous_action(np.asarray(action, dtype=np.float32), config)
|