File size: 5,261 Bytes
068a50e
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
# some code blocks are taken from https://huggingface.co/spaces/HuggingFaceH4/open_llm_leaderboard/tree/main
import json
import os
from datetime import datetime, timezone

import gradio as gr
import pandas as pd

from src.css_html import custom_css
from src.text_content import ABOUT_TEXT, SUBMISSION_TEXT_3
from src.utils import (
    AutoEvalColumn,
    fields,
    is_model_on_hub,
    make_clickable_names,
)

df = pd.read_csv("data/code_eval_board.csv")

COLS = [c.name for c in fields(AutoEvalColumn) if not c.hidden]
TYPES = [c.type for c in fields(AutoEvalColumn) if not c.hidden]
COLS_LITE = [
    c.name for c in fields(AutoEvalColumn) if c.displayed_by_default and not c.hidden
]
TYPES_LITE = [
    c.type for c in fields(AutoEvalColumn) if c.displayed_by_default and not c.hidden
]


def select_columns(df, columns):
    always_here_cols = [
        AutoEvalColumn.model.name,
    ]
    # We use COLS to maintain sorting
    filtered_df = df[
        always_here_cols + [c for c in COLS if c in df.columns and c in columns]
    ]
    return filtered_df


def filter_items(df, leaderboard_table, query):
    if query == "all":
        return df[leaderboard_table.columns]
    else:
        query = query[0]
    filtered_df = df[df["T"].str.contains(query, na=False)]
    return filtered_df[leaderboard_table.columns]


def search_table(df, leaderboard_table, query):
    filtered_df = df[(df["Model"].str.contains(query, case=False))]
    return filtered_df[leaderboard_table.columns]


df = make_clickable_names(df)

demo = gr.Blocks(css=custom_css)
with demo:
    with gr.Row():
        gr.Markdown(
            """<div style="text-align: center;"><h1> ESPnet-EZ Leaderboard for LibriSpeech-100h ASR1</span></h1></div>\
            <br>\
            <p>Users can use <code>reproduce</code> function to reproduce the numbers in ESPnet-EZ!</p>
""",
            elem_classes="markdown-text",
        )

    with gr.Tabs(elem_classes="tab-buttons") as tabs:
        with gr.TabItem("πŸ” Evaluation table", id=0):
            with gr.Accordion("➑️ See All Columns", open=False):
                shown_columns = gr.CheckboxGroup(
                    choices=[
                        c
                        for c in COLS
                        if c
                        not in [
                            # AutoEvalColumn.dummy.name,
                            AutoEvalColumn.model.name,
                        ]
                    ],
                    value=[
                        c
                        for c in COLS_LITE
                        if c
                        not in [
                            # AutoEvalColumn.dummy.name,
                            AutoEvalColumn.model.name,
                        ]
                    ],
                    label="",
                    elem_id="column-select",
                    interactive=True,
                )
            # with gr.Column(min_width=780):
            with gr.Row():
                search_bar = gr.Textbox(
                    placeholder="πŸ” Search for your model and press ENTER...",
                    show_label=False,
                    elem_id="search-bar",
                )
            leaderboard_df = gr.components.Dataframe(
                value=df[
                    [
                        AutoEvalColumn.model.name,
                    ]
                    + shown_columns.value
                ],
                headers=[
                    AutoEvalColumn.model.name,
                ]
                + shown_columns.value,
                datatype=TYPES,
                elem_id="leaderboard-table",
                interactive=False,
            )

            hidden_leaderboard_df = gr.components.Dataframe(
                value=df,
                headers=COLS,
                datatype=["str" for _ in range(len(COLS))],
                visible=False,
            )
            search_bar.submit(
                search_table,
                [hidden_leaderboard_df, leaderboard_df, search_bar],
                leaderboard_df,
            )
            shown_columns.change(
                select_columns,
                [hidden_leaderboard_df, shown_columns],
                leaderboard_df,
            )
            gr.Markdown(
                """
            **Notes:**
            - Win Rate represents how often a model outperforms other models in each language, averaged across all languages.
            - The scores of instruction-tuned models might be significantly higher on humaneval-python than other languages. We use the instruction format of HumanEval. For other languages, we use base MultiPL-E prompts.
            - For more details check the πŸ“ About section.
            - Models with a πŸ”΄ symbol represent external evaluation submission, this means that we didn't verify the results, you can find the author's submission under `Submission PR` field from `See All Columns` tab.
            """,
                elem_classes="markdown-text",
            )

        with gr.TabItem("πŸ“ About", id=2):
            gr.Markdown(ABOUT_TEXT, elem_classes="markdown-text")

        with gr.TabItem("Submit results πŸš€", id=3):
            gr.Markdown(SUBMISSION_TEXT_3)


demo.launch()