add viewer + update plots

viewer/agg_score_metrics.py

@@ -0,0 +1,297 @@
+
+from typing import Literal
+
+AGG_SCORE_METRICS_TYPE = Literal["agg_score_metrics", "agg_score_metrics_prob_raw", "agg_score_metrics_acc"]
+
+agg_score_metrics_dict_prob = {
+    "ar": [
+        'custom|alghafa:mcq_exams_test_ar|0/prob_norm_token',
+        'custom|alghafa:meta_ar_msa|0/prob_norm',
+        'custom|alghafa:multiple_choice_grounded_statement_soqal_task|0/prob_norm_token',
+        'custom|arabic_mmlu_native:_average|0/prob_norm_pmi',
+        'custom|arc_easy_ar|0/prob_norm_token',
+        'custom|hellaswag-ar|0/prob_norm_token',
+        'custom|mlqa-ar|0/qa_ar_f1',
+        'custom|piqa_ar|0/prob_norm_token',
+        'custom|race_ar|0/prob_norm_token',
+        'custom|sciq_ar|0/prob_norm_token',
+        'custom|tydiqa-ar|0/qa_ar_f1',
+        'custom|x-codah-ar|0/prob_norm_token',
+        'custom|x-csqa-ar|0/prob_norm_pmi',
+        'custom|xnli-2.0-bool-v2-ar|0/prob',
+        'custom|arcd|0/qa_ar_f1',
+        'custom|xstory_cloze-ar|0/prob_norm_token'
+    ],
+    "fr": [
+        'custom|belebele-fr|0/prob_norm_token',
+        'custom|fquadv2|0/qa_fr_f1',
+        'custom|french-hellaswag|0/prob_norm_token',
+        'custom|mintaka-fr|0/qa_fr_f1',
+        'custom|meta_mmlu-fr:_average|0/prob_norm_pmi',
+        'custom|x-codah-fr|0/prob_norm_token',
+        'custom|x-csqa-fr|0/prob_norm_pmi',
+        'custom|xnli-2.0-bool-v2-fr|0/prob',
+        'custom|arc-fr|0/prob_norm_pmi'
+    ],
+    "hi": [
+        'custom|belebele-hi|0/prob_norm_token',
+        'custom|hellaswag-hi|0/prob_norm_token',
+        'custom|hi-arc:easy|0/arc_norm_token',
+        'custom|indicqa.hi|0/qa_hi_f1',
+        'custom|meta_mmlu-hi:_average|0/prob_norm_pmi',
+        'custom|x-codah-hi|0/prob_norm_token',
+        'custom|x-csqa-hi|0/prob_norm_pmi',
+        'custom|xcopa-hi|0/prob_norm_token',
+        'custom|indicnxnli-hi-bool-v2-hi|0/prob_norm_token',
+        'custom|xstory_cloze-hi|0/prob_norm_token'
+    ],
+    "ru": [
+        'custom|arc-ru|0/prob_norm_pmi',
+        'custom|belebele-ru|0/prob_norm_token',
+        'custom|hellaswag-ru|0/prob_norm_token',
+        'custom|parus|0/prob_norm_token',
+        'custom|rummlu:_average|0/prob_norm_pmi',
+        'custom|ruopenbookqa|0/prob_norm_token',
+        'custom|tydiqa-ru|0/qa_ru_f1',
+        'custom|x-codah-ru|0/prob_norm_token',
+        'custom|x-csqa-ru|0/prob_norm_pmi',
+        'custom|xnli-2.0-bool-v2-ru|0/prob',
+        'custom|sber_squad|0/qa_ru_f1',
+        'custom|xstory_cloze-ru|0/prob_norm_token',
+        'custom|xquad-ru|0/qa_ru_f1'
+    ],
+    "sw": [
+        'custom|belebele-sw|0/prob_norm_token',
+        'custom|arc-sw:easy|0/prob_norm_token',
+        'custom|kenswquad|0/qa_sw_f1',
+        'custom|tydiqa-sw|0/qa_sw_f1',
+        'custom|m3exam-sw|0/prob_norm_token',
+        'custom|x-csqa-sw|0/prob_norm_pmi',
+        'custom|xcopa-sw|0/prob_norm_token',
+        'custom|xnli-2.0-bool-v2-sw|0/prob_norm',
+        'custom|xstory_cloze-sw|0/prob_norm_token'
+    ],
+    "te": [
+        'custom|belebele-te|0/prob_norm_token',
+        'custom|custom_hellaswag-te|0/prob_norm_token',
+        'custom|indicqa.te|0/qa_te_f1',
+        'custom|mmlu-te:_average|0/prob_norm_token',
+        'custom|indicnxnli-te-bool-v2-te|0/prob_norm_token',
+        'custom|xcopa-te|0/prob_norm_token',
+        'custom|xstory_cloze-te|0/prob_norm_token'
+    ],
+    "th": [
+        'custom|belebele-th|0/prob_norm_token',
+        'custom|m3exam-th|0/prob_norm_token',
+        'custom|meta_mmlu-th:_average|0/prob_norm_pmi',
+        'custom|xnli-2.0-bool-v2-th|0/prob',
+        'custom|custom_hellaswag-th|0/prob_norm_token',
+        'custom|thaiqa|0/qa_th_f1',
+        'custom|xquad-th|0/qa_th_f1',
+    ],
+    "tr": [
+        'custom|arc-v2-tr|0/prob_norm',
+        'custom|belebele-tr|0/prob_norm',
+        'custom|exams-tr:_average|0/prob_norm',
+        'custom|hellaswag-tr|0/prob_norm',
+        'custom|mmlu-tr:_average|0/prob_norm_pmi',
+        'custom|tqduad2|0/qa_tr_f1',
+        'custom|xcopa-tr|0/prob_norm',
+        'custom|xnli-2.0-bool-v2-tr|0/prob',
+        'custom|xquad-tr|0/qa_tr_f1'
+    ],
+    "zh": [
+        'custom|agieval_NEW_LINE:_average|0/prob_norm_pmi',
+        'custom|belebele-zh|0/prob_norm_token',
+        'custom|c3|0/prob_norm_token',
+        'custom|ceval_NEW_LINE:_average|0/prob_norm_token',
+        'custom|cmmlu:_average|0/prob_norm_token',
+        'custom|cmrc|0/qa_zh_f1',
+        'custom|hellaswag-zh|0/prob_norm_token',
+        'custom|m3exam-zh|0/prob_norm_token',
+        'custom|mlqa-zh|0/qa_zh_f1',
+        'custom|x-codah-zh|0/prob_norm_token',
+        'custom|x-csqa-zh|0/prob_norm_pmi',
+        'custom|xcopa-zh|0/prob_norm_token',
+        'custom|ocnli-bool-v2-zh|0/prob',
+        'custom|chinese-squad|0/qa_zh_f1',
+        'custom|xstory_cloze-zh|0/prob_norm_token',
+        'custom|xwinograd-zh|0/prob_norm_token'
+    ]
+}
+
+
+def transform_for_prob_raw(metric: str):
+    # The pmi can't be used for unormalized probabilities
+    # Secondly the acc_norm_token is better in terms of monotonicity for this evaluation metric
+    splitted_metric = metric.split("/")
+    
+    # If it's generative metric we don't do anything
+    if not "prob" in splitted_metric[-1]:
+        return metric
+    return "/".join(splitted_metric[:-1] + ["prob_raw_norm_token"])
+
+
+
+    
+agg_score_metrics_dict_prob_raw = {
+    lang: [transform_for_prob_raw(metric) for metric in metrics]
+    for lang, metrics in agg_score_metrics_dict_prob.items()
+}
+
+agg_score_metrics_dict_acc = {
+    lang: [metric.replace("/prob", "/acc") for metric in metrics]
+    for lang, metrics in agg_score_metrics_dict_prob.items()
+}
+
+agg_score_metrics_dict_both = {
+    lang: agg_score_metrics_dict_prob[lang] + agg_score_metrics_dict_acc[lang]
+    for lang in agg_score_metrics_dict_prob.keys()
+}
+
+
+agg_score_metrics = {
+    "prob": agg_score_metrics_dict_prob,
+    "prob_raw": agg_score_metrics_dict_prob_raw,
+    "acc": agg_score_metrics_dict_acc,
+    "both": agg_score_metrics_dict_both
+}
+
+# Allow to override default groupping behaviour for aggregate tasks
+# The key is the task name and value is the list of tasks to use for the average
+custom_task_aggregate_groups = {
+    'custom|agieval_NEW_LINE': [
+        'gaokao-biology', 'gaokao-chemistry', 'gaokao-chinese', 'gaokao-geography',
+        'gaokao-history', 'gaokao-physics', 'jec-qa-ca',
+        'jec-qa-kd', 'logiqa-zh'
+    ]
+}
+
+def is_agg_score_col(col: str, agg_score_type: AGG_SCORE_METRICS_TYPE, lang: str):
+    metric_name = col
+    if agg_score_type == "agg_score_metrics_prob_raw":
+        return metric_name in agg_score_metrics_dict_prob_raw.get(lang, [])
+    elif agg_score_type == "agg_score_metrics_acc":
+        return metric_name in agg_score_metrics_dict_acc.get(lang, [])
+    
+    return agg_score_metrics_dict_prob.get(lang, [])
+
+
+# agg_score_metrics = {
+#     "ar": [
+#         'custom|alghafa:mcq_exams_test_ar|0/acc_norm_token',
+#         'custom|alghafa:meta_ar_msa|0/acc_norm',
+#         'custom|alghafa:multiple_choice_grounded_statement_soqal_task|0/acc_norm_token',
+#         'custom|arabic_mmlu_native:_average|0/acc_norm_pmi',
+#         'custom|arc_easy_ar|0/acc_norm_token',
+#         'custom|hellaswag-ar|0/acc_norm_token',
+#         'custom|mlqa-ar|0/qa_ar_f1',
+#         'custom|piqa_ar|0/acc_norm_token',
+#         'custom|race_ar|0/acc_norm_token',
+#         'custom|sciq_ar|0/acc_norm_token',
+#         'custom|tydiqa-ar|0/qa_ar_f1',
+#         'custom|x-codah-ar|0/acc_norm_token',
+#         'custom|x-csqa-ar|0/acc_norm_pmi',
+#         'custom|xnli-2.0-bool-v2-ar|0/acc',
+#         'custom|arcd|0/qa_ar_f1',
+#         'custom|xstory_cloze-ar|0/acc_norm_token'
+#     ],
+#     "fr": [
+#         'custom|belebele-fr|0/acc_norm_token',
+#         'custom|fquadv2|0/qa_fr_f1',
+#         'custom|french-hellaswag|0/acc_norm_token',
+#         'custom|mintaka-fr|0/qa_fr_f1',
+#         'custom|meta_mmlu-fr:_average|0/acc_norm_pmi',
+#         'custom|pawns-v2-fr|0/acc',
+#         'custom|x-codah-fr|0/acc_norm_token',
+#         'custom|x-csqa-fr|0/acc_norm_pmi',
+#         'custom|xnli-2.0-bool-v2-fr|0/acc',
+#         'custom|arc-fr|0/acc_norm_pmi'
+#     ],
+#     "hi": [
+#         'custom|belebele-hi|0/acc_norm_token',
+#         'custom|hellaswag-hi|0/acc_norm_token',
+#         'custom|hi-arc:easy|0/arc_norm_token',
+#         'custom|indicqa.hi|0/qa_hi_f1',
+#         'custom|meta_mmlu-hi:_average|0/acc_norm_pmi',
+#         'custom|x-codah-hi|0/acc_norm_token',
+#         'custom|x-csqa-hi|0/acc_norm_pmi',
+#         'custom|xcopa-hi|0/acc_norm_token',
+#         'custom|indicnxnli-hi-bool-v2-hi|0/acc_norm_token',
+#         'custom|xstory_cloze-hi|0/acc_norm_token'
+#     ],
+#     "ru": [
+#         'custom|arc-ru|0/acc_norm_pmi',
+#         'custom|belebele-ru|0/acc_norm_token',
+#         'custom|hellaswag-ru|0/acc_norm_token',
+#         'custom|parus|0/acc_norm_token',
+#         'custom|rummlu:_average|0/acc_norm_pmi',
+#         'custom|ruopenbookqa|0/acc_norm_token',
+#         'custom|tydiqa-ru|0/qa_ru_f1',
+#         'custom|x-codah-ru|0/acc_norm_token',
+#         'custom|x-csqa-ru|0/acc_norm_pmi',
+#         'custom|xnli-2.0-bool-v2-ru|0/acc',
+#         'custom|sber_squad|0/qa_ru_f1',
+#         'custom|xstory_cloze-ru|0/acc_norm_token',
+#         'custom|xquad-ru|0/qa_ru_f1'
+#     ],
+#     "sw": [
+#         'custom|belebele-sw|0/acc_norm_token',
+#         'custom|arc-sw:easy|0/acc_norm_token',
+#         'custom|kenswquad|0/qa_sw_f1',
+#         'custom|tydiqa-sw|0/qa_sw_f1',
+#         'custom|m3exam-sw|0/acc_norm_token',
+#         'custom|x-csqa-sw|0/acc_norm_pmi',
+#         'custom|xcopa-sw|0/acc_norm_token',
+#         'custom|xnli-2.0-bool-v2-sw|0/acc_norm',
+#         'custom|xstory_cloze-sw|0/acc_norm_token'
+#     ],
+#     "te": [
+#         'custom|belebele-te|0/acc_norm_token',
+#         'custom|custom_hellaswag-te|0/acc_norm_token',
+#         'custom|indicqa.te|0/qa_te_f1',
+#         'custom|mmlu-te:_average|0/acc_norm_token',
+#         'custom|indicnxnli-te-bool-v2-te|0/acc_norm_token',
+#         'custom|xcopa-te|0/acc_norm_token',
+#         'custom|xstory_cloze-te|0/acc_norm_token'
+#     ],
+#     "th": [
+#         'custom|belebele-th|0/acc_norm_token',
+#         'custom|m3exam-th|0/acc_norm_token',
+#         'custom|meta_mmlu-th:_average|0/acc_norm_pmi',
+#         'custom|xnli-2.0-bool-v2-th|0/acc',
+#         'custom|custom_hellaswag-th|0/acc_norm_token',
+#         'custom|thaiqa|0/qa_th_f1',
+#         'custom|xquad-th|0/qa_th_f1',
+#         'custom|thai-exams:tgat|0/acc_norm_token'
+#     ],
+#     "tr": [
+#         'custom|arc-v2-tr|0/acc_norm',
+#         'custom|belebele-tr|0/acc_norm',
+#         'custom|exams-tr:_average|0/acc_norm',
+#         'custom|hellaswag-tr|0/acc_norm',
+#         'custom|mmlu-tr:_average|0/acc_norm_pmi',
+#         'custom|tqduad2|0/qa_tr_f1',
+#         'custom|xcopa-tr|0/acc_norm',
+#         'custom|xnli-2.0-bool-v2-tr|0/acc',
+#         'custom|xquad-tr|0/qa_tr_f1'
+#     ],
+#     "zh": [
+#         'custom|agieval_NEW_LINE:_average|0/acc_norm_pmi',
+#         'custom|belebele-zh|0/acc_norm_token',
+#         'custom|c3|0/acc_norm_token',
+#         'custom|ceval_NEW_LINE:_average|0/acc_norm_token',
+#         'custom|cmmlu:_average|0/acc_norm_token',
+#         'custom|cmrc|0/qa_zh_f1',
+#         'custom|hellaswag-zh|0/acc_norm_token',
+#         'custom|m3exam-zh|0/acc_norm_token',
+#         'custom|mlqa-zh|0/qa_zh_f1',
+#         'custom|x-codah-zh|0/acc_norm_token',
+#         'custom|x-csqa-zh|0/acc_norm_pmi',
+#         'custom|xcopa-zh|0/acc_norm_token',
+#         'custom|ocnli-bool-v2-zh|0/acc',
+#         'custom|chinese-squad|0/qa_zh_f1',
+#         'custom|xstory_cloze-zh|0/acc_norm_token',
+#         'custom|xwinograd-zh|0/acc_norm_token'
+#     ]
+# }

viewer/app.py

@@ -0,0 +1,277 @@
+from collections import defaultdict
+from typing import get_args
+
+import gradio as gr
+import numpy as np
+
+from literals import TASK_CONSISTENCY_BUTTON_LABEL, CHECK_MISSING_DATAPOINTS_BUTTON_LABEL
+from plot import prepare_plot_data, plot_metric
+from viewer.results import fetch_run_results, fetch_run_list, init_input_normalization_runs, select_runs_by_regex, \
+    select_runs_by_language, \
+    init_input_component_values, init_std_dev_runs, render_results_table, export_results_csv, \
+    check_missing_datapoints
+from viewer.stats import generate_and_export_stats, format_statistics, calculate_statistics, smooth_tasks
+from viewer.utils import PlotOptions, check_task_hash_consistency, BASELINE_GROUPING_MODE
+
+with gr.Blocks() as demo:
+    list_of_runs = gr.State([])
+    plot_data = gr.State([])
+    statistics = gr.State(defaultdict(lambda: np.nan))
+    login_button = gr.LoginButton(visible=False)
+    run_data = gr.State([])
+    gr.Markdown("# FineWeb Multilingual experiments results explorer V2")
+    results_uri = gr.Textbox(label="TB HF Repo", value="s3://fineweb-multilingual-v1/evals/results/", visible=True)
+    with gr.Column():
+        with gr.Row():
+            # crop_prefix = gr.Textbox(label="Prefix to crop", value="tb/fineweb-exps-1p82G-")
+            steps = gr.Textbox(label="Training steps", value="%500",
+                               info="Use \",\" to separate. Use \"%32000\" for every 32000 steps. Use \"-\" for ranges. You can also combine them: \"1000-5000%1000\", 1000 to 5000 every 1000 steps.",
+                               interactive=True)
+            with gr.Column():
+                select_by_language = gr.Dropdown(choices=["ar", "fr", "ru", "hi", "th", "tr", "zh", "sw", "te"],
+                                                 interactive=True, label="Select language",
+                                                 info="Choose a language preset")
+                mcq_type = gr.Radio(choices=["prob_raw", "prob", "acc"], value="prob", label="MCQ agg metric type")
+            with gr.Column():
+                select_by_regex_text = gr.Textbox(label="Regex to select runs",
+                                                  value="1p46G-gemma-fp-.*-{lang}-.*")
+                select_by_regex_button = gr.Button("Select matching runs")
+        selected_runs = gr.Dropdown(choices=[], interactive=True, multiselect=True, label="Selected runs")
+        fetch_res = gr.Button("Fetch results")
+        with gr.Column():
+            aggregate_score_cols = gr.Dropdown(
+                choices=[], interactive=True, multiselect=True,
+                value=[],
+                label="Aggregate score columns", allow_custom_value=True,
+                info="The values from these columns/metrics will be averaged to produce the \"agg_score\""
+            )
+            metrics_to_show = gr.Checkboxgroup(
+                interactive=True,
+                value=["agg_score_metrics"],
+                choices=["agg_score_metrics"],
+                label="Metrics to display",
+                info="Results for these metrics will be shown")
+            with gr.Row():
+                with gr.Column(scale=1):
+                    task_averaging = gr.Checkboxgroup(
+                        interactive=True,
+                        choices=["show averages", "show expanded"],
+                        value=["show averages"],
+                        label="Task averaging",
+                        info="Behaviour for tasks with subsets")
+
+                    std_dev_run = gr.Dropdown(
+                        interactive=True,
+                        choices=[],
+                        label="Run for std_dev",
+                        info="Select a run to compute std_devs. Must have multiple seeds."
+                    )
+                with gr.Column(scale=2):
+                    # includes the seed
+                    with gr.Row():
+                        with gr.Column(scale=1):
+                            normalization_runs = gr.Dropdown(
+                                interactive=True,
+                                value=[], choices=[],
+                                multiselect=True,
+                                label="Normalization runs",
+                                info="Select runs to use for normalization"
+                            )
+                            normalization_mode = gr.Radio(
+                                choices=["No norm", "Rescale", "Z-norm"],
+                                value="Z-norm",
+                                label="Normalization mode"
+                            )
+                            clip_scores_checkbox = gr.Checkbox(value=False, label="Clip Scores")
+                        with gr.Column(scale=1):
+                            baseline_runs = gr.Dropdown(
+                                interactive=True,
+                                value=[], choices=[],
+                                multiselect=True,
+                                label="Baseline runs",
+                                info="Select runs to use as baseline"
+                            )
+                            baseline_groupping_mode = gr.Dropdown(choices=list(get_args(BASELINE_GROUPING_MODE)), value="Mean", label="Baseline grouping mode")
+        results_df = gr.Dataframe(interactive=False)
+
+        with gr.Row():
+            with gr.Column():
+                export_button = gr.Button("Export Results")
+                csv = gr.File(interactive=False, visible=False)
+            with gr.Column():
+                export_stats_button = gr.Button("Export Stats")
+                stats_csv = gr.File(interactive=False, visible=False)
+
+            check_missing_checkpoints = gr.Button(CHECK_MISSING_DATAPOINTS_BUTTON_LABEL)
+            check_task_consistency_button = gr.Button(TASK_CONSISTENCY_BUTTON_LABEL, visible=True)
+
+        task_consistency_output = gr.Json(label="Task hash consistency", visible=False)
+        missing_list = gr.Json(label="Missing datapoints", visible=False)
+        with gr.Row():
+            column_to_plot = gr.Dropdown(
+                choices=[], interactive=True,
+                value='agg_score_macro',
+                label="Task and metric", allow_custom_value=True)
+            score_step = gr.Number(
+                value=14000,
+                label="Step to use for computing benchmark score",
+            )
+            baseline_window = gr.Number(
+                value=5,
+                label="Window size for computing variability and randomness",
+            )
+        with gr.Row():
+            with gr.Column():
+                gr.Markdown("### Monotonicity - Spearman Rank Correlation (steps vs score)")
+                monotonicity_md = gr.Markdown()
+            with gr.Column():
+                gr.Markdown("### Variability (Windowed)  - std_dev (all steps of std_dev_run) and SNR (last step)")
+                variability_md = gr.Markdown()
+            with gr.Column():
+                gr.Markdown("### Randomness (Windowed) - distance to RB (in std_dev)")
+                randomness_md = gr.Markdown()
+            with gr.Column():
+                gr.Markdown("### Ordering - Kendall Tau (steps vs score)")
+                ordering_md = gr.Markdown()
+        with gr.Row():
+            merge_seeds = gr.Dropdown(
+                choices=["none", "min", "max", "mean"],
+                value='mean',
+                label="Seed merging")
+            smoothing_steps = gr.Number(
+                value=3,
+                label="Smooth every N datapoints (sliding window)",
+            )
+            stds_to_plot = gr.Number(
+                value=0,
+                label="plot N stds as error bars",
+            )
+            with gr.Column():
+                interpolate_checkbox = gr.Checkbox(value=False, label="Interpolate missing steps")
+                percent_checkbox = gr.Checkbox(value=False, label="%")
+                barplot_checkbox = gr.Checkbox(value=False, label="Bar plot")
+        plot = gr.Plot()
+
+    # run selection
+    gr.on(
+        triggers=[results_uri.change],
+        fn=fetch_run_list, inputs=[results_uri], outputs=[list_of_runs, selected_runs]
+    )
+    gr.on(
+        triggers=[select_by_regex_button.click],
+        fn=select_runs_by_regex,
+        inputs=[list_of_runs, selected_runs, select_by_regex_text, select_by_language], outputs=[selected_runs]
+    )
+    gr.on(
+        triggers=[select_by_language.change, mcq_type.change],
+        fn=select_runs_by_language,
+        inputs=[list_of_runs, selected_runs, select_by_language, aggregate_score_cols, mcq_type], outputs=[selected_runs, aggregate_score_cols]
+    )
+    demo.load(fn=fetch_run_list, inputs=[results_uri], outputs=[list_of_runs, selected_runs])
+
+    gr.on(
+        triggers=[selected_runs.change],
+        fn=init_std_dev_runs,
+        inputs=[selected_runs, std_dev_run],
+        outputs=[std_dev_run]
+    )
+    # fetch result
+    gr.on(
+        triggers=[fetch_res.click],
+        fn=fetch_run_results,
+        inputs=[results_uri, selected_runs, steps],
+        # We set the plot as output, as state has stae has no loading indicator
+        outputs=[run_data, plot]
+    ).then(
+        fn=init_input_component_values, inputs=[run_data, normalization_mode, select_by_language],
+        outputs=[metrics_to_show, normalization_runs, baseline_runs]
+    ).then(
+        fn=render_results_table,
+        inputs=[run_data, metrics_to_show, task_averaging, normalization_runs, baseline_runs, baseline_groupping_mode, clip_scores_checkbox,
+                normalization_mode, aggregate_score_cols, select_by_language, baseline_window, mcq_type],
+        outputs=[results_df, aggregate_score_cols, column_to_plot]
+    )
+    # change results table
+    gr.on(
+        triggers=[
+            metrics_to_show.input,
+            task_averaging.input,
+            normalization_runs.input,
+            baseline_runs.input,
+            clip_scores_checkbox.input,
+            baseline_groupping_mode.input,
+            aggregate_score_cols.input
+        ],
+        fn=render_results_table,
+        inputs=[run_data, metrics_to_show, task_averaging, normalization_runs, baseline_runs, baseline_groupping_mode, clip_scores_checkbox,
+                normalization_mode, aggregate_score_cols, select_by_language, baseline_window, mcq_type],
+        outputs=[results_df, aggregate_score_cols, column_to_plot]
+    )
+    
+    # On normalization mode we first have to preinit the compoentntns
+    gr.on(
+        triggers=[normalization_mode.input],
+        fn=init_input_normalization_runs,
+        inputs=[run_data, normalization_mode],
+        outputs=[normalization_runs]
+    ).then(
+        fn=render_results_table,
+        inputs=[run_data, metrics_to_show, task_averaging, normalization_runs, baseline_runs, baseline_groupping_mode, clip_scores_checkbox,
+                normalization_mode, aggregate_score_cols, select_by_language, baseline_window, mcq_type],
+        outputs=[results_df, aggregate_score_cols, column_to_plot]
+    )
+    # table actions
+    gr.on(
+        triggers=[export_button.click],
+        fn=export_results_csv, inputs=[results_df], outputs=[csv]
+    )
+    gr.on(
+        triggers=[check_missing_checkpoints.click],
+        fn=check_missing_datapoints, inputs=[selected_runs, steps, run_data, check_missing_checkpoints],
+        outputs=[missing_list, check_missing_checkpoints]
+    )
+
+    gr.on(
+        triggers=[check_task_consistency_button.click],
+        fn=check_task_hash_consistency, inputs=[run_data, check_task_consistency_button],
+        outputs=[task_consistency_output, check_task_consistency_button]
+    )
+    # plot
+    gr.on(
+        triggers=[results_df.change, column_to_plot.input, merge_seeds.input, smoothing_steps.input, stds_to_plot.input,
+                  interpolate_checkbox.input, percent_checkbox.input, baseline_window.input, barplot_checkbox.input],
+        fn=lambda df, col, merge_seeds, smoothing_steps, interpolate_checkbox, percent_checkbox:
+        prepare_plot_data(df,
+                          col,
+                          merge_seeds,
+                          PlotOptions(
+                              smoothing=smoothing_steps,
+                              interpolate=interpolate_checkbox,
+                              pct=percent_checkbox,
+                              merge_seeds=merge_seeds)),
+        inputs=[results_df, column_to_plot, merge_seeds, smoothing_steps, interpolate_checkbox, percent_checkbox],
+        outputs=[plot_data]
+    ).then(
+        fn=lambda df ,std_dev_run_name, column_name, score_s, variance_window, smoothing_steps:
+        calculate_statistics(smooth_tasks(df, smoothing_steps), std_dev_run_name, column_name, score_s, variance_window),
+        inputs=[results_df, std_dev_run, column_to_plot, score_step, baseline_window, smoothing_steps],
+        outputs=[statistics]
+    ).then(
+        fn=plot_metric,
+        inputs=[plot_data, column_to_plot, merge_seeds, percent_checkbox, statistics, stds_to_plot, select_by_language, barplot_checkbox],
+        outputs=[plot]
+    ).then(
+        fn=format_statistics,
+        inputs=[statistics],
+        outputs=[monotonicity_md, variability_md, randomness_md, ordering_md]
+    )
+
+    gr.on(
+        triggers=[export_stats_button.click],
+        fn=generate_and_export_stats,
+        inputs=[run_data, std_dev_run, baseline_runs, baseline_groupping_mode,
+                score_step, baseline_window],
+        outputs=[stats_csv]
+    )
+
+demo.launch()

viewer/literals.py

@@ -0,0 +1,9 @@
+TASK_CONSISTENCY_BUTTON_LABEL = "Check task hash consistency"
+TASK_CONSISTENCY_BUTTON_CLOSE_LABEL = "Close results"
+CHECK_MISSING_DATAPOINTS_BUTTON_LABEL = "Check missing datapoints"
+CHECK_MISSING_DATAPOINTS_BUTTON_CLOSE_LABEL = "Close results"
+FALLBACK_TOKEN_NAME = "HF_TOKEN"
+BASLINE_RUN_NAME = "baseline-6-"
+
+
+REFERENCE_RUNS = ["cc-100", "commoncrawl", "culturax", "hplt", "mc4"]

viewer/plot.py

@@ -0,0 +1,131 @@
+import numpy as np
+import pandas as pd
+from plotly import graph_objects as go
+import plotly.express as px
+from viewer.utils import PlotOptions
+
+
+def parse_merge_runs_to_plot(df, metric_name, merge_method):
+    if merge_method == "none":
+        return [
+            (group["steps"], group[metric_name], f'{runname}-s{seed}')
+            for (runname, seed), group in df.groupby(["runname", "seed"])
+        ]
+    if metric_name not in df.columns:
+        return []
+    grouped = df.groupby(['runname', 'steps']).agg({metric_name: merge_method}).reset_index()
+    return [
+        (group["steps"], group[metric_name], runname)
+        for (runname,), group in grouped.groupby(["runname"])
+    ]
+
+
+def prepare_plot_data(df: pd.DataFrame, metric_name: str, seed_merge_method: str,
+                      plot_options: PlotOptions) -> pd.DataFrame:
+    if df is None or "steps" not in df or metric_name not in df.columns:
+        return pd.DataFrame()
+
+    df = df.copy().sort_values(by=["steps"])
+    plot_data = parse_merge_runs_to_plot(df, metric_name, seed_merge_method)
+
+    # Create DataFrame with all possible steps as index
+    all_steps = sorted(set(step for xs, _, _ in plot_data for step in xs))
+    result_df = pd.DataFrame(index=all_steps)
+
+    # Populate the DataFrame respecting xs for each series
+    for xs, ys, runname in plot_data:
+        result_df[runname] = pd.Series(index=xs.values, data=ys.values)
+
+    # Interpolate or keep NaN based on the interpolate flag
+    if plot_options.interpolate:
+        # this is done per run, as each run is in a diff column
+        result_df = result_df.interpolate(method='linear')
+    # Apply smoothing if needed
+    if plot_options.smoothing > 0:
+        result_df = result_df.rolling(window=plot_options.smoothing, min_periods=1).mean()
+    if plot_options.pct:
+        result_df = result_df * 100
+
+    return result_df
+
+
+def plot_metric(plot_df: pd.DataFrame, metric_name: str, seed_merge_method: str, pct: bool, statistics: dict,
+                nb_stds: int, language: str = None, barplot: bool = False) -> go.Figure:
+    if barplot:
+        return plot_metric_barplot(plot_df, metric_name, seed_merge_method, pct, statistics, nb_stds, language)
+    return plot_metric_scatter(plot_df, metric_name, seed_merge_method, pct, statistics, nb_stds, language)
+
+def plot_metric_scatter(plot_df: pd.DataFrame, metric_name: str, seed_merge_method: str, pct: bool, statistics: dict,
+                nb_stds: int, language: str = None) -> go.Figure:
+    fig = go.Figure()
+    if not isinstance(plot_df, pd.DataFrame) or plot_df.empty:
+        return fig
+    show_error_bars = nb_stds > 0 and not np.isnan(statistics["mean_std"])
+    error_value = statistics["mean_std"] * nb_stds * (100 if pct else 1) if show_error_bars else 0.0
+
+    last_y_values = {runname: plot_df[runname].iloc[-1] for runname in plot_df.columns}
+    sorted_runnames = sorted(last_y_values, key=last_y_values.get, reverse=True)
+    for runname in sorted_runnames:
+        fig.add_trace(
+            go.Scatter(x=plot_df.index, y=plot_df[runname], mode='lines+markers', name=runname,
+                       hovertemplate=f'%{{y:.2f}} ({runname})<extra></extra>',
+                       error_y=dict(
+                           type='constant',  # Use a constant error value
+                           value=error_value,  # Single error value
+                           visible=show_error_bars  # Show error bars
+                       ))
+        )
+
+    lang_string = f" ({language})" if language else ""
+
+    fig.update_layout(
+        title=f"Run comparisons{lang_string}: {metric_name}" +
+              (f" ({seed_merge_method} over seeds)" if seed_merge_method != "none" else "") + (f" [%]" if pct else ""),
+        xaxis_title="Training steps",
+        yaxis_title=metric_name,
+        hovermode="x unified"
+    )
+    return fig
+
+
+def plot_metric_barplot(plot_df: pd.DataFrame, metric_name: str, seed_merge_method: str, pct: bool, statistics: dict,
+                nb_stds: int, language: str = None) -> go.Figure:
+    fig = go.Figure()
+    if not isinstance(plot_df, pd.DataFrame) or plot_df.empty:
+        return fig
+
+    show_error_bars = nb_stds > 0 and not np.isnan(statistics["mean_std"])
+    error_value = statistics["mean_std"] * nb_stds * (100 if pct else 1) if show_error_bars else 0.0
+
+    last_values = {runname: plot_df[runname].iloc[-1] for runname in plot_df.columns}
+    sorted_runnames = sorted(last_values, key=last_values.get, reverse=True)
+
+    # Create color map for consistent colors
+    colors = px.colors.qualitative.Set1
+    color_map = {run: colors[i % len(colors)] for i, run in enumerate(plot_df.columns)}
+
+    fig.add_trace(
+        go.Bar(
+            x=sorted_runnames,
+            y=[last_values[run] for run in sorted_runnames],
+            marker_color=[color_map[run] for run in sorted_runnames],
+            error_y=dict(
+                type='constant',
+                value=error_value,
+                visible=show_error_bars
+            ),
+            hovertemplate='%{y:.2f}<extra></extra>'
+        )
+    )
+
+    lang_string = f" ({language})" if language else ""
+
+    fig.update_layout(
+        title=f"Run comparisons{lang_string}: {metric_name}" +
+              (f" ({seed_merge_method} over seeds)" if seed_merge_method != "none" else "") + (
+                  f" [%]" if pct else ""),
+        xaxis_title="Runs",
+        yaxis_title=metric_name,
+        hovermode="x"
+    )
+    return fig

viewer/results.py

@@ -0,0 +1,421 @@
+import re
+
+import itertools
+import json
+import os
+from concurrent.futures import ThreadPoolExecutor
+from typing import get_args, Literal, List
+
+import pandas as pd
+import time
+from collections import defaultdict, Counter
+from datetime import datetime
+
+import gradio as gr
+from huggingface_hub import cached_assets_path
+
+from viewer.agg_score_metrics import agg_score_metrics_dict_prob, custom_task_aggregate_groups, agg_score_metrics
+from viewer.literals import BASLINE_RUN_NAME, CHECK_MISSING_DATAPOINTS_BUTTON_CLOSE_LABEL, \
+    CHECK_MISSING_DATAPOINTS_BUTTON_LABEL, \
+    FALLBACK_TOKEN_NAME, REFERENCE_RUNS
+from viewer.utils import BASELINE_GROUPING_MODE, create_df_from_run_data, get_run_name_seed, RunInfo, TaskInfo, get_groupped_score, RunData, is_aggregate_column, is_baseline_run, is_reference_run, is_task_column, rescale_scores, select_runs, z_score_normalize
+from datatrove.io import DataFolder
+from viewer.task_type_mapping import get_task_type, TASK_TYPE
+import tqdm as progress
+
+NormalizationMode = Literal["No adjustment", "Rescale", "Z-norm"]
+
+def fetch_run_results(results_uri, runs_to_fetch, steps_to_fetch,
+                      oauth_token: gr.OAuthToken | None = None):
+    token = os.environ.get(FALLBACK_TOKEN_NAME)
+    if oauth_token:
+        token = oauth_token.token
+    if not runs_to_fetch:
+        return None, None
+
+    steps_to_fetch_list = steps_to_fetch.split(",")
+    data_folder = DataFolder(results_uri, token=token)
+
+    def fetch_run_files(run_to_fetch):
+        def filename_to_steps_timestamp(fn):
+            step, ts = fn.split("/results_")
+            dt = datetime.strptime(ts.split(".")[0], "%Y-%m-%dT%H-%M-%S")
+            return int(step), dt
+
+        run_path = f"results/{run_to_fetch}"
+
+        try:
+            eval_files = [f for f in data_folder.list_files(run_path, recursive=True)]
+        except FileNotFoundError:
+            return []
+
+        # Group files by step
+        step_files = defaultdict(list)
+        for fn in eval_files:
+            steps, ts = filename_to_steps_timestamp(os.path.relpath(fn, run_path))
+            step_files[steps].append((ts, fn))
+
+        # Sort files within each step by timestamp (newest first)
+        for step in step_files:
+            step_files[step].sort(reverse=True)  # tuples are sorted element by element by default
+
+        # (run, steps, file_paths_in_repo)
+        results = []
+        for step, files in step_files.items():
+            if any(step_element_match(step, step_el) for step_el in steps_to_fetch_list):
+                results.append((run_to_fetch, step, files))
+        return results
+
+    def get_file_with_retry(data_folder: DataFolder, filename: str):
+        save_path = os.path.join(cached_assets_path(library_name="results-viewer",
+                                                    namespace=data_folder.path), filename)
+        if os.path.exists(save_path):
+            with open(save_path, "rb") as f:
+                return f.read()
+
+        wait = 1.5
+        max_retries = 20
+        for attempt in range(max_retries):
+            try:
+                with data_folder.open(filename, "rb") as f:
+                    data = f.read()
+                os.makedirs(os.path.dirname(save_path), exist_ok=True)
+                with open(save_path, "wb") as f:
+                    f.write(data)
+                return data
+            except Exception as e:
+                print(f"Error downloading (attempt {attempt + 1}/{max_retries}): {e}")
+                if attempt == max_retries - 1:
+                    raise e
+                time.sleep(max(wait ** attempt, 40))
+
+        return None
+    
+    def hot_fix_task_name(task_name: str):
+        """
+        This is a hot fix as Hynek inocrrectly named the average collumns
+        """
+
+        if task_name.endswith(":_average"):
+            return task_name.replace(":_average", ":_average|0")
+        return task_name
+
+
+
+
+    def load_run_file(run_info: tuple[str, str, list[tuple[datetime, str]]]):
+        run_to_fetch, step, file_data = run_info
+        aggregated_data = {}
+        latest_timestamps = {}
+
+        for timestamp, result_file in file_data:
+            file_data = get_file_with_retry(data_folder, result_file)
+            if not file_data:
+                raise Exception(f"File {result_file} not found")
+            json_data = json.loads(file_data)
+            for task, res in json_data["results"].items():
+                if task not in latest_timestamps or timestamp > latest_timestamps[task]:
+                    latest_timestamps[task] = timestamp
+                    # The aggregated tassks don't contain hashes, we thus use dummy values not to cause conflict
+                    hashes = json_data["summary_tasks"].get(task, {}).get("hashes") or {
+                        "hash_examples": "",
+                        "hash_full_prompts": "",
+                        "hash_input_tokens": "",
+                        "hash_cont_tokens": ""
+                    }
+                    aggregated_data[task] = {
+                        "metrics": res,
+                        "hashes": hashes,
+                        "filename": result_file
+                    }
+
+        runname, seed = get_run_name_seed(run_to_fetch)
+        return RunInfo(runname, seed, int(step),
+                       [TaskInfo(res["filename"], hot_fix_task_name(task), res["metrics"], res["hashes"]) for task, res in
+                        aggregated_data.items()])
+
+    with ThreadPoolExecutor() as pool:
+        run_files = list(itertools.chain.from_iterable(
+            progress.tqdm(pool.map(fetch_run_files, runs_to_fetch), total=len(runs_to_fetch),
+                          desc="Fetching datafiles...")))
+        run_data = list(
+            progress.tqdm(pool.map(load_run_file, run_files), total=len(run_files), desc="Loading evals data..."))
+
+    return run_data, None
+
+def filter_run_list_for_language(all_runs, language):
+    if not language:
+        return []
+    return [
+        x for x in all_runs if f"-{language}-" in x
+    ]
+
+
+def fetch_run_list(results_uri, oauth_token: gr.OAuthToken | None = None, language=None):
+    token = os.environ.get(FALLBACK_TOKEN_NAME)
+    if oauth_token:
+        token = oauth_token.token
+
+    data_folder = DataFolder(results_uri, token=token)
+    # Ignore the root directory
+    list_of_runs = [f.removeprefix("results/") for f in
+                    data_folder.list_files(subdirectory="results", recursive=False, include_directories=True)
+                    if f != "results"]
+    return list_of_runs, gr.update(choices=filter_run_list_for_language(list_of_runs, language), value=None)
+
+
+def select_runs_by_regex(runs, current_selected, regex_to_select, lang=None):
+    if lang and "{lang}" in regex_to_select:
+        regex_to_select = regex_to_select.replace("{lang}", lang)
+    comp_re = re.compile(regex_to_select)
+    return list(sorted(set((current_selected if current_selected else []) +
+                           [run for run in runs if comp_re.fullmatch(run)])))
+
+
+def add_baseline_rows(df: pd.DataFrame, baseline_runs: list[str], grouping_mode: BASELINE_GROUPING_MODE, baseline_name: str = BASLINE_RUN_NAME) -> pd.DataFrame:
+    if len(baseline_runs) == 0:
+        return df
+    
+    baseline_df = select_runs(df, runs_to_include=baseline_runs)
+    baseline_values = get_groupped_score(baseline_df, baseline_runs, grouping_mode)
+    
+    # If baseline values doesn't contain all available steps, we interpolate the baseline values
+    unique_steps = df["steps"].unique()
+    baseline_values = baseline_values.set_index("steps").reindex(index=unique_steps).interpolate().reset_index()
+    runname, seed = get_run_name_seed(baseline_name)
+
+    baseline_values['runname'] = runname
+    baseline_values['seed'] = seed
+    
+    # Add the baseline values to the dataframe
+    df = pd.concat([df, baseline_values], ignore_index=True)
+
+    return df
+
+def normalize_scores(df: pd.DataFrame, normalization_runs: list[str], clip_scores: bool, normalization_mode: NormalizationMode, variability_window: int = 1):
+    if not normalization_runs or len(normalization_runs) == 0:
+        return df
+
+    cols_to_process = [col for col in df.columns if is_task_column(col) and not col.endswith('_stderr') and ":_average|" not in col]
+
+    if normalization_mode == "Z-norm":
+        df = z_score_normalize(df, normalization_runs, cols_to_process, variability_window)
+    elif normalization_mode == "Rescale":
+        df = rescale_scores(df, normalization_runs, cols_to_process)
+
+    if clip_scores:
+        df[cols_to_process] = df[cols_to_process].clip(lower=0)
+    return df
+
+def recompute_averages(df: pd.DataFrame) -> pd.DataFrame:
+    average_columns = [col for col in df.columns if ":_average|" in col]
+    tasks_with_averages = set(x.split(":_average|")[0] for x in average_columns)
+    values_to_average = defaultdict(list)
+    for col in df.columns:
+        if (task := col.split(":")[0]) in tasks_with_averages and (task_subset := col.split(":")[1].split("|")[0]) and task_subset != "_average":
+            task_group = custom_task_aggregate_groups.get(task)
+            # Only add the task to average is it exists in the task group
+            if not task_group or task_subset in task_group:
+                values_to_average[(task, col.split("|")[-1])].append(col)  # task name and metric
+    
+    for (task, metric), cols in values_to_average.items():
+        df[f"{task}:_average|{metric}"] = df[cols].mean(axis=1)
+
+    return df
+
+
+def select_runs_by_language(runs, current_selected, language, selected_cols, mcq_type):
+    new_runs = current_selected
+    if language:
+        if language in agg_score_metrics[mcq_type]:
+            selected_cols = agg_score_metrics[mcq_type][language]
+        new_runs = select_runs_by_regex(runs, current_selected, ".*gemma.*-(" + "|".join(REFERENCE_RUNS) + ")-{lang}-.*", language)
+    return gr.update(value=new_runs, choices=filter_run_list_for_language(runs, language)), gr.update(value=selected_cols if selected_cols else [], choices=selected_cols if selected_cols else [])
+
+
+def step_element_match(step_to_check, step_element):
+    step_element = step_element.strip().replace(" ", "")
+    if "-" in step_element:
+        a, b = step_element.split("-")
+        c = None
+        if "%" in b:
+            b, c = b.split("%")
+        return (int(a) <= step_to_check <= int(b) and
+                (c is None or (step_to_check - int(a)) % int(c) == 0))
+    elif "%" in step_element:
+        return step_to_check % int(step_element[1:]) == 0
+    else:
+        return step_to_check == int(step_element)
+
+
+def init_input_component_values(run_data: RunData, normalization_mode: NormalizationMode, language: str | None = None):
+    task_metrics = set(metric for run in run_data for task in run.tasks for metric in task.metrics.keys())
+    initial_value = "agg_score_metrics" if language and language in agg_score_metrics_dict_prob else \
+        ("acc_norm" if "acc_norm" in task_metrics else next(iter(task_metrics), None))
+    runs = set(run.full_name for run in run_data)
+    baseline_runs = [run for run in runs if is_baseline_run(run)]
+
+
+    
+
+    return (gr.update(choices=["agg_score_metrics"] + sorted(task_metrics, key=lambda m: (m.endswith("_stderr"), m)), value=[initial_value]),
+            init_input_normalization_runs(run_data, normalization_mode),
+            gr.update(value=[] if not baseline_runs else [baseline_runs[0]], choices=sorted(runs)))
+
+
+def init_input_normalization_runs(runs: RunData, normalization_mode: NormalizationMode):
+    run_names = set([run.full_name for run in runs])
+    if normalization_mode == "Z-norm":
+        referene_runs = [run for run in run_names if is_reference_run(run)]
+        return gr.update(value=referene_runs, choices=sorted(run_names))
+    
+    elif normalization_mode == "Rescale":
+        baseline_runs = [run for run in run_names if is_baseline_run(run)]
+        return gr.update(value=baseline_runs, choices=sorted(run_names))
+    
+    else:
+        return gr.update(value=[], choices=[])
+
+
+
+def init_std_dev_runs(runs, current_val):
+    # sets to the run with the highest count of seeds, that has at least 2 seeds. name does not include the seed
+    value = current_val or "-"
+    seed_counter = Counter()
+    for run in runs or []:
+        seed_counter[run.split("-seed-")[0]] += 1
+
+    if seed_counter[value] <= 1:  # can only select runs with at least 2 seeds
+        top_val, top_count = seed_counter.most_common(n=1)[0] if seed_counter else (None, 0)
+        value = top_val if top_count > 1 else "-"
+    return gr.update(value=value, choices=["-"] + sorted([val for val, count in seed_counter.items() if count > 1]))
+
+
+def update_dropdown_choices(selected_choices, possible_choices):
+    selected_choices = [choice for choice in selected_choices if choice in possible_choices]
+    return gr.update(choices=possible_choices, value=selected_choices)
+
+
+def render_results_table(df: pd.DataFrame, metrics, task_avg, normalization_runs: list[str], baseline_runs: list[str], baseline_mode: BASELINE_GROUPING_MODE, clip_scores: bool,
+                         normalization_mode: NormalizationMode, aggregate_score_cols: list[str], language: str, variability_window: int = 1, mcq_type = "prob"):
+    # if not run_data:
+    #     return None, gr.update(), gr.update()
+    # df = create_df_from_run_data(run_data)
+
+    # Create baseline rows
+    df = add_baseline_rows(df, baseline_runs, baseline_mode)
+
+    # it's important to first normalize scores, so that the _averages can be recomputed
+    df = normalize_scores(df, normalization_runs=normalization_runs, clip_scores=clip_scores, normalization_mode=normalization_mode, variability_window=variability_window)
+
+    df = recompute_averages(df)
+    
+    # Remove baseline runs from the main DataFrame
+    df = select_runs(df, runs_to_exclude=baseline_runs)
+
+    to_drop = []
+    for col in df.columns:
+        if is_task_column(col):
+            # part of the agg score metrics
+            if "agg_score_metrics" in metrics and language in agg_score_metrics[mcq_type] and col in agg_score_metrics[mcq_type][language]:
+                continue
+            task, metric = col.split("/")
+            # If no metrics are selected, show all metrics
+            if ((metric not in metrics and len(metrics) > 0) or
+                    (":_average|" in task and "show averages" not in task_avg) or
+                    ("|" in task and ":_average|" not in task and ":" in task.split("|")[
+                        1] and "show expanded" not in task_avg)):
+                to_drop.append(col)
+    if to_drop:
+        df = df.drop(columns=to_drop)
+
+
+    df.sort_values(by=["runname", "seed", "steps"], inplace=True)
+    df = update_agg_score(df, aggregate_score_cols)
+    
+    aggregate_columns = [col for col in df.columns if is_aggregate_column(col)]
+    # All task metrics contains /metric
+    task_columns = [col for col in df.columns if is_task_column(col)]
+    return df, update_dropdown_choices(aggregate_score_cols, task_columns), gr.update(aggregate_columns[0], choices=aggregate_columns + task_columns)
+
+
+def get_type_tasks_dict(tasks: list[str]) -> dict[TASK_TYPE, list[str]]:
+    """
+    Creates a dictionary mapping task types to lists of task names.
+
+    Args:
+        tasks (list[str]): List of task names.
+
+    Returns:
+        dict[TASK_TYPE, list[str]]: Dictionary with task types as keys and lists of task names as values.
+    """
+    task_type_dict: dict[TASK_TYPE, list[str]] = defaultdict(list)
+    
+    for task in tasks:
+        task_type = get_task_type(task)
+        if not task_type:
+            raise ValueError(f"Task {task} has no task type")
+        task_type_dict[task_type].append(task)
+    
+    return task_type_dict
+
+def update_agg_score(df: pd.DataFrame, agg_score_columns: list[str]) -> pd.DataFrame:
+    if not agg_score_columns or df is None or "steps" not in df:
+        return df
+
+    new_df = df.copy()
+    cols_to_avg = [col for col in agg_score_columns if col in new_df.columns]
+    
+    if cols_to_avg:
+        # Calculate task type aggregates
+        task_type_dict = get_type_tasks_dict(cols_to_avg)
+        # Create a dict from task_type_list
+        for task_type, tasks in task_type_dict.items():
+            new_df[f'agg_score_{task_type}'] = new_df[tasks].mean(axis=1)
+        
+
+        # Calculate agg_score_task_macro
+        new_df['agg_score_macro'] = new_df[[f'agg_score_{task_type}' for task_type in task_type_dict.keys()]].mean(axis=1)
+
+        # Update agg_score
+        new_df['agg_score_micro'] = new_df[cols_to_avg].mean(axis=1)
+
+    return new_df
+
+
+def export_results_csv(df):
+    df.to_csv("output.csv", index=False)
+    return gr.update(value="output.csv", visible=True)
+
+
+def check_missing_datapoints(runs, steps_to_check, run_data: RunData, check_missing_checkpoints):
+    if not runs or check_missing_checkpoints == CHECK_MISSING_DATAPOINTS_BUTTON_CLOSE_LABEL or not run_data or not steps_to_check:
+        return gr.Json(value={}, visible=False), gr.Button(value=CHECK_MISSING_DATAPOINTS_BUTTON_LABEL)
+
+    max_step = max(run.step for run in run_data)
+    steps_set = set()
+    for step_elem in steps_to_check.split(","):
+        step_element = step_elem.strip().replace(" ", "")
+        if "-" in step_element:
+            a, b = step_element.split("-")
+            c = None
+            if "%" in b:
+                b, c = b.split("%")
+            steps_set.update(range(int(a), int(b) + 1, int(c) if c else 1))
+        elif "%" in step_element:
+            steps_set.update(range(0, max_step + 1, int(step_element[1:])))
+        else:
+            steps_set.add(int(step_element))
+
+    existing_evals = {(run.name, run.seed, run.step) for run in run_data}
+
+    missing_evals = defaultdict(dict)
+    for run in runs:
+        runname, seed = get_run_name_seed(run)
+        missing_steps = [
+            step for step in sorted(steps_set) if (runname, seed, step) not in existing_evals
+        ]
+        if missing_steps:
+            missing_evals[runname][str(seed)] = missing_steps
+
+    return gr.Json(value=missing_evals, visible=True), gr.Button(value=CHECK_MISSING_DATAPOINTS_BUTTON_CLOSE_LABEL)

viewer/stats.py

@@ -0,0 +1,189 @@
+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)
+

viewer/task_type_mapping.py

@@ -0,0 +1,41 @@
+import re
+from functools import lru_cache
+from typing import Literal, Dict, Optional
+
+TASK_TYPE = Literal['GK', 'RC', 'RES', 'NLU', 'TOXICITY', 'MATH', 'SEMANTIC']
+
+task_mapping: dict[TASK_TYPE, list[str]] = {
+    'GK': ['arc', 'hi-arc', '.*mmlu', 'mkqa', '.*exams', "mintaka", "m3exam", 'acva', 'agieval', 'ceval', 'x-csqa', 'sciq', 'ruworldtree', 'truthfulqa'],
+    'RC': ['belebele', 'tydiqa', 'xquad', 'fquad', ".*meta_ar", 'indicqa', 'cmrc', 'thaiqa', 'tqduad2', 'mlqa', 'race', 'arcd', 'chai', '.*boolq', 'lambada', 'kenswquad', 'chinese-squad', 'sber_squad', '.*soqal', 'c3'],
+    'RES': ['x-codah', 'xcopa', 'math-logic-qa', 'parus', 'ruopenbookqa', 'openbook_qa', 'piqa'],
+    'NLU': ['.*xnli', '.*hellaswag', 'xstory_cloze', 'xwinograd', 'pawns', 'rcb', 'ocnli'],
+    'TOXICITY': ['toxigen'],
+    'MATH': ['cmath'],
+    'SEMANTIC': ['.*sentiment'],
+}    
+
+def get_regex_from_strs(strs: list[str]) -> str:
+    return r'|'.join(strs)
+
+@lru_cache(maxsize=1)
+def create_task_type_retriever() -> Dict[str, TASK_TYPE]:
+    return {
+        get_regex_from_strs(tasks): task_type
+        for task_type, tasks in task_mapping.items()
+    }
+
+def get_task_type(task_name: str) -> Optional[TASK_TYPE]:
+    """
+    Given a task name in format of 'suite|task_name|...', returns the type of task
+    """
+    # Ensure we don't put too much into cache
+    real_task_name = task_name.split('|')[1]
+    return _get_task_type(real_task_name)
+
+@lru_cache(maxsize=10_000)
+def _get_task_type(task_name: str) -> Optional[TASK_TYPE]:
+    task_type_mapping = create_task_type_retriever()
+    for pattern, task_type in task_type_mapping.items():
+        if re.match(pattern, task_name):
+            return task_type
+    return None

viewer/utils.py

@@ -0,0 +1,186 @@
+from collections import defaultdict
+from dataclasses import dataclass
+from typing import Literal, Type
+
+import pandas as pd
+from typing import List
+
+import gradio as gr
+import numpy as np
+import pandas as pd
+
+from viewer.literals import REFERENCE_RUNS, TASK_CONSISTENCY_BUTTON_CLOSE_LABEL, TASK_CONSISTENCY_BUTTON_LABEL
+
+
+@dataclass
+class PlotOptions:
+    smoothing: int
+    interpolate: bool
+    pct: bool
+    merge_seeds: str
+
+
+@dataclass(frozen=True)
+class TaskInfo:
+    # Source file from which the task was fetched
+    filename: str
+    name: str
+    metrics: dict[str, float]
+    hashes: dict[str, str]
+
+
+@dataclass(frozen=True)
+class RunInfo:
+    name: str
+    seed: int
+    step: int
+    tasks: list[TaskInfo]
+
+    @property
+    def full_name(self):
+        return f"{self.name}-seed-{self.seed}" if not self.name.endswith("-") else self.name
+
+
+RunData = list[RunInfo]
+
+
+def get_run_name_seed(run_name):
+    if "-seed-" not in run_name:
+        return run_name, 42
+    run_name, seed = run_name.split("-seed-")
+    return run_name, int(seed)
+
+
+def select_runs(df: pd.DataFrame, runs_to_include: list[str] | None = None, runs_to_exclude: list[str] | None = None):
+    conditions = pd.Series(True, index=df.index)
+
+    if runs_to_include:
+        conditions_include = [(df['runname'] == get_run_name_seed(run)[0]) & (df['seed'] == get_run_name_seed(run)[1]) for run in runs_to_include]
+        conditions = pd.concat(conditions_include, axis=1).any(axis=1)
+    if runs_to_exclude:
+        conditions_exclude = [(df['runname'] == get_run_name_seed(run)[0]) & (df['seed'] == get_run_name_seed(run)[1]) for run in runs_to_exclude]
+        conditions = ~pd.concat(conditions_exclude, axis=1).any(axis=1)
+
+    return df[conditions]
+
+BASELINE_GROUPING_MODE = Literal["Mean", "Median", "Min", "Max"]
+def get_groupped_score(df: pd.DataFrame, runs: list[str], groupping_mode: BASELINE_GROUPING_MODE):
+    if len(runs) == 0:
+        return pd.DataFrame(columns=df.columns)
+    
+
+    tasks_or_agg = [col for col in df.columns if is_task_column(col) or is_aggregate_column(col)]
+    
+    res = select_runs(df, runs_to_include=runs)
+    
+    if groupping_mode == "Mean":
+        return res.groupby("steps")[tasks_or_agg].mean().reset_index()
+    elif groupping_mode == "Median":
+        return res.groupby("steps")[tasks_or_agg].median().reset_index()
+    elif groupping_mode == "Min":
+        return res.groupby("steps")[tasks_or_agg].min().reset_index()
+    elif groupping_mode == "Max":
+        return res.groupby("steps")[tasks_or_agg].max().reset_index()
+    
+
+
+def check_task_hash_consistency(run_data: RunData, check_task_consistency_button):
+    if not run_data or check_task_consistency_button == TASK_CONSISTENCY_BUTTON_CLOSE_LABEL:
+        return gr.update(value={}, visible=False), gr.update(value=TASK_CONSISTENCY_BUTTON_LABEL)
+    # Ignore the continuation tokens, as they vary with generative tasks
+    hash_keys = ["hash_examples", "hash_full_prompts"]
+    task_hashes = defaultdict(lambda: defaultdict(list))
+
+    for run in run_data:
+        for task_info in run.tasks:
+            hashes = task_info.hashes
+            hash_values = tuple(hashes.get(k) for k in hash_keys)
+            task_hashes[task_info.name][hash_values].append({
+                "name": run.name,
+                "step": run.step,
+                "filename": task_info.filename
+            })
+
+    conflicts = {}
+    for task, hash_groups in task_hashes.items():
+        if len(hash_groups) > 1:
+            conflicts[task] = [
+                {
+                    "runs": runs,
+                    "hashes": dict(zip(hash_keys, hash_values))
+                }
+                for hash_values, runs in hash_groups.items()
+            ]
+
+    return gr.Json(value={"conflicts": conflicts}, visible=True), gr.Button(value=TASK_CONSISTENCY_BUTTON_CLOSE_LABEL)
+
+
+def create_df_from_run_data(run_data: RunData):
+    df = pd.DataFrame([
+        {
+            "runname": run.name,
+            "seed": run.seed,
+            "steps": run.step,
+            "agg_score_micro": 0,
+            **{
+                f"{task_info.name}/{metric}": value
+                for task_info in run.tasks
+                for metric, value in task_info.metrics.items()
+            }
+        } for run in run_data
+    ])
+    df = df.fillna(0)
+    return df
+
+
+def is_task_column(column: str):
+    return "/" in column
+
+def is_aggregate_column(column: str):
+    return column.startswith("agg_score")
+
+def is_baseline_run(run: str):
+    return any(run.startswith(prefix) for prefix in ["random", "dummy", "baseline"])
+
+def is_reference_run(run: str):
+    return any([ref_run + "-" in run for ref_run in REFERENCE_RUNS])
+
+
+def z_score_normalize(df: pd.DataFrame, normalization_runs: List[str], columns: List[str], variability_window: int = 1) -> pd.DataFrame:
+    # without 2 runs we can't estimate the std
+    if len(normalization_runs) <= 1:
+        return df
+    
+    normalization_df = select_runs(df, runs_to_include=normalization_runs)
+    
+    # Group by steps and calculate mean and std for all columns at once
+    grouped = normalization_df.groupby('steps')[columns]
+    means = grouped.mean()
+    stds = grouped.std()
+
+    # Ensure we don't divide by zero
+    stds = stds.replace(0, 1)
+
+    # fetch values at the highest step
+    last_means = means.loc[means.index.max()]
+    # fetch and average the last N steps defined by the window size
+    last_window_stds = stds.sort_index(ascending=False).head(variability_window).mean()
+
+    df[columns] = (df[columns].sub(last_means[columns], axis=1)
+                   .div(last_window_stds[columns], axis=1))
+    
+    return df
+
+def rescale_scores(df: pd.DataFrame, normalization_runs: List[str], columns: List[str]) -> pd.DataFrame:
+    baseline = get_groupped_score(df, normalization_runs, "Mean")
+    
+    # Prepare baseline values and df for vectorized operation
+    baseline = baseline.set_index("steps").reindex(df["steps"].unique()).interpolate().reset_index()
+    
+    rescaled_cols = baseline.columns[~((baseline <= 0.0).all() | (baseline == 1.0).all())]
+    rescaled_cols = rescaled_cols[(rescaled_cols != 'steps') & rescaled_cols.isin(columns)]
+
+    df_with_baseline = df.merge(baseline[list(rescaled_cols) + ['steps']], on=["steps"], how="left", suffixes=("", "_baseline")).fillna(0)
+    df[rescaled_cols] = df[rescaled_cols].sub(df_with_baseline[rescaled_cols + '_baseline'].values)
+    df[rescaled_cols] = df[rescaled_cols].div(1 - df_with_baseline[rescaled_cols + '_baseline'].values)
+    return df