| from __future__ import annotations |
|
|
| from typing import Any |
|
|
| import numpy as np |
|
|
| from .schemas import PlannerOutput, action_dict |
|
|
|
|
| OBSERVATION_FIELDS = [ |
| "sin_hour", |
| "cos_hour", |
| "verified_mwh", |
| "reported_mwh", |
| "pmax_mwh", |
| "gap", |
| "liquidity", |
| "token_price", |
| "violation_rate", |
| "static_slippage", |
| "prev_reward_ratio", |
| "prev_liquidity_ratio", |
| ] |
|
|
|
|
| def build_episode_context(env: Any) -> dict[str, Any]: |
| base_env = getattr(env, "unwrapped", env) |
| config = base_env.config |
| market = config.market |
| context: dict[str, Any] = { |
| "episode_steps": int(config.episode_steps), |
| "no_physics_penalty": bool(config.no_physics_penalty), |
| "action_bounds_from_config": { |
| "reward_ratio": [market.min_reward_ratio, market.max_reward_ratio], |
| "liquidity_ratio": [market.min_liquidity_ratio, market.max_liquidity_ratio], |
| "burn_rate": [0.0, market.max_burn_rate], |
| "max_total_allocation": market.max_total_allocation, |
| }, |
| } |
| try: |
| start = int(base_env._episode_start_hour) |
| stop = start + int(config.episode_steps) |
| rows = base_env.data.city_hour[ |
| base_env.data.city_hour["absolute_hour"].between(start, stop - 1, inclusive="both") |
| ] |
| market_rows = base_env.data.market[ |
| base_env.data.market["absolute_hour"].between(start, stop - 1, inclusive="both") |
| ] |
| trades = base_env.data.trades[ |
| base_env.data.trades["absolute_hour"].between(start, stop - 1, inclusive="both") |
| ] |
| hourly = rows.groupby("absolute_hour", as_index=False).agg( |
| verified_W=("verified_W", "sum"), |
| reported_W=("reported_W", "sum"), |
| pmax_W=("pmax_W", "sum"), |
| violation_count=("violation_count", "sum"), |
| record_count=("record_count", "sum"), |
| ) |
| hourly["violation_rate"] = hourly["violation_count"] / hourly["record_count"].clip(lower=1) |
| demand = trades.groupby("absolute_hour", as_index=False).agg(demand_MWh=("energy_purchased_MW", "sum")) |
| hourly = hourly.merge(demand, on="absolute_hour", how="left").fillna({"demand_MWh": 0.0}) |
| hourly["verified_mwh"] = hourly["verified_W"] / 1_000_000.0 |
| hourly["reported_mwh"] = hourly["reported_W"] / 1_000_000.0 |
| hourly["pmax_mwh"] = hourly["pmax_W"] / 1_000_000.0 |
| hourly["gap"] = (hourly["verified_mwh"] - hourly["demand_MWh"]) / hourly["demand_MWh"].clip(lower=1e-6) |
| context.update( |
| { |
| "episode_start_hour": start, |
| "mean_verified_mwh": _mean(hourly["verified_mwh"]), |
| "min_verified_mwh": _min(hourly["verified_mwh"]), |
| "max_verified_mwh": _max(hourly["verified_mwh"]), |
| "mean_reported_mwh": _mean(hourly["reported_mwh"]), |
| "mean_pmax_mwh": _mean(hourly["pmax_mwh"]), |
| "mean_gap": _mean(hourly["gap"]), |
| "min_gap": _min(hourly["gap"]), |
| "mean_violation_rate": _mean(hourly["violation_rate"]), |
| "max_violation_rate": _max(hourly["violation_rate"]), |
| "mean_static_slippage": _mean(market_rows.get("slippage_solarchain_pct", [])), |
| } |
| ) |
| except Exception: |
| obs = base_env._observation() |
| context.update(_observation_context(obs)) |
| context["fallback_context"] = True |
| return context |
|
|
|
|
| def build_step_context( |
| obs: np.ndarray, |
| proposed_action: np.ndarray, |
| previous_action: np.ndarray, |
| plan: PlannerOutput, |
| info: dict[str, Any] | None = None, |
| ) -> dict[str, Any]: |
| proposed = np.asarray(proposed_action, dtype=np.float32) |
| previous = np.asarray(previous_action, dtype=np.float32) |
| return { |
| "observation": _observation_context(obs), |
| "proposed_action": action_dict(proposed), |
| "previous_action": action_dict(previous), |
| "action_jitter": float(np.linalg.norm(proposed - previous, ord=1)), |
| "plan": plan.model_dump(), |
| "latest_info": info or {}, |
| } |
|
|
|
|
| def _observation_context(obs: np.ndarray) -> dict[str, float]: |
| arr = np.asarray(obs, dtype=np.float32) |
| return {field: float(arr[index]) for index, field in enumerate(OBSERVATION_FIELDS)} |
|
|
|
|
| def _mean(values: Any) -> float: |
| arr = np.asarray(values, dtype=np.float64) |
| return float(np.mean(arr)) if arr.size else 0.0 |
|
|
|
|
| def _min(values: Any) -> float: |
| arr = np.asarray(values, dtype=np.float64) |
| return float(np.min(arr)) if arr.size else 0.0 |
|
|
|
|
| def _max(values: Any) -> float: |
| arr = np.asarray(values, dtype=np.float64) |
| return float(np.max(arr)) if arr.size else 0.0 |
|
|
