viewer/app.py

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()