Upload 8 files

LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023 clembench
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

app.py

@@ -0,0 +1,215 @@
+import gradio as gr
+
+from src.assets.text_content import TITLE, INTRODUCTION_TEXT
+from src.leaderboard_utils import filter_search, get_github_data
+from src.plot_utils import split_models, compare_plots
+
+# from src.reload_utils import ReloadData
+from src.reload import get_primary_leaderboard, get_open_models, get_closed_models, get_plot_df, get_version_names, get_version_df, get_prev_df
+
+reload_time = 5
+
+# # For Leaderboards
+# # Get CSV data
+# global primary_leaderboard_df, version_dfs, version_names
+# primary_leaderboard_df, version_dfs, version_names = get_github_data()
+
+# global prev_df
+# prev_df = version_dfs[0]
+# def select_prev_df(name):
+#     ind = version_names.index(name)
+#     prev_df = version_dfs[ind]
+#     return prev_df
+
+# # For Plots 
+# global plot_df, OPEN_MODELS, CLOSED_MODELS
+# plot_df = primary_leaderboard_df[0]
+# MODELS = list(plot_df[list(plot_df.columns)[0]].unique())
+# OPEN_MODELS, CLOSED_MODELS = split_models(MODELS)
+
+
+# MAIN APPLICATION s
+main_app = gr.Blocks()
+with main_app:
+    gr.HTML(TITLE)
+    gr.Markdown(INTRODUCTION_TEXT, elem_classes="markdown-text")
+
+    with gr.Tabs(elem_classes="tab-buttons") as tabs:
+        with gr.TabItem("🥇 CLEM Leaderboard", elem_id="llm-benchmark-tab-table", id=0):
+            with gr.Row():
+                search_bar = gr.Textbox(
+                    placeholder=" 🔍 Search for models - separate multiple queries with `;` and press ENTER...",
+                    show_label=False,
+                    elem_id="search-bar",
+                )
+
+            leaderboard_table = gr.DataFrame(
+                value=get_primary_leaderboard,
+                elem_id="leaderboard-table",
+                interactive=False,
+                visible=True,
+                every=reload_time
+            )              
+
+            # Add a dummy leaderboard to handle search queries from the primary_leaderboard_df and not update primary_leaderboard_df
+            dummy_leaderboard_table = gr.Dataframe(
+                value=get_primary_leaderboard,
+                elem_id="leaderboard-table",
+                interactive=False,
+                visible=False,
+                every=reload_time
+            )
+                
+            search_bar.submit(
+                filter_search,
+                [dummy_leaderboard_table, search_bar],
+                leaderboard_table,
+                queue=True
+            )
+
+        with gr.TabItem("📈 Plot", id=3):
+            with gr.Row():
+                open_models_selection = gr.CheckboxGroup(
+                    choices=get_open_models(),
+                    label="Open-weight Models 🌐",
+                    value=[],
+                    elem_id="value-select",
+                    interactive=True,
+                    every=reload_time
+                )
+
+            with gr.Row():
+                closed_models_selection = gr.CheckboxGroup(
+                    choices=get_closed_models(), 
+                    label="Closed-weight Models 💼",
+                    value=[],
+                    elem_id="value-select-2",
+                    interactive=True,
+                    every=reload_time
+                )
+            
+            with gr.Row():
+                with gr.Column():
+                    show_all = gr.CheckboxGroup(
+                        ["Select All Models"],
+                        label="Show plot for all models 🤖",
+                        value=[],
+                        elem_id="value-select-3",
+                        interactive=True,
+                    )
+                
+                with gr.Column():
+                    show_names = gr.CheckboxGroup(
+                        ["Show Names"],
+                        label ="Show names of models on the plot 🏷️",
+                        value=[],
+                        elem_id="value-select-4",
+                        interactive=True,
+                    ) 
+
+                with gr.Column():
+                    show_legend = gr.CheckboxGroup(
+                        ["Show Legend"],
+                        label ="Show legend on the plot 💡",
+                        value=[],
+                        elem_id="value-select-5",
+                        interactive=True,
+                    ) 
+
+            with gr.Row():
+                dummy_plot_df = gr.DataFrame(
+                    value=get_plot_df,
+                    visible=False,
+                    every=reload_time
+                )
+
+            with gr.Row():
+                with gr.Column():
+                    # Output block for the plot
+                    plot_output = gr.Plot()
+
+            open_models_selection.change(
+                compare_plots,
+                [dummy_plot_df, open_models_selection, closed_models_selection, show_all, show_names, show_legend],
+                plot_output,
+                queue=True
+            )
+
+            closed_models_selection.change(
+                compare_plots,
+                [dummy_plot_df, open_models_selection, closed_models_selection, show_all, show_names, show_legend],
+                plot_output,
+                queue=True
+            )
+            
+            show_all.change(
+                compare_plots,
+                [dummy_plot_df, open_models_selection, closed_models_selection, show_all, show_names, show_legend],
+                plot_output,
+                queue=True
+            )
+
+            show_names.change(
+                compare_plots,
+                [dummy_plot_df, open_models_selection, closed_models_selection, show_all, show_names, show_legend],
+                plot_output,
+                queue=True
+            )
+
+            show_legend.change(
+                compare_plots,
+                [dummy_plot_df, open_models_selection, closed_models_selection, show_all, show_names, show_legend],
+                plot_output,
+                queue=True
+            )
+
+        with gr.TabItem("🔄 Versions and Details", elem_id="details", id=2):
+            with gr.Row():
+                version_select = gr.Dropdown(
+                    choices=get_version_names(), 
+                    label="Select Version 🕹️", 
+                    value=get_version_names()[0],
+                    every=reload_time
+                )
+            with gr.Row():
+                search_bar_prev = gr.Textbox(
+                    placeholder=" 🔍 Search for models - separate multiple queries with `;` and press ENTER...",
+                    show_label=False,
+                    elem_id="search-bar-2",
+                )
+
+            prev_table = gr.Dataframe(
+                value=get_prev_df,
+                elem_id="leaderboard-table",
+                interactive=False,
+                visible=True,
+                every=reload_time
+            )
+
+            dummy_prev_table = gr.Dataframe(
+                value=get_prev_df,
+                elem_id="leaderboard-table",
+                interactive=False,
+                visible=False,
+                every=reload_time
+            )
+
+            search_bar_prev.submit(
+                filter_search,
+                [dummy_prev_table, search_bar_prev],
+                prev_table,
+                queue=True
+            )
+
+            version_select.change(
+                get_prev_df,
+                [version_select],
+                prev_table,
+                queue=True,
+                every=reload_time
+            )
+    main_app.load()
+
+main_app.queue()
+
+main_app.launch()

requirements.txt

@@ -0,0 +1,3 @@
+gradio==3.43.2
+pandas==2.0.0
+plotly==5.18.0

src/assets/text_content.py

@@ -0,0 +1,53 @@
+TITLE = """<h1 align="center" id="space-title"> 🏆 CLEM Leaderboard</h1>"""
+
+INTRODUCTION_TEXT = """
+<h6 align="center">
+The CLEM Leaderboard aims to track, rank and evaluate current cLLMs (chat-optimized Large Language Models) with the suggested pronounciation “clems”. 
+
+The benchmarking approach is described in [Clembench: Using Game Play to Evaluate Chat-Optimized Language Models as Conversational Agents](https://arxiv.org/abs/2305.13455).
+
+Source code for benchmarking "clems" is available here: [Clembench](https://github.com/clembench/clembench)
+
+All generated files and results from the benchmark runs are available here: [clembench-runs](https://github.com/clembench/clembench-runs) </h6>
+"""
+
+SHORT_NAMES = {
+    "t0.0": "",
+    "claude-v1.3": "cl-1.3",
+    "claude-2": "cl-2",
+    "claude-2.1": "cl-2.1",
+    "claude-instant-1.2": "cl-ins-1.2",
+    "gpt-3.5-turbo-0613": "3.5-0613",
+    "gpt-3.5-turbo-1106": "3.5-1106",
+    "gpt-4-0613": "4-0613",
+    "gpt-4-1106-preview": "4-1106",
+    "gpt-4-0314": "4-0314",
+    "gpt-4": "4",
+    "text-davinci-003": "3",
+    "luminous-supreme": "lm",
+    "koala-13b": "k-13b",
+    "falcon-40b": "fal-40b",
+    "falcon-7b-instruct": "fal-7b",
+    "falcon-40b-instruct": "flc-i-40b",
+    "oasst-12b": "oas-12b",
+    "oasst-sft-4-pythia-12b-epoch-3.5": "ost-12b",
+    "vicuna-13b": "vic-13b",
+    "vicuna-33b-v1.3": "vic-33b-v1.3",
+    "sheep-duck-llama-2-70b-v1.1": "sd-l2-70b-v1.1",
+    "sheep-duck-llama-2-13b": "sd-l2-13b",
+    "WizardLM-70b-v1.0": "w-70b-v1.0",
+    "CodeLlama-34b-Instruct-hf": "cl-34b",
+    "command": "com",
+    "Mistral-7B-Instruct-v0.1": "m-i-7b-v0.1",
+    "Wizard-Vicuna-13B-Uncensored-HF": "vcn-13b",
+    "llama-2-13b-chat-hf": "l2-13b",
+    "llama-2-70b-chat-hf": "l2-70b",
+    "llama-2-7b-chat-hf": "l2-7b",
+    "koala-13B-HF": "k-13b",
+    "WizardLM-13b-v1.2": "w-13b-v1.2",
+    "vicuna-7b-v1.5": "vic-7b-v1.5",
+    "vicuna-13b-v1.5": "vic-13b-v1.5",
+    "gpt4all-13b-snoozy": "g4a-13b-s",
+    "zephyr-7b-alpha":"z-7b-a",
+    "zephyr-7b-beta":"z-7b-b"
+}

src/leaderboard_utils.py

@@ -0,0 +1,142 @@
+import os
+import pandas as pd
+import requests, json
+from io import StringIO
+
+from datetime import datetime
+
+
+def get_github_data():
+    current_time = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+    print(f"LOADING GITHUB DATAAA.... at time = {current_time}")
+    '''
+    Get data from csv files on Github
+    Args:
+        None    
+    Returns: 
+        latest_df: singular list containing dataframe of the latest version of the leaderboard with only 4 columns 
+        all_dfs: list of dataframes for previous versions + latest version including columns for all games
+        all_vnames: list of the names for the previous versions + latest version (For Details and Versions Tab Dropdown)
+    '''
+    uname = "kushal-10"
+    repo = "clembench-runs"
+    json_url = f"https://raw.githubusercontent.com/{uname}/{repo}/main/benchmark_runs.json"
+    resp = requests.get(json_url)
+    if resp.status_code == 200:
+        json_data = json.loads(resp.text)
+        versions = json_data['versions']
+        version_names = []
+        csv_url = f"https://raw.githubusercontent.com/{uname}/{repo}/main/"
+        for ver in versions:
+            version_names.append(ver['version'])
+            csv_path = ver['result_file'].split('/')[1:]
+            csv_path = '/'.join(csv_path)
+        
+        #Sort by latest version
+        float_content = [float(s[1:]) for s in version_names]
+        float_content.sort(reverse=True)
+        version_names = ['v'+str(s) for s in float_content]
+
+        DFS = []
+        for version in version_names:
+            result_url = csv_url+ version + '/' + csv_path
+            csv_response = requests.get(result_url)
+            if csv_response.status_code == 200:
+                df = pd.read_csv(StringIO(csv_response.text))
+                df = process_df(df)
+                df = df.sort_values(by=list(df.columns)[1], ascending=False) # Sort by clemscore
+                DFS.append(df)
+            else:
+                print(f"Failed to read CSV file for version : {version}. Status Code : {resp.status_code}")
+
+        # Only keep relavant columns for the main leaderboard
+        latest_df_dummy = DFS[0]
+        all_columns = list(latest_df_dummy.columns)
+        keep_columns = all_columns[0:4]
+        latest_df_dummy = latest_df_dummy.drop(columns=[c for c in all_columns if c not in keep_columns])
+
+        latest_df = [latest_df_dummy]
+        all_dfs = []
+        all_vnames = []
+        for df, name in zip(DFS, version_names):
+            all_dfs.append(df)
+            all_vnames.append(name) 
+        return latest_df, all_dfs, all_vnames
+    
+    else:
+        print(f"Failed to read JSON file: Status Code : {resp.status_code}")
+
+def process_df(df: pd.DataFrame) -> pd.DataFrame:
+    '''
+    Process dataframe 
+    - Remove repition in model names 
+    - Convert datatypes to sort by "float" instead of "str" for sorting
+    - Update column names
+    Args:
+        df: Unprocessed Dataframe (after using update_cols)
+    Returns:
+        df: Processed Dataframe
+    '''
+
+    # Change column type to float from str
+    list_column_names = list(df.columns)
+    model_col_name = list_column_names[0]
+    for col in list_column_names:
+        if col != model_col_name:
+            df[col] = df[col].astype(float)
+
+    # Remove repetition in model names, if any
+    models_list = []
+    for i in range(len(df)):
+        model_name = df.iloc[i][model_col_name]
+        splits = model_name.split('--')
+        splits = [split.replace('-t0.0', '') for split in splits] # Comment to not remove -t0.0
+        if splits[0] == splits[1]:
+            models_list.append(splits[0])
+        else:
+            models_list.append(splits[0] + "--" + splits[1])
+    df[model_col_name] = models_list
+
+    # Update column names
+    update = ['Model', 'Clemscore', '% Played', 'Quality Score']
+    game_metrics = list_column_names[4:]
+
+    for col in game_metrics:
+        splits = col.split(',')
+        update.append(splits[0].capitalize() + "" + splits[1])
+    
+    map_cols = {}
+    for i in range(len(update)):
+        map_cols[list_column_names[i]] = str(update[i])
+
+    df = df.rename(columns=map_cols)    
+    return df
+
+def filter_search(df: pd.DataFrame, query: str) -> pd.DataFrame:
+    '''
+    Filter the dataframe based on the search query
+    Args:
+        df: Unfiltered dataframe
+        query: a string of queries separated by ";"
+    Return:
+        filtered_df: Dataframe containing searched queries in the 'Model' column 
+    '''
+    queries = query.split(';')
+    list_cols = list(df.columns)
+    df_len = len(df)
+    filtered_models = []
+    models_list = list(df[list_cols[0]])
+    for q in queries:
+        q = q.lower()
+        q = q.strip()
+        for i in range(df_len):
+            model_name = models_list[i]
+            if q in model_name.lower():
+                filtered_models.append(model_name) # Append model names containing query q
+
+    filtered_df = df[df[list_cols[0]].isin(filtered_models)]
+
+    if query == "":
+        return df
+
+    return filtered_df

src/plot_utils.py

@@ -0,0 +1,133 @@
+import pandas as pd
+import plotly.express as px
+
+from src.assets.text_content import SHORT_NAMES
+
+def plotly_plot(df:pd.DataFrame, LIST:list, ALL:list, NAMES:list, LEGEND:list):
+    '''
+    Takes in a list of models for a plotly plot
+    Args:
+        df: A dummy dataframe of latest version
+        LIST: List of models to plot
+        ALL: Either [] or ["Show All Models"] - toggle view to plot all models 
+        NAMES: Either [] or ["Show Names"] - toggle view to show model names on plot 
+        LEGEND: Either [] or ["Show Legend"] - toggle view to show legend on plot
+    Returns:
+        Fig: plotly figure
+    '''
+    
+    # Get list of all models and append short names column to df
+    list_columns = list(df.columns)
+    ALL_LIST = list(df[list_columns[0]].unique())
+    short_names = label_map(ALL_LIST)
+    list_short_names = list(short_names.values())
+    df["Short"] = list_short_names
+
+    if ALL:
+        LIST = ALL_LIST
+    # Filter dataframe based on the provided list of models
+    df = df[df[list_columns[0]].isin(LIST)]
+    
+
+    if NAMES:
+        fig = px.scatter(df, x=list_columns[2], y=list_columns[3], color=list_columns[0], symbol=list_columns[0],
+                 color_discrete_map={"category1": "blue", "category2": "red"},
+                 hover_name=list_columns[0], template="plotly_white", text="Short")
+        fig.update_traces(textposition='top center')
+    else:
+        fig = px.scatter(df, x=list_columns[2], y=list_columns[3], color=list_columns[0], symbol=list_columns[0],
+                    color_discrete_map={"category1": "blue", "category2": "red"},
+                    hover_name=list_columns[0], template="plotly_white")
+        
+    if not LEGEND:
+        fig.update_layout(showlegend=False)
+        
+    fig.update_layout(
+        xaxis_title='% Played',
+        yaxis_title='Quality Score',
+        title='Overview of benchmark results',
+        height=1000
+    )
+
+    fig.update_xaxes(range=[-5, 105])
+    fig.update_yaxes(range=[-5, 105])
+
+    return fig
+
+
+# ['Model', 'Clemscore', 'All(Played)', 'All(Quality Score)']
+def compare_plots(df: pd.DataFrame, LIST1: list, LIST2: list, ALL:list, NAMES:list, LEGEND: list):
+    '''
+    Quality Score v/s % Played plot by selecting models
+    Args:
+        df: A dummy dataframe of latest version
+        LIST1: The list of open source models to show in the plot, updated from frontend
+        LIST2: The list of commercial models to show in the plot, updated from frontend
+        ALL: Either [] or ["Show All Models"] - toggle view to plot all models 
+        NAMES: Either [] or ["Show Names"] - toggle view to show model names on plot
+        LEGEND: Either [] or ["Show Legend"] - toggle view to show legend on plot 
+    Returns:
+        fig: The plot
+    '''
+
+    # Combine lists for Open source and commercial models
+    LIST = LIST1 + LIST2
+    fig = plotly_plot(df, LIST, ALL, NAMES, LEGEND)
+
+    return fig
+    
+def shorten_model_name(full_name):
+    # Split the name into parts
+    parts = full_name.split('-')
+
+    # Process the name parts to keep only the parts with digits (model sizes and versions)
+    short_name_parts = [part for part in parts if any(char.isdigit() for char in part)]
+
+    if len(parts) == 1:
+        short_name = ''.join(full_name[0:min(3, len(full_name))])
+    else:
+        # Join the parts to form the short name
+        short_name = '-'.join(short_name_parts)
+
+        # Remove any leading or trailing hyphens
+        short_name = full_name[0] + '-'+ short_name.strip('-')
+
+    return short_name
+
+def label_map(model_list: list) -> dict:
+    '''
+    Generate a map from long names to short names, to plot them in frontend graph
+    Define the short names in src/assets/text_content.py
+    Args: 
+        model_list: A list of long model names
+    Returns:
+        short_name: A dict from long to short name
+    '''
+    short_names = {}
+    for model_name in model_list:
+        if model_name in SHORT_NAMES:
+            short_name = SHORT_NAMES[model_name]
+        else:
+            short_name = shorten_model_name(model_name)
+
+        # Define the short name and indicate both models are same
+        short_names[model_name] = short_name
+
+    return short_names
+    
+def split_models(MODEL_LIST: list):
+    '''
+    Split the models into open source and commercial
+    '''
+    open_models = []
+    comm_models = []
+
+    for model in MODEL_LIST:
+        if model.startswith(('gpt-', 'claude-', 'command')):
+            comm_models.append(model)
+        else:
+            open_models.append(model)
+
+    open_models.sort(key=lambda o: o.upper())
+    comm_models.sort(key=lambda c: c.upper())
+    return open_models, comm_models

src/reload.py

@@ -0,0 +1,78 @@
+# Isolated functions to reload the leaderboard data and plot the results
+
+from src.leaderboard_utils import filter_search, get_github_data
+from src.plot_utils import split_models, compare_plots
+
+def get_primary_leaderboard():
+    '''
+    Returns
+        primary_leaderboard_df[0]: Dataframe containing the primary leaderboard (laterst version of the benchmark results)
+    '''
+    print("Initializing Reload...........")
+    
+    primary_leaderboard_df, _, _ = get_github_data()
+    print(primary_leaderboard_df)
+    return primary_leaderboard_df[0]
+
+def get_open_models():
+    '''
+    Returns
+        open_models: Checkbox group containing the open models
+    '''
+    primary_leaderboard_df, _, _ = get_github_data()
+    temp_df = primary_leaderboard_df[0]
+    models = list(temp_df[list(temp_df.columns)[0]].unique())
+    open_models, _ = split_models(models)
+    return open_models
+
+def get_closed_models():
+    '''
+    Returns
+        closed_models: Checkbox group containing the closed models
+    '''
+    primary_leaderboard_df, _, _ = get_github_data()
+    temp_df = primary_leaderboard_df[0]
+    models = list(temp_df[list(temp_df.columns)[0]].unique())
+    _, closed_models = split_models(models)
+    return closed_models
+
+def get_plot_df():      
+        '''
+        Returns
+            plot_df: Dataframe containing the results of latest version for plotting
+        '''
+        primary_leaderboard_df, _, _ = get_github_data()
+        plot_df = primary_leaderboard_df[0]
+        return plot_df
+    
+def get_version_names():
+    '''
+    Returns
+        version_names: List containing the versions of the benchmark results for dropdown selection
+    '''
+    _, _, version_names = get_github_data()
+    return version_names
+    
+def get_version_df():
+    '''
+    Returns
+        version_dfs: Dataframe containing the benchmark results for all versions
+    '''
+    _, version_dfs, _ = get_github_data()
+    return version_dfs
+
+def get_prev_df(name='initial'):
+    '''
+    Returns
+        prev_df: Dataframe containing the benchmark results for the previous versions (default = latest version)
+    '''
+    _, version_dfs, version_names = get_github_data()
+    
+    if name == 'initial':
+        name = version_names[0]
+
+    ind = version_names.index(name)
+    prev_df = version_dfs[ind]
+    return prev_df
+
+

src/reload_utils.py

@@ -0,0 +1,82 @@
+# Isolated functions to reload the leaderboard data and plot the results
+
+from src.leaderboard_utils import filter_search, get_github_data
+from src.plot_utils import split_models, compare_plots
+
+#COMPONENTS TO RELOAD EVERY TIME
+# leaderboard_table, dummy_leaderboard_table, 
+# open_models_selection, closed_models_selection, show_all, show_names, show_legend
+#version_select, prev_table, dummy_prev_table
+
+class ReloadData():
+    '''
+    A class containing methods to reload the leaderboard data and plot the results
+    The methods return individual component values directly to use 'every' arg in the component
+    '''
+
+    def __init__(self):
+        print("Initializing Reload...........")
+        self.primary_leaderboard_df, self.version_dfs, self.version_names = get_github_data()
+        self.plot_df = self.primary_leaderboard_df[0]
+        self.models = list(self.plot_df[list(self.plot_df.columns)[0]].unique())
+        print("Reload completed ....... Here's a reloaded dataframe for latest version")
+        print(self.primary_leaderboard_df)
+
+    def get_primary_leaderboard(self):
+        '''
+        Returns
+            self.primary_leaderboard_df[0]: Dataframe containing the primary leaderboard (laterst version of the benchmark results)
+        '''
+        return self.primary_leaderboard_df[0]
+    
+    def get_open_models(self):
+        '''
+        Returns
+            open_models: Checkbox group containing the open models
+        '''
+        self.open_models, _ = split_models(self.models)
+        return self.open_models
+    
+    def get_closed_models(self):
+        '''
+        Returns
+            closed_models: Checkbox group containing the closed models
+        '''
+        _, self.closed_models = split_models(self.models)
+        return self.closed_models
+    
+    def get_plot_df(self):      
+        '''
+        Returns
+            plot_df: Dataframe containing the results of latest version for plotting
+        '''
+        return self.plot_df
+    
+    def get_version_names(self):
+        '''
+        Returns
+            version_names: List containing the versions of the benchmark results for dropdown selection
+        '''
+        return self.version_names
+        
+    def get_version_df(self):
+        '''
+        Returns
+            version_dfs: Dataframe containing the benchmark results for all versions
+        '''
+        return self.version_dfs
+    
+    def get_prev_df(self, name='initial'):
+        '''
+        Returns
+            prev_df: Dataframe containing the benchmark results for the previous versions (default = latest version)
+        '''
+        if name == 'initial':
+            name = self.version_names[0]
+
+        ind = self.version_names.index(name)
+        self.prev_df = self.version_dfs[ind]
+        return self.prev_df
+
+
+