viewer/stats.py

from collections import defaultdict

import gradio as gr
import numpy as np
import pandas as pd
from scipy import stats
from viewer.literals import BASLINE_RUN_NAME
import tqdm as progress
from viewer.results import NormalizationMode, add_baseline_rows

from viewer.utils import BASELINE_GROUPING_MODE, create_df_from_run_data, get_groupped_score, get_run_name_seed, RunData, is_aggregate_column, is_task_column, select_runs


def fast_kendall_tau_a(x, y):
    x = np.array(x)
    y = np.array(y)
    n = len(x)
    if n <= 1:
        return 0.0

    # Create matrices of pairwise differences
    x_diff = x[:, np.newaxis] - x
    y_diff = y[:, np.newaxis] - y

    # Calculate concordant and discordant pairs
    concordant = np.sum((x_diff * y_diff > 0) & (np.triu(np.ones((n, n)), k=1) == 1))
    discordant = np.sum((x_diff * y_diff <= 0) & (np.triu(np.ones((n, n)), k=1) == 1))

    # Calculate tau-a
    tau_a = (concordant - discordant) / (n * (n - 1) / 2)

    return tau_a


def calculate_statistics(df: pd.DataFrame, std_dev_run_name: str, column_name: str,
                         score_s: int,  score_window: int, baseline_run: str = BASLINE_RUN_NAME) -> dict[str, float]:
    if len(df) == 0 or not (is_task_column(column_name) or is_aggregate_column(column_name)) or column_name not in df.columns:
        return defaultdict(lambda: np.nan)
    
    # drop baseline_score and other columns
    baseline_df = select_runs(df, runs_to_include=[baseline_run])

    df = select_runs(df, runs_to_exclude=[baseline_run])
    df = df[['runname', 'seed', 'steps', column_name]]
    
    # mean over seeds
    mean_over_seeds = df.groupby(['runname', 'steps'], as_index=False)[column_name].mean()
    pivot_df = mean_over_seeds.pivot(index='steps', columns='runname', values=column_name).interpolate(method='linear')

    # 1. monotonicity: Spearman Correlation
    spearman_corrs = [stats.spearmanr(pivot_df[col].index, pivot_df[col], nan_policy="omit")[0] for col in
                      pivot_df.columns if len(np.unique(pivot_df[col])) > 1]
    avg_spearman = np.mean([c for c in spearman_corrs if not np.isnan(c)]) if not all(
        map(np.isnan, spearman_corrs)) else np.nan

    # 2. ordering consistency: Average Kendall Tau-a
    last_half = int(len(pivot_df.index) / 2)
    step_pairs = list(zip(pivot_df.index[:-1], pivot_df.index[1:]))[last_half:]
    kendall_tau_a_values = [fast_kendall_tau_a(pivot_df.loc[s1], pivot_df.loc[s2]) for s1, s2 in step_pairs]
    avg_kendall_tau_a = np.mean(kendall_tau_a_values) if kendall_tau_a_values else np.nan

    # 3. variability: Std dev
    mean_std, min_std, min_std_step, max_std, max_std_step, snr, max_n_std  = (
        np.nan, np.nan, np.nan, np.nan, np.nan, np.nan, np.nan)
    if std_dev_run_name and std_dev_run_name != "-":
        grouped_std_runs = df[(df['runname'] == std_dev_run_name) & (df['steps'] != 0)] \
            .groupby('steps')[column_name]
            
        means = grouped_std_runs.mean()
        stds = grouped_std_runs.std()

        window_steps = means.index[means.index <= score_s][-score_window:]
        pivot_df_window = pivot_df.loc[window_steps]

        stds_window = stds[window_steps]
            
        if not stds_window.empty:
            max_std, max_std_step = stds_window.max(), stds_window.index[stds_window.argmax()]
            min_std, min_std_step = stds_window.min(), stds_window.index[stds_window.argmin()]
            mean_std = stds_window.mean()
            
        
            
        score = pivot_df_window.loc[score_s]

        full_mean_std = stds.mean()
        if full_mean_std != 0.0 and full_mean_std != np.nan:
            snr = score.mean() / full_mean_std

        if not baseline_df.empty and mean_std != np.nan and mean_std != 0:
            # 4. randomness
            random_baseline_scores = baseline_df.set_index("steps")[column_name].reindex(
                pd.concat([baseline_df["steps"], pivot_df_window.index.to_series()]).unique().sort()
            ).interpolate(method='linear')

            baseline_score = random_baseline_scores.loc[score_s]
            max_n_std = (score - baseline_score).max() / mean_std

    # # 2. Standard Error, Mean, and Max
    # summary_stats = [(df[col].std() / np.sqrt(df[col].count()),
    #                   df[col].mean(),
    #                   df[col].max()) for col in df.columns if df[col].count() > 1]
    # avg_stderr, avg_mean, max_max = np.nan, np.nan, np.nan
    # if summary_stats:
    #     avg_stderr = np.mean([s for s, _, _ in summary_stats])
    #     avg_mean = np.mean([m for _, m, _ in summary_stats])
    #     max_max = np.max([mx for _, _, mx in summary_stats])

    return {
        "avg_spearman": float(avg_spearman),
        "avg_kendall_tau_a": float(avg_kendall_tau_a),
        "max_std": float(max_std),
        "max_std_step": float(max_std_step),
        "min_std": float(min_std),
        "min_std_step": float(min_std_step),
        "mean_std": float(mean_std),
        "avg_snr": float(snr),
        "max_n_std": float(max_n_std)
    }


def format_statistics(stats: dict[str, float]) -> tuple[str, str, str, str]:
    if not stats:
        stats = defaultdict(lambda: np.nan)
    monotonicity_md_text = f"Average=**{stats['avg_spearman']:.3f}**"
    variability_md_text = f"""SNR=**{stats['avg_snr']:.2f}**; Mean std_dev=**{stats['mean_std']:.5f}**;
    Min std_dev=**{stats['min_std']:.3f} (step {stats['min_std_step']})**; 
    Max std_dev=**{stats['max_std']:.3f} (step {stats['max_std_step']})**"""
    randomness_md_text = (f"Maximum distance of final checkpoint to random baseline="
                          f"**{stats['max_n_std']:.2f}** std_devs")
    ordering_md_text = (f"Average Kendall-A Tau between second half of consecutive steps="
                        f"**{stats['avg_kendall_tau_a']:.3f}**")

    return monotonicity_md_text, variability_md_text, randomness_md_text, ordering_md_text


def smooth_tasks(df: pd.DataFrame, rolling_window: int) -> pd.DataFrame:
    if df.empty or "steps" not in df.columns:
        return df
    
    
    task_or_agg_columns = [c for c in df.columns if is_aggregate_column(c) or is_task_column(c)]
    if rolling_window > 0:
        smoothed_df = df.sort_values(by=["runname", "seed", "steps"])
        smoothed_df = smoothed_df.groupby(['runname', 'seed'])[task_or_agg_columns].rolling(rolling_window, min_periods=1).mean().reset_index(level=[0,1])
        smoothed_df["steps"] = df["steps"]
        df = smoothed_df
    return df

def generate_and_export_stats(run_data: RunData, std_dev_run_name: str, baseline_runs: list[str], baseline_mode: BASELINE_GROUPING_MODE, score_s: int, baseline_window: int) -> gr.File:
    if not run_data:
        return gr.File(value=None, visible=False)

    stats_data: list[dict] = []

    task_metrics = set(f"{task_info.name}/{metric}" for run in run_data for task_info in run.tasks
                       for metric, value in task_info.metrics.items())

    df = create_df_from_run_data(run_data)
    
    
    df = add_baseline_rows(df, baseline_runs, baseline_mode)

    df = select_runs(df, runs_to_exclude=baseline_runs)

    df = smooth_tasks(df, 3)
    
    for column in list(progress.tqdm(task_metrics)):
        if not is_task_column(column):
            continue
        
        # Calculate statistics
        task_stats = calculate_statistics(df, std_dev_run_name, column, score_s, baseline_window)

        task, metric = column.split("/")

        # Add to stats_data
        stats_data.append({
            "task": task,
            "metric": metric.removesuffix("|0/"),
            **task_stats
        })

    # Create DataFrame and export to CSV
    stats_df = pd.DataFrame(stats_data)
    stats_df.to_csv("statistics.csv", index=False)

    return gr.File(value="statistics.csv", visible=True)