Spaces:
Running
Running
| import gradio as gr | |
| import pandas as pd | |
| import numpy as np | |
| from rouge_score import rouge_scorer | |
| from joblib import Parallel, delayed | |
| from selfrank.algos.greedy import SelfRankGreedy | |
| from selfrank.algos.iterative import SelfRank | |
| from selfrank.algos.baseline import MCARank | |
| from selfrank.algos.triplet import equality, rouge | |
| import matplotlib.pyplot as plt | |
| from itertools import zip_longest | |
| class UI: | |
| def __init__(self): | |
| """Load any static assets""" | |
| self.load_css() | |
| def header_block(self): | |
| """Title/description""" | |
| with open("assets/header.md", "r") as f: | |
| content = f.read() | |
| gr.Markdown(content) | |
| gr.Markdown("---") | |
| gr.Markdown("<br>") | |
| def selection_panel(self): | |
| """user selections""" | |
| gr.Markdown("""<h1 style='color: purple;'> Ranking with benchmarks </h1> """) | |
| gr.Markdown( | |
| """Using inference data gathered from [HELM](https://crfm.stanford.edu/helm/classic/latest/) we first show how our estimated rankings compare to rankings derived from using ground-truth or reference data.""" | |
| ) | |
| with gr.Column(variant="compact"): | |
| self.data = gr.Dropdown( | |
| choices=["CNN/DM", "XSUM", "MMLU"], | |
| multiselect=False, | |
| value="CNN/DM", | |
| label="Choose a dataset.", | |
| info="The dataset describes a specific task, either summarization (CNN/DM, XSUM) or multiple choice (MMLU).", | |
| interactive=True, | |
| ) | |
| self.mmlu = gr.Dropdown(visible=False) | |
| self.evaluation = gr.Dropdown( | |
| choices=["Rouge", "Equality"], | |
| multiselect=False, | |
| value="Rouge", | |
| interactive=True, | |
| label="Evaluation function", | |
| info="How should the Judge model decide the winner? Demo limited to use 'Rouge' for generative tasks like summarization, and 'equality' for multiple choice or classification tasks. In practice you can use any function that compares judge responses to the contestant models.", | |
| ) | |
| def update_mmlu(v): | |
| if v == "MMLU": | |
| return gr.Dropdown( | |
| choices=list(['abstract_algebra', 'college_chemistry', 'computer_security', 'econometrics', 'us_foreign_policy']), | |
| value='us_foreign_policy', | |
| multiselect=False, | |
| label="Choose MMLU subject.", | |
| info="MMLU subject area.", | |
| interactive=True, | |
| visible=True, | |
| ), gr.Dropdown(choices=['Equality'], value='Equality') | |
| else: | |
| return gr.Dropdown(visible=False), gr.Dropdown(choices=['Rouge'], value='Rouge') | |
| self.data.change(fn=update_mmlu, inputs=self.data, outputs=[self.mmlu, self.evaluation]) | |
| self.nmodels = gr.Dropdown( | |
| choices=["All", 10, 20, 30], | |
| label="Number of models", | |
| info="Sample a subset of LLMs to rank.", | |
| value=10, | |
| interactive=True, | |
| ) | |
| self.nrows = gr.Dropdown( | |
| choices=["All", 10, 20, 30], | |
| label="Number of instances", | |
| info="Sample a subset of instances to evaluate (smaller is faster).", | |
| value=10, | |
| interactive=True, | |
| ) | |
| self.method = gr.Dropdown( | |
| choices=["Greedy", "Full"], | |
| label="Algorithm variant to use", | |
| info="Choose from one of two variants. 'Full' (FTR in the paper) runs all triplet combinations, recommended when evaluations are cheap or for smaller datasets, or 'greedy' (GTR) a faster variant suggested for more complex evaluations.", | |
| value="Full", | |
| interactive=True, | |
| ) | |
| self.btn_execute = gr.Button("Run") | |
| def output_panel(self): | |
| """Plots/leaderboard/bump charts""" | |
| with gr.Column(variant="default"): | |
| gr.Markdown("""<h2 style='color: purple;'> Estimated ranking </h2> """) | |
| self.leaderboard = gr.DataFrame(headers=["rank", "model"], | |
| datatype=["number", "str"]) | |
| with gr.Column(variant="default"): | |
| gr.Markdown( | |
| """<h2 style='color: purple;'> Comparison to 'true' ranking </h2> """ | |
| ) | |
| # self.bumpchart = gr.Plot(format='png') | |
| self.bumpchart = gr.Image() | |
| self.eval_metrics = gr.Markdown() | |
| def synth_panel(self): | |
| """Synthetic data experiments""" | |
| gr.Markdown("<br>") | |
| gr.Markdown("---") | |
| gr.Markdown("""<h1 style='color: purple;'>Synthetic multiple choice </h1> """) | |
| gr.Markdown("Coming soon.") | |
| def byod_panel(self): | |
| """Instructions panel""" | |
| gr.Markdown("<br>") | |
| gr.Markdown("---") | |
| with open("assets/instructions.md", "r") as f: | |
| content = f.read() | |
| gr.Markdown(content) | |
| gr.Markdown("---") | |
| def load_css(self): | |
| with open("style.css", "r") as file: | |
| self.css = file.read() | |
| def layout(self): | |
| """Assemble the overall layout""" | |
| with gr.Blocks(theme=gr.themes.Default()) as demo: | |
| self.header_block() | |
| with gr.Row(): | |
| # Selection panel | |
| with gr.Column(): | |
| self.selection_panel() | |
| # Output panel/leaderboard | |
| self.output_panel() | |
| # TODO: self.synth_panel() | |
| self.byod_panel() | |
| # Register event listeners | |
| self.btn_execute.click( | |
| fn=self.benchmark_executor, | |
| inputs=[ | |
| self.data, | |
| self.mmlu, | |
| self.evaluation, | |
| self.nmodels, | |
| self.nrows, | |
| self.method, | |
| ], | |
| outputs=[self.leaderboard, self.bumpchart, self.eval_metrics], | |
| ) | |
| return demo | |
| def benchmark_executor( | |
| self, data, mmlu_subject, evaluation, nmodels, nrows, method | |
| ) -> tuple[pd.DataFrame, plt.figure]: | |
| """Main execution flow for benchmarks""" | |
| # gr.Info(f"Loaded run config: {data}, {evaluation}, {nmodels}.") | |
| seed = 40 | |
| np.random.seed(seed) | |
| match data: | |
| case "MMLU": | |
| adf = pd.read_pickle(f"data/mmlu_subject_{mmlu_subject}.pkl") | |
| case "CNN/DM": | |
| adf = pd.read_pickle(f"data/cnndm.pkl") | |
| case "XSUM": | |
| adf = pd.read_pickle(f"data/xsum.pkl") | |
| case _: | |
| raise ValueError(f"'{data}' not understood.") | |
| MODELS = adf.model.unique() | |
| # Sample fewer models if so needed | |
| if nmodels != "All": | |
| if nmodels < len(MODELS): | |
| MODELS = np.random.choice(MODELS, nmodels, replace=False).tolist() | |
| adf = adf[adf.model.isin(MODELS)] | |
| match data: | |
| case "MMLU": | |
| keys = [ | |
| "id", | |
| "trial_id", | |
| "perturbation", | |
| ] # MMLU has this extra parameter | |
| case "CNN/DM" | "XSUM": | |
| keys = ["id", "trial_id"] | |
| case _: | |
| pass | |
| df = adf.pivot_table( | |
| columns="model", | |
| index=keys, | |
| values="output", | |
| aggfunc="first", | |
| ) | |
| # Filter by number of rows | |
| df.dropna(inplace=True) | |
| if nrows != "All": | |
| if nrows < df.shape[0]: | |
| df = df.sample(nrows, random_state=seed) | |
| # Compute true ranking | |
| adf = adf.set_index(keys).loc[df.index].reset_index() | |
| if evaluation == "Rouge": | |
| def __true_rouge(x, scorer): | |
| return scorer.score(x["reference"], x["output"])["rouge2"].fmeasure | |
| scorer = rouge_scorer.RougeScorer(["rouge2"], use_stemmer=True) | |
| adf["rouge"] = Parallel(n_jobs=-1, batch_size=128)( | |
| delayed(__true_rouge)(i, scorer) for _, i in adf.iterrows() | |
| ) | |
| # Method 2 - look at "win rates" - for each question, see which model | |
| # wins (i.e. has the best ROUGE score) | |
| idx = adf.groupby(["id", "trial_id"])["rouge"].idxmax() | |
| win_rates = adf.loc[idx].model.value_counts() | |
| win_rate_rank = win_rates.index.tolist() | |
| # include models with nowins at the bottom | |
| no_wins = list(set(MODELS) - set(win_rate_rank)) | |
| true_ranking = win_rate_rank + no_wins | |
| evaluator = rouge | |
| elif evaluation == "Equality": | |
| # Compute the true ranking (multiple choice - so use equality between | |
| # LLM response and reference-value) | |
| adf["C"] = (adf.output == adf.reference).astype(int) | |
| true_ranking = ( | |
| adf.groupby("model")["C"] | |
| .apply(lambda x: sum(x) / len(x)) | |
| .sort_values(ascending=False) | |
| .index.tolist() | |
| ) | |
| evaluator = equality | |
| else: | |
| raise ValueError(f"'{evaluation}' not understood.") | |
| match method: | |
| case "Full": | |
| ranker = SelfRank(MODELS, evaluator, true_ranking) | |
| case "Greedy": | |
| ranker = SelfRankGreedy(MODELS, evaluator, true_ranking) | |
| case "MCA": | |
| raise NotImplementedError | |
| case _: | |
| raise ValueError(f"'{method}' not understood.") | |
| # generate outputs | |
| ranker.fit(df) | |
| ranks = ranker.ranking | |
| ranks = [ | |
| j + i for i, j in zip_longest(ranks, ["🥇 ", "🥈 ", "🥉 "], fillvalue="") | |
| ] | |
| out_df = pd.DataFrame({"rank": range(1, len(true_ranking) + 1), "model": ranks}) | |
| out_metrics = { | |
| "rbo": ranker.measure(metric="rbo"), | |
| "map-1": ranker.measure(metric="mapk", k=1), | |
| "map-3": ranker.measure(metric="mapk", k=3), | |
| "map-5": ranker.measure(metric="mapk", k=5), | |
| "map-10": ranker.measure(metric="mapk", k=10), | |
| "evaluations": evaluator.calls, | |
| } | |
| eval_metrics = ( | |
| f"<h2> Evaluation measures </h2>" | |
| f"Rank-Biased Overlap: {out_metrics['rbo']:0.3f}<br>" | |
| f"MAP-3 : {out_metrics['map-3']:0.3f}<br>" | |
| f"MAP-5 : {out_metrics['map-5']:0.3f}<br>" | |
| f"MAP-10 : {out_metrics['map-10']: 0.3f}." | |
| ) | |
| out_plot = ranker.plot() | |
| return out_df, "output.png", eval_metrics | |
| def run(self): | |
| self.ui = self.layout() | |
| self.ui.queue().launch(show_error=True) | |
| # if __name__ == "__main__": | |
| ui = UI() | |
| # ui.run() | |
| demo = ui.layout() | |
| demo.launch() | |