File size: 11,700 Bytes
0a3530a
6b87e28
bcd77eb
9346f1c
4fc3864
4596a70
2a5f9fb
bcd77eb
60ff46b
2a5f9fb
 
8c49cb6
 
 
0a3530a
8c49cb6
 
 
 
976f398
df66f6e
 
 
 
 
 
 
0a3530a
9d22eee
0a3530a
 
 
 
 
4fc3864
0a3530a
 
 
df66f6e
 
0a3530a
 
8c49cb6
a5d34d3
092c345
a5d34d3
60ff46b
8ff5577
0a3530a
092c345
10f9b3c
2a5f9fb
d084b26
0c7ef71
a5d34d3
 
 
 
 
 
 
 
092c345
a5d34d3
 
 
 
 
 
6b87e28
 
dbb8b5d
a5d34d3
dbb8b5d
6b87e28
 
 
0a3530a
 
 
dbb8b5d
a5d34d3
6b87e28
 
092c345
a5d34d3
 
6b87e28
a5d34d3
6b87e28
092c345
6b87e28
 
 
b7d036c
a5d34d3
 
 
 
0c7ef71
b7d036c
4fc3864
 
 
0a3530a
 
d084b26
b7d036c
 
6b87e28
26286b2
4fc3864
551debe
092c345
0a3530a
 
 
 
 
 
4fc3864
6b87e28
 
 
 
4fc3864
 
 
614ee1f
1f60a20
01233b7
 
58733e4
6e8f400
10f9b3c
8cb7546
613696b
bcd77eb
 
 
 
092c345
bcd77eb
 
 
092c345
 
bcd77eb
 
 
092c345
 
 
3ac217c
092c345
 
 
 
 
 
 
 
 
bcd77eb
 
8b63c4c
092c345
8b63c4c
092c345
4fc3864
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
6b87e28
9d6aecc
6e8f400
9d6aecc
 
2246286
0227006
4ccfada
8dfa543
0227006
8dfa543
6e8f400
00358b1
 
0227006
6e8f400
 
 
a163e5c
b323764
9d22eee
8c49cb6
b323764
2762eff
b323764
 
0227006
6e8f400
12cea14
9d22eee
8c49cb6
12cea14
 
217b585
 
12cea14
9d22eee
8c49cb6
12cea14
 
 
6e8f400
8c49cb6
8cb7546
9d6aecc
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
6e8f400
 
 
 
 
 
 
 
12cea14
 
8c49cb6
6e8f400
 
8cb7546
 
d16cee2
 
 
 
 
67109fc
d16cee2
adb0416
 
d16cee2
092c345
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
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
import os
import logging
import time
import gradio as gr
import datasets
from apscheduler.schedulers.background import BackgroundScheduler
from huggingface_hub import snapshot_download
from gradio_leaderboard import Leaderboard, ColumnFilter, SelectColumns
from gradio_space_ci import enable_space_ci

from src.display.about import (
    CITATION_BUTTON_LABEL,
    CITATION_BUTTON_TEXT,
    EVALUATION_QUEUE_TEXT,
    FAQ_TEXT,
    INTRODUCTION_TEXT,
    LLM_BENCHMARKS_TEXT,
    TITLE,
)
from src.display.css_html_js import custom_css
from src.display.utils import (
    BENCHMARK_COLS,
    COLS,
    EVAL_COLS,
    EVAL_TYPES,
    AutoEvalColumn,
    ModelType,
    Precision,
    WeightType,
    fields,
)
from src.envs import (
    API,
    EVAL_REQUESTS_PATH,
    AGGREGATED_REPO,
    H4_TOKEN,
    QUEUE_REPO,
    REPO_ID,
)
from src.populate import get_evaluation_queue_df, get_leaderboard_df
from src.submission.submit import add_new_eval
from src.tools.plots import create_metric_plot_obj, create_plot_df, create_scores_df

# Configure logging
logging.basicConfig(level=logging.INFO, format="%(asctime)s - %(levelname)s - %(message)s")

# Start ephemeral Spaces on PRs (see config in README.md)
enable_space_ci()


def restart_space():
    API.restart_space(repo_id=REPO_ID, token=H4_TOKEN)


def time_diff_wrapper(func):
    def wrapper(*args, **kwargs):
        start_time = time.time()
        result = func(*args, **kwargs)
        end_time = time.time()
        diff = end_time - start_time
        logging.info(f"Time taken for {func.__name__}: {diff} seconds")
        return result

    return wrapper


@time_diff_wrapper
def download_dataset(repo_id, local_dir, repo_type="dataset", max_attempts=3, backoff_factor=1.5):
    """Download dataset with exponential backoff retries."""
    attempt = 0
    while attempt < max_attempts:
        try:
            logging.info(f"Downloading {repo_id} to {local_dir}")
            snapshot_download(
                repo_id=repo_id,
                local_dir=local_dir,
                repo_type=repo_type,
                tqdm_class=None,
                etag_timeout=30,
                max_workers=8,
            )
            logging.info("Download successful")
            return
        except Exception as e:
            wait_time = backoff_factor**attempt
            logging.error(f"Error downloading {repo_id}: {e}, retrying in {wait_time}s")
            time.sleep(wait_time)
            attempt += 1
    raise Exception(f"Failed to download {repo_id} after {max_attempts} attempts")


def init_space(full_init: bool = True):
    """Initializes the application space, loading only necessary data."""
    if full_init:
        # These downloads only occur on full initialization
        try:
            download_dataset(QUEUE_REPO, EVAL_REQUESTS_PATH)
        except Exception:
            restart_space()

    # Always retrieve the leaderboard DataFrame
    leaderboard_dataset = datasets.load_dataset(AGGREGATED_REPO, "default", split="train")
    leaderboard_df = get_leaderboard_df(
        leaderboard_dataset=leaderboard_dataset, 
        cols=COLS,
        benchmark_cols=BENCHMARK_COLS,
    )

    # Evaluation queue DataFrame retrieval is independent of initialization detail level
    eval_queue_dfs = get_evaluation_queue_df(EVAL_REQUESTS_PATH, EVAL_COLS)

    return leaderboard_df, eval_queue_dfs


# Convert the environment variable "LEADERBOARD_FULL_INIT" to a boolean value, defaulting to True if the variable is not set.
# This controls whether a full initialization should be performed.
do_full_init = os.getenv("LEADERBOARD_FULL_INIT", "True") == "True"

# Calls the init_space function with the `full_init` parameter determined by the `do_full_init` variable.
# This initializes various DataFrames used throughout the application, with the level of initialization detail controlled by the `do_full_init` flag.
leaderboard_df, eval_queue_dfs = init_space(full_init=do_full_init)
finished_eval_queue_df, running_eval_queue_df, pending_eval_queue_df = eval_queue_dfs


# Data processing for plots now only on demand in the respective Gradio tab
#def load_and_create_plots():
#    plot_df = create_plot_df(create_scores_df(leaderboard_df))
#    return plot_df


demo = gr.Blocks(css=custom_css)
with demo:
    gr.HTML(TITLE)
    gr.Markdown(INTRODUCTION_TEXT, elem_classes="markdown-text")

    with gr.Tabs(elem_classes="tab-buttons") as tabs:
        with gr.TabItem("πŸ… LLM Benchmark", elem_id="llm-benchmark-tab-table", id=0):
            leaderboard = Leaderboard(
                value=leaderboard_df,
                datatype=[c.type for c in fields(AutoEvalColumn)],
                select_columns=SelectColumns(
                    default_selection=[c.name for c in fields(AutoEvalColumn) if c.displayed_by_default],
                    cant_deselect=[c.name for c in fields(AutoEvalColumn) if c.never_hidden or c.dummy],
                    label="Select Columns to Display:",
                ),
                search_columns=[AutoEvalColumn.model.name, AutoEvalColumn.fullname.name, AutoEvalColumn.license.name],
                hide_columns=[c.name for c in fields(AutoEvalColumn) if c.hidden],
                filter_columns=[
                    ColumnFilter(AutoEvalColumn.model_type.name, type="checkboxgroup", label="Model types"),
                    ColumnFilter(AutoEvalColumn.precision.name, type="checkboxgroup", label="Precision"),
                    ColumnFilter(
                        AutoEvalColumn.params.name,
                        type="slider",
                        min=0.01,
                        max=150,
                        label="Select the number of parameters (B)",
                    ),
                    ColumnFilter(
                        AutoEvalColumn.still_on_hub.name, type="boolean", label="Private or deleted", default=True
                    ),
                    ColumnFilter(
                        AutoEvalColumn.merged.name, type="boolean", label="Contains a merge/moerge", default=True
                    ),
                    ColumnFilter(AutoEvalColumn.moe.name, type="boolean", label="MoE", default=False),
                    ColumnFilter(AutoEvalColumn.not_flagged.name, type="boolean", label="Flagged", default=True),
                ],
                bool_checkboxgroup_label="Hide models",
            )

        #with gr.TabItem("πŸ“ˆ Metrics through time", elem_id="llm-benchmark-tab-table", id=2):
        #    with gr.Row():
        #        with gr.Column():
        #            plot_df = load_and_create_plots()
        #            chart = create_metric_plot_obj(
        #                plot_df,
        #                [AutoEvalColumn.average.name],
        #                title="Average of Top Scores and Human Baseline Over Time (from last update)",
        #            )
        #            gr.Plot(value=chart, min_width=500)
        #        with gr.Column():
        #            plot_df = load_and_create_plots()
        #            chart = create_metric_plot_obj(
        #                plot_df,
        #                BENCHMARK_COLS,
        #                title="Top Scores and Human Baseline Over Time (from last update)",
        #            )
        #            gr.Plot(value=chart, min_width=500)

        with gr.TabItem("πŸ“ About", elem_id="llm-benchmark-tab-table", id=3):
            gr.Markdown(LLM_BENCHMARKS_TEXT, elem_classes="markdown-text")

        with gr.TabItem("❗FAQ", elem_id="llm-benchmark-tab-table", id=4):
            gr.Markdown(FAQ_TEXT, elem_classes="markdown-text")

        with gr.TabItem("πŸš€ Submit ", elem_id="llm-benchmark-tab-table", id=5):
            with gr.Column():
                with gr.Row():
                    gr.Markdown(EVALUATION_QUEUE_TEXT, elem_classes="markdown-text")

            with gr.Row():
                gr.Markdown("# βœ‰οΈβœ¨ Submit your model here!", elem_classes="markdown-text")

            with gr.Row():
                with gr.Column():
                    model_name_textbox = gr.Textbox(label="Model name")
                    revision_name_textbox = gr.Textbox(label="Revision commit", placeholder="main")
                    model_type = gr.Dropdown(
                        choices=[t.to_str(" : ") for t in ModelType if t != ModelType.Unknown],
                        label="Model type",
                        multiselect=False,
                        value=ModelType.FT.to_str(" : "),
                        interactive=True,
                    )

                with gr.Column():
                    precision = gr.Dropdown(
                        choices=[i.value.name for i in Precision if i != Precision.Unknown],
                        label="Precision",
                        multiselect=False,
                        value="float16",
                        interactive=True,
                    )
                    weight_type = gr.Dropdown(
                        choices=[i.value.name for i in WeightType],
                        label="Weights type",
                        multiselect=False,
                        value="Original",
                        interactive=True,
                    )
                    base_model_name_textbox = gr.Textbox(label="Base model (for delta or adapter weights)")

            with gr.Column():
                with gr.Accordion(
                    f"βœ… Finished Evaluations ({len(finished_eval_queue_df)})",
                    open=False,
                ):
                    with gr.Row():
                        finished_eval_table = gr.components.Dataframe(
                            value=finished_eval_queue_df,
                            headers=EVAL_COLS,
                            datatype=EVAL_TYPES,
                            row_count=5,
                        )
                with gr.Accordion(
                    f"πŸ”„ Running Evaluation Queue ({len(running_eval_queue_df)})",
                    open=False,
                ):
                    with gr.Row():
                        running_eval_table = gr.components.Dataframe(
                            value=running_eval_queue_df,
                            headers=EVAL_COLS,
                            datatype=EVAL_TYPES,
                            row_count=5,
                        )

                with gr.Accordion(
                    f"⏳ Pending Evaluation Queue ({len(pending_eval_queue_df)})",
                    open=False,
                ):
                    with gr.Row():
                        pending_eval_table = gr.components.Dataframe(
                            value=pending_eval_queue_df,
                            headers=EVAL_COLS,
                            datatype=EVAL_TYPES,
                            row_count=5,
                        )

            submit_button = gr.Button("Submit Eval")
            submission_result = gr.Markdown()
            submit_button.click(
                add_new_eval,
                [
                    model_name_textbox,
                    base_model_name_textbox,
                    revision_name_textbox,
                    precision,
                    weight_type,
                    model_type,
                ],
                submission_result,
            )

    with gr.Row():
        with gr.Accordion("πŸ“™ Citation", open=False):
            citation_button = gr.Textbox(
                value=CITATION_BUTTON_TEXT,
                label=CITATION_BUTTON_LABEL,
                lines=20,
                elem_id="citation-button",
                show_copy_button=True,
            )

demo.queue(default_concurrency_limit=40).launch()