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