Update app.py

app.py

@@ -1,253 +1,191 @@
-import gradio as gr
+import os, glob
+import json
+from datetime import datetime, timezone
+from dataclasses import dataclass
+from datasets import load_dataset, Dataset
 import pandas as pd
-import os
-import zipfile
-import base64
+import gradio as gr
+from huggingface_hub import HfApi, snapshot_download, ModelInfo, list_models
+from enum import Enum
+
+OWNER = "AIEnergyScore"
+COMPUTE_SPACE = f"{OWNER}/launch-computation-example"
+TOKEN = os.environ.get("DEBUG")
+API = HfApi(token=TOKEN)
+
+task_mappings = {
+    'automatic speech recognition': 'automatic-speech-recognition',
+    'Object Detection': 'object-detection',
+    'Text Classification': 'text-classification',
+    'Image to Text': 'image-to-text',
+    'Question Answering': 'question-answering',
+    'Text Generation': 'text-generation',
+    'Image Classification': 'image-classification',
+    'Sentence Similarity': 'sentence-similarity',
+    'Image Generation': 'image-generation',
+    'Summarization': 'summarization'
+}
 
-CITATION_BUTTON_LABEL = "Copy the following snippet to cite these results"
-CITATION_BUTTON_TEXT = r"""@misc{aienergyscore-leaderboard,
-    author = {Sasha Luccioni and Boris Gamazaychikov and Emma Strubell and Sara Hooker and Yacine Jernite and Carole-Jean Wu and Margaret Mitchell},
-    title = {AI Energy Score Leaderboard - February 2025},
-    year = {2025},
-    publisher = {Hugging Face},
-    howpublished = "\url{https://huggingface.co/spaces/AIEnergyScore/Leaderboard}",
-}"""
+@dataclass
+class ModelDetails:
+    name: str
+    display_name: str = ""
+    symbol: str = ""  # emoji
 
-# List of tasks (CSV filenames)
-tasks = [
-    'asr.csv',
-    'object_detection.csv',
-    'text_classification.csv',
-    'image_captioning.csv',
-    'question_answering.csv',
-    'text_generation.csv',
-    'image_classification.csv',
-    'sentence_similarity.csv',
-    'image_generation.csv',
-    'summarization.csv'
-]
+def start_compute_space():
+    API.restart_space(COMPUTE_SPACE)
+    gr.Info(f"Okay! {COMPUTE_SPACE} should be running now!")
 
-def format_stars(score):
+def get_model_size(model_info: ModelInfo):
+    """Gets the model size from the configuration, or the model name if the configuration does not contain the information."""
     try:
-        score_int = int(score)
-    except Exception:
-        score_int = 0
-    # Render stars in black with a slightly larger font.
-    return f'<span style="color: black; font-size:1.5em;">{"★" * score_int}</span>'
-
-def make_link(mname):
-    parts = str(mname).split('/')
-    display_name = parts[1] if len(parts) > 1 else mname
-    return f'<a href="https://huggingface.co/{mname}" target="_blank">{display_name}</a>'
-
-def extract_link_text(html_link):
-    """Extracts the inner text from an HTML link."""
-    start = html_link.find('>') + 1
-    end = html_link.rfind('</a>')
-    if start > 0 and end > start:
-        return html_link[start:end]
+        model_size = round(model_info.safetensors["total"] / 1e9, 3)
+    except (AttributeError, TypeError):
+        return 0  # Unknown model sizes are indicated as 0
+    return model_size
+
+def add_docker_eval(zip_file):
+    new_fid_list = zip_file.split("/")
+    new_fid = new_fid_list[-1]
+    if new_fid.endswith('.zip'):
+        API.upload_file(
+            path_or_fileobj=zip_file,
+            repo_id="AIEnergyScore/tested_proprietary_models",
+            path_in_repo='submitted_models/' + new_fid,
+            repo_type="dataset",
+            commit_message="Adding logs via submission Space.",
+            token=TOKEN
+        )
+        gr.Info('Uploaded logs to dataset! We will validate their validity and add them to the next version of the leaderboard.')
     else:
-        return html_link
-
-def generate_html_table_from_df(df):
-    """
-    Given a dataframe with a numeric energy column (gpu_energy_numeric),
-    generate an HTML table with three columns:
-      - Model (the link, with a fixed width based on the longest model name)
-      - GPU Energy (Wh) plus a horizontal bar whose width is proportional
-        to the energy value relative to the maximum in the table.
-      - Score (displayed as stars)
-    """
-    # Compute a static width (in pixels) for the Model column based on the longest model name.
-    if not df.empty:
-        max_length = max(len(extract_link_text(link)) for link in df['Model'])
+        gr.Info('You can only upload .zip files here!')
+
+def add_new_eval(repo_id: str, task: str):
+    model_owner = repo_id.split("/")[0]
+    model_name = repo_id.split("/")[1]
+    current_time = datetime.now(timezone.utc).strftime("%Y-%m-%dT%H:%M:%SZ")
+    requests = load_dataset("AIEnergyScore/requests_debug", split="test", token=TOKEN)
+    requests_dset = requests.to_pandas()
+    model_list = requests_dset[requests_dset['status'] == 'COMPLETED']['model'].tolist()
+    task_models = list(API.list_models(filter=task_mappings[task]))
+    task_model_names = [m.id for m in task_models]
+    if repo_id in model_list:
+        gr.Info('This model has already been run!')
+    elif repo_id not in task_model_names:
+        gr.Info("This model isn't compatible with the chosen task! Pick a different model-task combination")
     else:
-        max_length = 10
-    # Multiply by an estimated average character width (10 pixels) and add some extra padding.
-    static_width = max_length * 10 + 16
-
-    max_energy = df['gpu_energy_numeric'].max() if not df.empty else 1
-    color_map = {"1": "black", "2": "black", "3": "black", "4": "black", "5": "black"}
-    html = '<table style="width:100%; border-collapse: collapse; font-family: Inter, sans-serif;">'
-    # Keep only one header (the one with hover text)
-    html += '<thead><tr style="background-color: #f2f2f2;">'
-    html += '<th style="text-align: left; padding: 8px;" title="Model name with link to Hugging Face">Model</th>'
-    html += '<th style="text-align: left; padding: 8px;" title="GPU energy consumed in Watt-hours for 1,000 queries">GPU Energy (Wh)</th>'
-    html += '<th style="text-align: left; padding: 8px;" title="5 is most efficient, 1 is least. Relative energy efficiency score relative to other models in task/class at the time of leaderboard launch">Score</th>'
-    html += '</tr></thead>'
-    html += '<tbody>'
-    for _, row in df.iterrows():
-        energy_numeric = row['gpu_energy_numeric']
-        energy_str = f"{energy_numeric:.2f}"
-        # Compute the relative width (as a percentage)
-        bar_width = (energy_numeric / max_energy) * 100
-        score_val = row['energy_score']
-        bar_color = color_map.get(str(score_val), "gray")
-        html += '<tr>'
-        html += f'<td style="padding: 8px; width: {static_width}px;">{row["Model"]}</td>'
-        html += (
-            f'<td style="padding: 8px;">{energy_str}<br>'
-            f'<div style="background-color: {bar_color}; width: {bar_width:.1f}%; height: 10px;"></div></td>'
-        )
-        html += f'<td style="padding: 8px;">{row["Score"]}</td>'
-        html += '</tr>'
-    html += '</tbody></table>'
-    return html
-
-# --- Function to zip all CSV files ---
-def zip_csv_files():
-    data_dir = "data/energy"
-    zip_filename = "data.zip"
-    with zipfile.ZipFile(zip_filename, "w", zipfile.ZIP_DEFLATED) as zipf:
-        for filename in os.listdir(data_dir):
-            if filename.endswith(".csv"):
-                filepath = os.path.join(data_dir, filename)
-                zipf.write(filepath, arcname=filename)
-    return zip_filename
+        try:
+            model_info = API.model_info(repo_id=repo_id)
+            model_size = get_model_size(model_info=model_info)
+            likes = model_info.likes
+        except Exception:
+            gr.Info("Could not find information for model %s" % (model_name))
+            model_size = None
+            likes = None
+
+        gr.Info("Adding request")
+        request_dict = {
+            "model": repo_id,
+            "status": "PENDING",
+            "submitted_time": pd.to_datetime(current_time),
+            "task": task_mappings[task],
+            "likes": likes,
+            "params": model_size,
+            "leaderboard_version": "v0",
+        }
+        print("Writing out request file to dataset")
+        df_request_dict = pd.DataFrame([request_dict])
+        print(df_request_dict)
+        df_final = pd.concat([requests_dset, df_request_dict], ignore_index=True)
+        updated_dset = Dataset.from_pandas(df_final)
+        updated_dset.push_to_hub("AIEnergyScore/requests_debug", split="test", token=TOKEN)
+        gr.Info("Starting compute space at %s " % COMPUTE_SPACE)
+        return start_compute_space()
+
+def print_existing_models():
+    requests = load_dataset("AIEnergyScore/requests_debug", split="test", token=TOKEN)
+    requests_dset = requests.to_pandas()
+    model_df = requests_dset[['model', 'status']]
+    model_df = model_df[model_df['status'] == 'COMPLETED']
+    return model_df
+
+def highlight_cols(x):
+    df = x.copy()
+    df[df['status'] == 'COMPLETED'] = 'color: green'
+    df[df['status'] == 'PENDING'] = 'color: orange'
+    df[df['status'] == 'FAILED'] = 'color: red'
+    return df
+
+# Applying the style function for the table
+existing_models = print_existing_models()
+formatted_df = existing_models.style.apply(highlight_cols, axis=None)
+
+def get_leaderboard_models():
+    path = r'leaderboard_v0_data/energy'
+    filenames = glob.glob(path + "/*.csv")
+    data = []
+    for filename in filenames:
+        data.append(pd.read_csv(filename))
+    leaderboard_data = pd.concat(data, ignore_index=True)
+    return leaderboard_data[['model', 'task']]
 
 def get_zip_data_link():
-    """Creates a data URI download link for the ZIP file."""
-    zip_filename = zip_csv_files()
-    with open(zip_filename, "rb") as f:
-        data = f.read()
-    b64 = base64.b64encode(data).decode()
-    href = (
-        f'<a href="data:application/zip;base64,{b64}" '
-        'download="data.zip" '
-        'style="margin: 0 15px; text-decoration: none; font-weight: bold; font-size: 1.1em; '
-        'color: black; font-family: \'Inter\', sans-serif;">Download Data</a>'
+    return (
+        '<a href="https://example.com/download.zip" '
+        'style="text-decoration: none; font-weight: bold; font-size: 1.1em; '
+        'color: black; font-family: \'Inter\', sans-serif;">Download Logs</a>'
     )
-    return href
-
-# --- Modified functions to include a sort_order parameter ---
-def get_model_names_html(task, sort_order="Low to High"):
-    df = pd.read_csv('data/energy/' + task)
-    if df.columns[0].startswith("Unnamed:"):
-        df = df.iloc[:, 1:]
-    df['energy_score'] = df['energy_score'].astype(int)
-    # Convert kWh to Wh:
-    df['gpu_energy_numeric'] = pd.to_numeric(df['total_gpu_energy'], errors='raise') * 1000
-    df['Model'] = df['model'].apply(make_link)
-    df['Score'] = df['energy_score'].apply(format_stars)
-    ascending = True if sort_order == "Low to High" else False
-    df = df.sort_values(by='gpu_energy_numeric', ascending=ascending)
-    return generate_html_table_from_df(df)
-
-def get_all_model_names_html(sort_order="Low to High"):
-    all_df = pd.DataFrame()
-    for task in tasks:
-        df = pd.read_csv('data/energy/' + task)
-        if df.columns[0].startswith("Unnamed:"):
-            df = df.iloc[:, 1:]
-        df['energy_score'] = df['energy_score'].astype(int)
-        df['gpu_energy_numeric'] = pd.to_numeric(df['total_gpu_energy'], errors='raise') * 1000
-        df['Model'] = df['model'].apply(make_link)
-        df['Score'] = df['energy_score'].apply(format_stars)
-        all_df = pd.concat([all_df, df], ignore_index=True)
-    all_df = all_df.drop_duplicates(subset=['model'])
-    ascending = True if sort_order == "Low to High" else False
-    all_df = all_df.sort_values(by='gpu_energy_numeric', ascending=ascending)
-    return generate_html_table_from_df(all_df)
-
-def get_text_generation_model_names_html(model_class, sort_order="Low to High"):
-    df = pd.read_csv('data/energy/text_generation.csv')
-    if df.columns[0].startswith("Unnamed:"):
-        df = df.iloc[:, 1:]
-    if 'class' in df.columns:
-        df = df[df['class'] == model_class]
-    df['energy_score'] = df['energy_score'].astype(int)
-    df['gpu_energy_numeric'] = pd.to_numeric(df['total_gpu_energy'], errors='raise') * 1000
-    df['Model'] = df['model'].apply(make_link)
-    df['Score'] = df['energy_score'].apply(format_stars)
-    ascending = True if sort_order == "Low to High" else False
-    df = df.sort_values(by='gpu_energy_numeric', ascending=ascending)
-    return generate_html_table_from_df(df)
-
-# --- Update functions for dropdown changes ---
-
-# For Text Generation, two dropdowns: model class and sort order.
-def update_text_generation(selected_display, sort_order):
-    mapping = {
-        "A (Single Consumer GPU) <20B parameters": "A",
-        "B (Single Cloud GPU) 20-66B parameters": "B",
-        "C (Multiple Cloud GPUs) >66B parameters": "C"
-    }
-    model_class = mapping.get(selected_display, "A")
-    return get_text_generation_model_names_html(model_class, sort_order)
-
-# For the other tabs, each update function simply takes the sort_order.
-def update_image_generation(sort_order):
-    return get_model_names_html('image_generation.csv', sort_order)
-
-def update_text_classification(sort_order):
-    return get_model_names_html('text_classification.csv', sort_order)
-
-def update_image_classification(sort_order):
-    return get_model_names_html('image_classification.csv', sort_order)
-
-def update_image_captioning(sort_order):
-    return get_model_names_html('image_captioning.csv', sort_order)
-
-def update_summarization(sort_order):
-    return get_model_names_html('summarization.csv', sort_order)
-
-def update_asr(sort_order):
-    return get_model_names_html('asr.csv', sort_order)
-
-def update_object_detection(sort_order):
-    return get_model_names_html('object_detection.csv', sort_order)
 
-def update_sentence_similarity(sort_order):
-    return get_model_names_html('sentence_similarity.csv', sort_order)
-
-def update_extractive_qa(sort_order):
-    return get_model_names_html('question_answering.csv', sort_order)
-
-def update_all_tasks(sort_order):
-    return get_all_model_names_html(sort_order)
-
-# --- Build the Gradio Interface ---
-
-demo = gr.Blocks(css="""
-.gr-dataframe table {
-    table-layout: fixed;
-    width: 100%;
-}
-.gr-dataframe th, .gr-dataframe td {
-    max-width: 150px;
-    white-space: nowrap;
-    overflow: hidden;
-    text-overflow: ellipsis;
-}
-""")
+with gr.Blocks() as demo:
+    # --- Custom CSS for layout and styling ---
+    gr.HTML('''
+    <style>
+      /* Evenly space the header links */
+      .header-links {
+          display: flex;
+          justify-content: space-evenly;
+          align-items: center;
+          margin: 10px 0;
+      }
+      /* Center the subtitle text */
+      .centered-subtitle {
+          text-align: center;
+          font-size: 1.2em;
+          margin-bottom: 20px;
+      }
+      /* Full width container for matching widget edges */
+      .full-width {
+          width: 100% !important;
+      }
+    </style>
+    ''')
 
-with demo:
     # --- Header Links (at the very top) ---
-    with gr.Row():
+    with gr.Row(elem_classes="header-links"):
         submission_link = gr.HTML(
             '<a href="https://huggingface.co/spaces/AIEnergyScore/submission_portal" '
-            'style="margin: 0 10px; text-decoration: none; font-weight: bold; font-size: 1.1em; '
+            'style="text-decoration: none; font-weight: bold; font-size: 1.1em; '
             'color: black; font-family: \'Inter\', sans-serif;">Submission Portal</a>'
         )
         label_link = gr.HTML(
             '<a href="https://huggingface.co/spaces/AIEnergyScore/Label" '
-            'style="margin: 0 10px; text-decoration: none; font-weight: bold; font-size: 1.1em; '
+            'style="text-decoration: none; font-weight: bold; font-size: 1.1em; '
             'color: black; font-family: \'Inter\', sans-serif;">Label Generator</a>'
         )
         faq_link = gr.HTML(
             '<a href="https://huggingface.github.io/AIEnergyScore/#faq" '
-            'style="margin: 0 10px; text-decoration: none; font-weight: bold; font-size: 1.1em; '
+            'style="text-decoration: none; font-weight: bold; font-size: 1.1em; '
             'color: black; font-family: \'Inter\', sans-serif;">FAQ</a>'
         )
         documentation_link = gr.HTML(
             '<a href="https://huggingface.github.io/AIEnergyScore/#documentation" '
-            'style="margin: 0 10px; text-decoration: none; font-weight: bold; font-size: 1.1em; '
+            'style="text-decoration: none; font-weight: bold; font-size: 1.1em; '
             'color: black; font-family: \'Inter\', sans-serif;">Documentation</a>'
         )
         download_link = gr.HTML(get_zip_data_link())
         community_link = gr.HTML(
             '<a href="https://huggingface.co/spaces/AIEnergyScore/README/discussions" '
-            'style="margin: 0 10px; text-decoration: none; font-weight: bold; font-size: 1.1em; '
+            'style="text-decoration: none; font-weight: bold; font-size: 1.1em; '
             'color: black; font-family: \'Inter\', sans-serif;">Community</a>'
         )
     
@@ -256,147 +194,56 @@ with demo:
     <div style="margin-top: 0px;">
         <img src="https://huggingface.co/spaces/AIEnergyScore/Leaderboard/resolve/main/logo.png" 
              alt="Logo" 
-             style="display: block; margin: 0 auto; max-width: 500px; height: auto;">
+             style="display: block; margin: 0 auto; max-width: 400px; height: auto;">
     </div>
     ''')
 
-
     # --- Subtitle (centered) ---
-    gr.Markdown('<p style="text-align: center;">Welcome to the <a href="https://huggingface.co/AIEnergyScore">AI Energy Score</a> Leaderboard. Select the task to see scored model results.</p>')
-    
-    # --- Tabs for the different tasks ---
-    with gr.Tabs():
-        # --- Text Generation Tab ---
-        with gr.TabItem("Text Generation 💬"):
-            with gr.Row():
-                model_class_options = [
-                    "A (Single Consumer GPU) <20B parameters",
-                    "B (Single Cloud GPU) 20-66B parameters",
-                    "C (Multiple Cloud GPUs) >66B parameters"
-                ]
-                model_class_dropdown = gr.Dropdown(
-                    choices=model_class_options,
-                    label="Select Model Class",
-                    value=model_class_options[0]
-                )
-                sort_dropdown_tg = gr.Dropdown(
-                    choices=["Low to High", "High to Low"],
-                    label="Sort",
-                    value="Low to High"
+    gr.Markdown('<p class="centered-subtitle">Welcome to the AI Energy Score Leaderboard. Select the task to see scored model results.</p>')
+
+    # --- Main UI Container (ensuring matching edges) ---
+    with gr.Column(elem_classes="full-width"):
+        with gr.Row():
+            with gr.Column():
+                task = gr.Dropdown(
+                    choices=list(task_mappings.keys()),
+                    label="Choose a benchmark task",
+                    value='Text Generation',
+                    multiselect=False,
+                    interactive=True,
                 )
-            tg_table = gr.HTML(get_text_generation_model_names_html("A", "Low to High"))
-            # When either dropdown changes, update the table.
-            model_class_dropdown.change(fn=update_text_generation, inputs=[model_class_dropdown, sort_dropdown_tg], outputs=tg_table)
-            sort_dropdown_tg.change(fn=update_text_generation, inputs=[model_class_dropdown, sort_dropdown_tg], outputs=tg_table)
+            with gr.Column():
+                model_name_textbox = gr.Textbox(label="Model name (user_name/model_name)")
         
-        # --- Image Generation Tab ---
-        with gr.TabItem("Image Generation 📷"):
-            sort_dropdown_img = gr.Dropdown(
-                choices=["Low to High", "High to Low"],
-                label="Sort",
-                value="Low to High"
-            )
-            img_table = gr.HTML(get_model_names_html('image_generation.csv', "Low to High"))
-            sort_dropdown_img.change(fn=update_image_generation, inputs=sort_dropdown_img, outputs=img_table)
-        
-        # --- Text Classification Tab ---
-        with gr.TabItem("Text Classification 🎭"):
-            sort_dropdown_tc = gr.Dropdown(
-                choices=["Low to High", "High to Low"],
-                label="Sort",
-                value="Low to High"
-            )
-            tc_table = gr.HTML(get_model_names_html('text_classification.csv', "Low to High"))
-            sort_dropdown_tc.change(fn=update_text_classification, inputs=sort_dropdown_tc, outputs=tc_table)
-        
-        # --- Image Classification Tab ---
-        with gr.TabItem("Image Classification 🖼️"):
-            sort_dropdown_ic = gr.Dropdown(
-                choices=["Low to High", "High to Low"],
-                label="Sort",
-                value="Low to High"
-            )
-            ic_table = gr.HTML(get_model_names_html('image_classification.csv', "Low to High"))
-            sort_dropdown_ic.change(fn=update_image_classification, inputs=sort_dropdown_ic, outputs=ic_table)
-        
-        # --- Image Captioning Tab ---
-        with gr.TabItem("Image Captioning 📝"):
-            sort_dropdown_icap = gr.Dropdown(
-                choices=["Low to High", "High to Low"],
-                label="Sort",
-                value="Low to High"
-            )
-            icap_table = gr.HTML(get_model_names_html('image_captioning.csv', "Low to High"))
-            sort_dropdown_icap.change(fn=update_image_captioning, inputs=sort_dropdown_icap, outputs=icap_table)
-        
-        # --- Summarization Tab ---
-        with gr.TabItem("Summarization 📃"):
-            sort_dropdown_sum = gr.Dropdown(
-                choices=["Low to High", "High to Low"],
-                label="Sort",
-                value="Low to High"
-            )
-            sum_table = gr.HTML(get_model_names_html('summarization.csv', "Low to High"))
-            sort_dropdown_sum.change(fn=update_summarization, inputs=sort_dropdown_sum, outputs=sum_table)
-        
-        # --- Automatic Speech Recognition Tab ---
-        with gr.TabItem("Automatic Speech Recognition 💬"):
-            sort_dropdown_asr = gr.Dropdown(
-                choices=["Low to High", "High to Low"],
-                label="Sort",
-                value="Low to High"
-            )
-            asr_table = gr.HTML(get_model_names_html('asr.csv', "Low to High"))
-            sort_dropdown_asr.change(fn=update_asr, inputs=sort_dropdown_asr, outputs=asr_table)
-        
-        # --- Object Detection Tab ---
-        with gr.TabItem("Object Detection 🚘"):
-            sort_dropdown_od = gr.Dropdown(
-                choices=["Low to High", "High to Low"],
-                label="Sort",
-                value="Low to High"
-            )
-            od_table = gr.HTML(get_model_names_html('object_detection.csv', "Low to High"))
-            sort_dropdown_od.change(fn=update_object_detection, inputs=sort_dropdown_od, outputs=od_table)
-        
-        # --- Sentence Similarity Tab ---
-        with gr.TabItem("Sentence Similarity 📚"):
-            sort_dropdown_ss = gr.Dropdown(
-                choices=["Low to High", "High to Low"],
-                label="Sort",
-                value="Low to High"
-            )
-            ss_table = gr.HTML(get_model_names_html('sentence_similarity.csv', "Low to High"))
-            sort_dropdown_ss.change(fn=update_sentence_similarity, inputs=sort_dropdown_ss, outputs=ss_table)
+        with gr.Row():
+            with gr.Column():
+                submit_button = gr.Button("Submit for Analysis")
+                submission_result = gr.Markdown()
+                submit_button.click(
+                    fn=add_new_eval,
+                    inputs=[model_name_textbox, task],
+                    outputs=submission_result,
+                )
         
-        # --- Extractive QA Tab ---
-        with gr.TabItem("Extractive QA ❔"):
-            sort_dropdown_qa = gr.Dropdown(
-                choices=["Low to High", "High to Low"],
-                label="Sort",
-                value="Low to High"
-            )
-            qa_table = gr.HTML(get_model_names_html('question_answering.csv', "Low to High"))
-            sort_dropdown_qa.change(fn=update_extractive_qa, inputs=sort_dropdown_qa, outputs=qa_table)
+        # --- Docker Log Submission (Simplified) ---
+        with gr.Accordion("Submit log files from a Docker run:", open=False):
+            gr.Markdown("""
+            **⚠️ Warning: By uploading the zip file, you confirm that you have read and agree to the following terms:**
+
+            - **Public Data Sharing:** You consent to the public sharing of the energy performance data derived from your submission. No additional information related to this model, including proprietary configurations, will be disclosed.
+            - **Data Integrity:** You certify that the log files submitted are accurate, unaltered, and generated directly from testing your model as per the specified benchmarking procedures.
+            - **Model Representation:** You affirm that the model tested and submitted is representative of the production-level version, including its level of quantization and any other relevant characteristics impacting energy efficiency and performance.
+            """)
+            file_output = gr.File(visible=False)
+            u = gr.UploadButton("Upload a zip file with logs", file_count="single", interactive=True)
+            u.upload(add_docker_eval, u, file_output)
         
-        # --- All Tasks Tab ---
-        with gr.TabItem("All Tasks 💡"):
-            sort_dropdown_all = gr.Dropdown(
-                choices=["Low to High", "High to Low"],
-                label="Sort",
-                value="Low to High"
-            )
-            all_table = gr.HTML(get_all_model_names_html("Low to High"))
-            sort_dropdown_all.change(fn=update_all_tasks, inputs=sort_dropdown_all, outputs=all_table)
-    
-    with gr.Accordion("📙 Citation", open=False):
-        citation_button = gr.Textbox(
-            value=CITATION_BUTTON_TEXT,
-            label=CITATION_BUTTON_LABEL,
-            elem_id="citation-button",
-            lines=10,
-            show_copy_button=True,
-        )
-    gr.Markdown("""Last updated: February 2025""")
-
-demo.launch()
+        # --- Leaderboard and Recent Models Accordions ---
+        with gr.Row():
+            with gr.Column():
+                with gr.Accordion("Models that are in the latest leaderboard version:", open=False, visible=False):
+                    gr.Dataframe(get_leaderboard_models(), elem_classes="full-width")
+                with gr.Accordion("Models that have been benchmarked recently:", open=False, visible=False):
+                    gr.Dataframe(formatted_df, elem_classes="full-width")
+
+demo.launch()