research/problems/cant_be_late/common/run_evaluator.py

#!/usr/bin/env python
"""
Common run_evaluator for cant-be-late variants.

Solution interface:
    class Solution(Strategy):
        def solve(self, spec_path: str) -> "Solution":
            # Optional: read spec for configuration
            return self

        def _step(self, last_cluster_type, has_spot) -> ClusterType:
            # Decision logic
            return ClusterType.SPOT if has_spot else ClusterType.ON_DEMAND
"""
import argparse
import inspect
import json
import os
import sys
from pathlib import Path
from typing import Optional

# Common directory paths
COMMON_DIR = Path(__file__).resolve().parent
SIM_ROOT = COMMON_DIR / "cant-be-late-simulator"

# ADRS defaults
ADRS_ENV_PATHS = [
    "us-west-2a_k80_8",
    "us-west-2b_k80_1",
    "us-west-2b_k80_8",
    "us-west-2a_v100_1",
    "us-west-2a_v100_8",
    "us-west-2b_v100_1",
]
ADRS_JOB_CONFIGS = [
    {"duration": 48, "deadline": 52},
    {"duration": 48, "deadline": 70},
]
ADRS_CHANGEOVER_DELAYS = [0.02, 0.05, 0.1]

# Setup paths
if str(COMMON_DIR) not in sys.path:
    sys.path.insert(0, str(COMMON_DIR))
if str(SIM_ROOT) not in sys.path:
    sys.path.insert(0, str(SIM_ROOT))

from cbl_evaluator import evaluate_stage1, evaluate_stage2
from sky_spot.strategies.strategy import Strategy


def load_and_validate_solution(solution_path: Path, spec_path: Path) -> Path:
    """
    Load solution, validate it's a Strategy with required methods, return the path.

    The solution.py file must define:
        class Solution(Strategy):
            def solve(self, spec_path): ...
            def _step(self, last_cluster_type, has_spot): ...
    """
    import importlib.util

    if not solution_path.exists():
        raise FileNotFoundError(f"solution.py not found at {solution_path}")

    spec = importlib.util.spec_from_file_location("submitted_solution", solution_path)
    if spec is None or spec.loader is None:
        raise ImportError(f"Failed to load spec for {solution_path}")

    module = importlib.util.module_from_spec(spec)
    spec.loader.exec_module(module)

    if not hasattr(module, "Solution"):
        raise AttributeError("solution.py must define a 'Solution' class")

    SolutionCls = module.Solution

    # Validate it's a Strategy subclass
    if not issubclass(SolutionCls, Strategy):
        raise TypeError("Solution must inherit from sky_spot.strategies.strategy.Strategy")

    # Validate it has solve method
    if not hasattr(SolutionCls, "solve") or not callable(getattr(SolutionCls, "solve")):
        raise AttributeError("Solution must implement solve(self, spec_path)")

    # Validate it has _step method
    if not hasattr(SolutionCls, "_step") or not callable(getattr(SolutionCls, "_step")):
        raise AttributeError("Solution must implement _step(self, last_cluster_type, has_spot)")

    # Note: solve() is NOT called here - it will be called by sim_worker with runtime config
    # Return the solution path - workers will load the Solution class directly
    return solution_path


def evaluate_solution(
    solution_path: Path,
    env_paths: Optional[list] = None,
    job_configs: Optional[list] = None,
    changeover_delays: Optional[list] = None,
) -> dict:
    """Evaluate a Solution (Strategy subclass); return payload with score and metrics."""
    solution_path_str = str(solution_path.resolve())

    env_paths = env_paths or ADRS_ENV_PATHS
    job_configs = job_configs or ADRS_JOB_CONFIGS
    changeover_delays = changeover_delays or ADRS_CHANGEOVER_DELAYS

    data_root = SIM_ROOT / "data"
    if not data_root.exists():
        raise RuntimeError(
            "Dataset not found. Please ensure real_traces.tar.gz has been extracted under "
            "common/cant-be-late-simulator/data/."
        )

    # Import pricing utils from simulator
    try:
        from sky_spot.utils import DEVICE_COSTS, COST_K
    except Exception as e:
        raise RuntimeError(f"Failed to import simulator pricing utils: {e}") from e

    # Stage 1: syntax/import check
    stage1_result = evaluate_stage1(solution_path_str)
    if stage1_result.get("runs_successfully", 0) != 1.0:
        return {"score": 0, "avg_cost": 0, "error": stage1_result.get("error", "Stage 1 failed")}

    # Stage 2: full evaluation
    try:
        result = evaluate_stage2(
            solution_path_str,
            env_paths,
            job_configs,
            changeover_delays,
        )
    except Exception as e:
        raise RuntimeError(f"Error running evaluator: {e}") from e

    if isinstance(result, dict):
        metrics = result.get("metrics", {})
        artifacts = result.get("artifacts", {})
    else:
        metrics = getattr(result, "metrics", {})
        artifacts = getattr(result, "artifacts", {})

    avg_cost = float(metrics.get("avg_cost", 0.0))
    scen_json = artifacts.get("scenario_stats_json")

    if not scen_json:
        return {"score": 0, "avg_cost": avg_cost, "od_anchor": None, "spot_anchor": None}

    try:
        scenario_stats = json.loads(scen_json)
    except Exception as e:
        raise RuntimeError(f"Error parsing scenario_stats_json: {e}") from e

    # Calculate normalized score
    total_weight = 0.0
    od_sum = 0.0
    spot_sum = 0.0

    for _, item in scenario_stats.items():
        env_path = item.get("env_path", "")
        duration = float(item.get("duration", 0))
        count = float(item.get("count", 0))
        if duration <= 0 or count <= 0 or not env_path:
            continue

        parts = env_path.split("_")
        device = None
        if len(parts) >= 3:
            device = f"{parts[-2]}_{parts[-1]}"
        if device not in DEVICE_COSTS:
            for cand in DEVICE_COSTS.keys():
                if cand in env_path:
                    device = cand
                    break
        od_price = DEVICE_COSTS.get(device)
        if od_price is None:
            continue
        spot_price = float(od_price) / float(COST_K)
        od_sum += float(od_price) * duration * count
        spot_sum += float(spot_price) * duration * count
        total_weight += count

    if total_weight <= 0 or od_sum <= 0:
        return {"score": 0, "avg_cost": avg_cost, "od_anchor": None, "spot_anchor": None}

    od_anchor = od_sum / total_weight
    spot_anchor = spot_sum / total_weight
    denom = od_anchor - spot_anchor
    if denom <= 1e-9:
        return {"score": 0, "avg_cost": avg_cost, "od_anchor": od_anchor, "spot_anchor": spot_anchor}

    norm = (od_anchor - avg_cost) / denom
    norm = max(0.0, min(1.0, norm))
    score = round(norm * 100)
    return {
        "score": score,
        "avg_cost": avg_cost,
        "od_anchor": od_anchor,
        "spot_anchor": spot_anchor,
        "scenario_count": total_weight,
    }


def evaluate(
    solution_path: Path,
    spec_path: Path,
    env_paths: Optional[list] = None,
    job_configs: Optional[list] = None,
    changeover_delays: Optional[list] = None,
) -> dict:
    """Full evaluation: load solution, validate, run simulations."""
    # Validate solution and call solve() for initialization
    validated_path = load_and_validate_solution(solution_path, spec_path)

    # Run evaluation
    return evaluate_solution(
        validated_path,
        env_paths=env_paths,
        job_configs=job_configs,
        changeover_delays=changeover_delays,
    )


def main(
    resources_dir: str,
    default_solution: str = "../../execution_env/solution_env/solution.py",
    env_paths: Optional[list] = None,
    job_configs: Optional[list] = None,
    changeover_delays: Optional[list] = None,
):
    """CLI entry point."""
    parser = argparse.ArgumentParser(description="Evaluate cant-be-late solution")
    parser.add_argument("--solution", default=default_solution, help="Path to solution.py")
    parser.add_argument("--spec", default=str(Path(resources_dir) / "submission_spec.json"))
    args = parser.parse_args()

    try:
        payload = evaluate(
            Path(args.solution).resolve(),
            Path(args.spec).resolve(),
            env_paths=env_paths,
            job_configs=job_configs,
            changeover_delays=changeover_delays,
        )
    except Exception as e:
        print(json.dumps({"error": str(e), "score": 0}))
        raise
    print(json.dumps(payload))