plotting/download_csv.py

"""
This file is to plot the MDP and POMDP results separately.

Usage example:
    python plottable.py --entity Your_entity --project Your_project --raw-csv runs.csv \
        --model-group-csv pqn_gdn_model_group.csv --output-csv obs_gap.csv
"""

import argparse
import pandas as pd
import wandb
import numpy as np
import matplotlib.pyplot as plt
import seaborn as sns
from scipy.interpolate import interp1d
import jax.numpy as jnp
from jax import lax


def parse_args():
    parser = argparse.ArgumentParser(
        description="Process W&B runs and compute MDP/POMDP return statistics."
    )

    # --- W&B connection ---
    parser.add_argument("--entity", type=str, default="Your_wandb_entity",
                        help="W&B entity (username or team). Default: Your_wandb_entity")
    parser.add_argument("--project", type=str, default="Your_wandb_project",
                        help="W&B project name. Default: Your_wandb_project")

    # --- Processing hyperparameters ---
    parser.add_argument("--interp-points", type=int, default=1000,
                        help="Number of interpolation points per run. Default: 1000")
    parser.add_argument("--normalizing-factor", type=float, default=200,
                        help="Step-axis normalizing factor. Default: 200")
    parser.add_argument("--ewm-span", type=int, default=100,
                        help="EWM smoothing span. Default: 100")

    # --- Output file names ---
    parser.add_argument("--raw-csv", type=str, default="runs_raw.csv",
                        help="Path for the raw per-step CSV fetched from W&B. Default: runs_raw.csv")
    parser.add_argument("--per-env-returns-csv", type=str, default="per_env_returns.csv",
                        help="Path for per-environment aggregated returns CSV. Default: per_env_returns.csv")
    parser.add_argument("--model-group-csv", type=str, default="model_group.csv",
                        help="Path for the per-algorithm model-group CSV. Default: model_group.csv")
    parser.add_argument("--output-csv", type=str, default="output.csv",
                        help="Path for the final obs-gap / memory-bias CSV. Default: output.csv")
    parser.add_argument("--per-env-table-csv", type=str, default="per_env_table.csv",
                        help="Path for the printable per-environment table CSV. Default: per_env_table.csv")

    # --- Control flow ---
    parser.add_argument("--skip-fetch", action="store_true",
                        help="Skip W&B fetch and load --raw-csv directly (for re-running analysis).")

    return parser.parse_args()


def fetch_and_process(args):
    """Fetch runs from W&B, process them, and save to args.raw_csv."""

    ENV_MAX_STEPS = {
        "CountRecallEasy": 2e7,
        "CountRecallMedium": 2e7,
        "CountRecallHard": 2e7,
        "BattleShipEasy": 2e7,
        "BattleShipMedium": 2e7,
        "BattleShipHard": 2e7,
        "MineSweeperEasy": 2e7,
        "MineSweeperMedium": 2e7,
        "MineSweeperHard": 2e7,
        "NavigatorEasy": 2e7,
        "NavigatorMedium": 2e7,
        "NavigatorHard": 2e7,
        # other environments default to 1e7
    }

    METRIC_MAPPING = {
        "PQN":     {"return_col": "returned_episode_returns", "time_col": "env_step"},
        "PQN_RNN": {"return_col": "returned_episode_returns", "time_col": "env_step"},
        "default": {"return_col": "episodic return",          "time_col": "TOTAL_TIMESTEPS"},
        # "PPO":     {"return_col": "episodic return", "time_col": "global step"},
        # "PPO_RNN": {"return_col": "episodic return", "time_col": "global step"},
    }

    api = wandb.Api()
    runs = api.runs(f"{args.entity}/{args.project}")
    filtered_runs = [r for r in runs if r.state == "finished"]
    print(f"Total runs: {len(runs)}, Completed runs: {len(filtered_runs)}")

    def process_run(run):
        """Process one W&B run; returns a DataFrame or None."""
        try:
            config = {k: v for k, v in run.config.items() if not k.startswith('_')}
            env_name = config.get("ENV_NAME", "UnknownEnv")
            partial_status = str(config.get("PARTIAL", False))

            env_max_step = ENV_MAX_STEPS.get(env_name, 1e7)

            # For PQN
            alg_name = config.get("ALG_NAME", "").upper()
            memory_type = "MLP"
            if alg_name == "PQN_RNN":
                memory_type = config.get("MEMORY_TYPE", "Unknown").capitalize()

            # For PPO (uncomment and swap when needed)
            # alg_name = config.get("TRAIN_TYPE", "").upper()
            # memory_type = "MLP"
            # if alg_name == "PPO_RNN":
            #     memory_type = config.get("MEMORY_TYPE", "Unknown").capitalize()

            metric_map = METRIC_MAPPING.get(alg_name, METRIC_MAPPING["default"])
            history = pd.DataFrame(
                list(run.scan_history(keys=[metric_map["return_col"], metric_map["time_col"]])),
                columns=[metric_map["return_col"], metric_map["time_col"]],
            )

            history["true_steps"] = history[metric_map["time_col"]].clip(upper=env_max_step)
            history = history.sort_values(metric_map["time_col"]).drop_duplicates(subset=["true_steps"])
            if len(history) < 2:
                print(f"Skipping {run.name}: insufficient data points")
                return None

            first_return = history[metric_map["return_col"]].iloc[0]
            last_return  = history[metric_map["return_col"]].iloc[-1]

            unified_steps = np.round(np.linspace(0, env_max_step, args.interp_points), decimals=5)
            scale_factor  = args.normalizing_factor / env_max_step

            interp_func = interp1d(
                history["true_steps"],
                history[metric_map["return_col"]],
                kind="linear",
                bounds_error=False,
                fill_value=(first_return, last_return),
            )
            interpolated_returns = interp_func(unified_steps)

            smoothed_returns = (
                pd.Series(interpolated_returns)
                .ewm(span=args.ewm_span, adjust=False, min_periods=1)
                .mean()
                .values
            )

            cummax_returns = lax.cummax(jnp.array(smoothed_returns))

            return pd.DataFrame({
                "Algorithm":      f"{alg_name} ({memory_type})",
                "Return":         interpolated_returns,
                "Smoothed Return": smoothed_returns,
                "Cummax Return":  np.array(cummax_returns),
                "True Steps":     unified_steps,
                "EnvName":        env_name,
                "Partial":        partial_status,
                "Seed":           str(config.get("SEED", 0)),
                "run_id":         run.id,
                "StepsNormalized": unified_steps * scale_factor,
                "EnvMaxStep":     env_max_step,
                "ScaleFactor":    scale_factor,
            })

        except Exception as e:
            print(f"Error processing {run.name}: {e}")
        return None

    all_data = [df for run in filtered_runs if (df := process_run(run)) is not None]
    if not all_data:
        print("No valid data to process")
        raise SystemExit(1)

    runs_df = pd.concat(all_data, ignore_index=True)
    runs_df.to_csv(args.raw_csv, index=False)
    print(f"Raw data saved to {args.raw_csv}")
    return runs_df


def analyse(args, runs_df):
    """Compute aggregated statistics and write output CSVs."""

    runs_df["FinalReturn"] = runs_df["Cummax Return"].astype(float)

    normal_dict = [
        "BattleShipEasy", "BattleShipMedium", "BattleShipHard",
        "MineSweeperEasy", "MineSweeperMedium", "MineSweeperHard",
        "BreakoutEasy", "BreakoutMedium", "BreakoutHard",
        "TetrisEasy", "TetrisMedium", "TetrisHard",
    ]

    for env in normal_dict:
        mask = runs_df["EnvName"] == env
        if mask.any():
            env_min = -1.0
            env_max = 0.6 if env in ["BreakoutEasy", "BreakoutMedium", "BreakoutHard"] else 1.0
            runs_df.loc[mask, "FinalReturn"] = (
                runs_df.loc[mask, "FinalReturn"] - env_min
            ) / (env_max - env_min)

    seedgroup = (
        runs_df
        .groupby(["Algorithm", "Partial", "EnvName", "run_id", "Seed"])["FinalReturn"]
        .max()
        .reset_index()
    )

    overseedgroup = seedgroup.groupby(["Algorithm", "Partial", "EnvName"]).agg(
        mean=("FinalReturn", "mean"),
        std=("FinalReturn", lambda x: x.std(ddof=1) if len(x) > 1 else 0.0),
        median=("FinalReturn", "median"),
        q25=("FinalReturn", lambda x: x.quantile(0.25)),
        q75=("FinalReturn", lambda x: x.quantile(0.75)),
        count=("FinalReturn", "count"),
    ).reset_index()

    overseedgroup["ci_lower"] = (
        overseedgroup["mean"] - 1.96 * overseedgroup["std"] / np.sqrt(overseedgroup["count"])
    )
    overseedgroup["ci_upper"] = (
        overseedgroup["mean"] + 1.96 * overseedgroup["std"] / np.sqrt(overseedgroup["count"])
    )

    overseedgroup.to_csv(args.per_env_returns_csv, index=False)
    print(f"Per-env returns saved to {args.per_env_returns_csv}")

    env_group = overseedgroup.groupby(["Algorithm", "Partial"]).agg(
        mean=("mean", "mean"),
        std=("std", "mean"),
        median=("median", "mean"),
        q25=("q25", "mean"),
        q75=("q75", "mean"),
        count=("count", "sum"),
    ).reset_index()

    env_group.to_csv(args.model_group_csv, index=False)
    print(f"Model-group data saved to {args.model_group_csv}")

    model_group = env_group.groupby(["Algorithm", "Partial"]).agg(
        mean=("mean", "mean"),
        std=("std", "mean"),
    ).reset_index()
    model_group.to_csv(args.output_csv, index=False)
    print(f"Output (obs gap / memory bias) saved to {args.output_csv}")

    # Print per-environment table (MDP vs POMDP)
    table_data = overseedgroup.copy()
    table_data["value_str"] = table_data.apply(
        lambda r: f"{r['mean']:.2f} \u00b1 {r['std']:.2f}", axis=1
    )
    pivot = table_data.pivot_table(
        index="EnvName", columns="Partial", values="value_str", aggfunc="first"
    )
    pivot.columns = [
        "MDP Return" if str(c) == "False" else "POMDP Return" for c in pivot.columns
    ]
    pivot = pivot.reset_index().rename(columns={"EnvName": "Environment"})
    print("\nPer-environment returns table:")
    print(pivot.to_string(index=False))
    pivot.to_csv(args.per_env_table_csv, index=False)
    print(f"\nSaved to {args.per_env_table_csv}")


def main():
    args = parse_args()

    if args.skip_fetch:
        print(f"Skipping W&B fetch — loading from {args.raw_csv}")
        runs_df = pd.read_csv(args.raw_csv)
    else:
        runs_df = fetch_and_process(args)

    analyse(args, runs_df)


if __name__ == "__main__":
    main()