Update app.py

app.py

@@ -1,7 +1,5 @@
 import gradio as gr
 import pandas as pd
-import plotly.express as px
-import numpy as np  # Import numpy
 
 CITATION_BUTTON_LABEL = "Copy the following snippet to cite these results"
 CITATION_BUTTON_TEXT = r"""@misc{aienergyscore-leaderboard,
@@ -26,6 +24,8 @@ tasks = [
     'summarization.csv'
 ]
 
+color_map = {"1": "red", "2": "orange", "3": "yellow", "4": "lightgreen", "5": "green"} # Keep color map
+
 def format_stars(score):
     try:
         score_int = int(score)
@@ -39,162 +39,61 @@ def make_link(mname):
     display_name = parts[1] if len(parts) > 1 else mname
     return f'[{display_name}](https://huggingface.co/{mname})'
 
-# --- Plot Functions (Bar Chart - Modified with kWh to Wh conversion and explicit tickvals) ---
-
-def get_plots(task):
-    df = pd.read_csv('data/energy/' + task)
-    if df.columns[0].startswith("Unnamed:"):
-        df = df.iloc[:, 1:]
-    # Use the raw numeric value from the CSV for GPU Energy and convert kWh to Wh
-    df['total_gpu_energy'] = pd.to_numeric(df['total_gpu_energy'], errors='raise') * 1000
-    df['energy_score'] = df['energy_score'].astype(int).astype(str)
-    # Create a display model column for labeling
-    df['Display Model'] = df['model'].apply(lambda m: m.split('/')[-1])
-
-    # Use the energy score to control color
-    color_map = {"1": "red", "2": "orange", "3": "yellow", "4": "lightgreen", "5": "green"}
-
-    # Now plot as a bar chart
-    fig = px.bar(
-        df,
-        x="Display Model",
-        y="total_gpu_energy",
-        color="energy_score",
-        custom_data=['energy_score'],
-        height=500,
-        width=800,
-        color_discrete_map=color_map
-    )
-    # Update hover text to show the model and GPU Energy (with 4 decimals)
-    fig.update_traces(
-        hovertemplate="<br>".join([
-            "Model: %{x}",
-            "GPU Energy (Wh): %{y:.4f}",
-            "Energy Score: %{customdata[0]}"
-        ])
-    )
-    fig.update_layout(
-        xaxis_title="Model",
-        yaxis_title="GPU Energy (Wh)",
-        yaxis = dict(
-            tickformat=".4f",
-            tickvals = list(np.arange(0, df['total_gpu_energy'].max() * 1.1, 100)) # Ticks every 100 Wh, adjust as needed
-        )
-    )
-    return fig
-
-def get_all_plots():
-    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['total_gpu_energy'] = pd.to_numeric(df['total_gpu_energy'], errors='raise') * 1000
-        df['energy_score'] = df['energy_score'].astype(int).astype(str)
-        df['Display Model'] = df['model'].apply(lambda m: m.split('/')[-1])
-        all_df = pd.concat([all_df, df], ignore_index=True)
-    all_df = all_df.drop_duplicates(subset=['model'])
-
-    color_map = {"1": "red", "2": "orange", "3": "yellow", "4": "lightgreen", "5": "green"}
-
-    fig = px.bar(
-        all_df,
-        x="Display Model",
-        y="total_gpu_energy",
-        color="energy_score",
-        custom_data=['energy_score'],
-        height=500,
-        width=800,
-        color_discrete_map=color_map
-    )
-    fig.update_traces(
-        hovertemplate="<br>".join([
-            "Model: %{x}",
-            "GPU Energy (Wh): %{y:.4f}",
-            "Energy Score: %{customdata[0]}"
-        ])
-    )
-    fig.update_layout(
-        xaxis_title="Model",
-        yaxis_title="GPU Energy (Wh)",
-        yaxis = dict(
-            tickformat=".4f",
-            tickvals = list(np.arange(0, all_df['total_gpu_energy'].max() * 1.1, 100)) # Ticks every 100 Wh, adjust as needed
-        )
-    )
-    return fig
-
-# --- New functions for Text Generation filtering by model class (with Bar Chart - Modified kWh to Wh and explicit tickvals) ---
+# --- Leaderboard Table Functions (Modified to dynamically calculate max energy) ---
 
-def get_text_generation_plots(model_class):
-    df = pd.read_csv('data/energy/text_generation.csv')
-    if df.columns[0].startswith("Unnamed:"):
-        df = df.iloc[:, 1:]
-    # Filter by the selected model class if the "class" column exists
-    if 'class' in df.columns:
-        df = df[df['class'] == model_class]
-    df['total_gpu_energy'] = pd.to_numeric(df['total_gpu_energy'], errors='raise') * 1000
-    df['energy_score'] = df['energy_score'].astype(int).astype(str)
-    df['Display Model'] = df['model'].apply(lambda m: m.split('/')[-1])
-
-
-    color_map = {"1": "red", "2": "orange", "3": "yellow", "4": "lightgreen", "5": "green"}
-
-    fig = px.bar(
-        df,
-        x="Display Model",
-        y="total_gpu_energy",
-        color="energy_score",
-        custom_data=['energy_score'],
-        height=500,
-        width=800,
-        color_discrete_map=color_map
-    )
-    fig.update_traces(
-        hovertemplate="<br>".join([
-            "Model: %{x}",
-            "GPU Energy (Wh): %{y:.4f}",
-            "Energy Score: %{customdata[0]}"
-        ])
-    )
-    fig.update_layout(
-        xaxis_title="Model",
-        yaxis_title="GPU Energy (Wh)",
-        yaxis = dict(
-            tickformat=".4f",
-            tickvals = list(np.arange(0, df['total_gpu_energy'].max() * 1.1, 100)) # Ticks every 100 Wh, adjust as needed
-        )
-    )
-    return fig
+def create_minimal_bar_html(energy_value_wh, energy_score, max_energy_value):
+    """Generates HTML for the minimal bar chart with dynamic max energy."""
+    if max_energy_value <= 0: # Avoid division by zero if max energy is 0 or negative
+        bar_percentage = 0
+    else:
+        bar_percentage = min(100, (energy_value_wh / max_energy_value) * 100) # Cap at 100%
+    bar_color = color_map.get(str(energy_score), "gray") # Default color if score is unexpected
 
+    html = f"""
+    <div style="display: flex; align-items: center; gap: 5px;">
+        <div style="width: {bar_percentage}%; height: 10px; background-color: {bar_color}; border-radius: 2px;"></div>
+        <span>{energy_value_wh:.4f} Wh</span>
+    </div>
+    """
+    return html
 
-# --- Leaderboard Table Functions (Modified kWh to Wh conversion) ---
 
 def get_model_names(task):
     df = pd.read_csv('data/energy/' + task)
     if df.columns[0].startswith("Unnamed:"):
         df = df.iloc[:, 1:]
+    df['total_gpu_energy'] = pd.to_numeric(df['total_gpu_energy'], errors='raise') * 1000 # kWh to Wh conversion
     df['energy_score'] = df['energy_score'].astype(int)
-    # For leaderboard display, format GPU Energy to 4 decimals and convert kWh to Wh
-    df['GPU Energy (Wh)'] = (pd.to_numeric(df['total_gpu_energy'], errors='raise') * 1000).apply(lambda x: f"{x:.4f}")
+    max_energy_for_task = df['total_gpu_energy'].max() # Calculate max energy for this task
+
+    # Create HTML bar chart for GPU Energy column, passing dynamic max_energy_for_task
+    df['GPU Energy (Wh)'] = df.apply(lambda row: create_minimal_bar_html(row['total_gpu_energy'], row['energy_score'], max_energy_for_task), axis=1)
+
     df['Model'] = df['model'].apply(make_link)
     df['Score'] = df['energy_score'].apply(format_stars)
-    # Remove any Class column if it exists
-    df = df[['Model', 'GPU Energy (Wh)', 'Score']]
-    df = df.sort_values(by='GPU Energy (Wh)')
+    df = df[['Model', 'GPU Energy (Wh)', 'Score']] # Keep only these columns
+    df = df.sort_values(by='total_gpu_energy') # Sort by underlying energy value for table order
+    df = df.drop('total_gpu_energy', axis=1) # remove the original energy column that was used for sorting
     return df
 
 def get_all_model_names():
     all_df = pd.DataFrame()
+    max_energy_overall = 0 # Initialize overall max energy
     for task in tasks:
         df = pd.read_csv('data/energy/' + task)
+        df['total_gpu_energy'] = pd.to_numeric(df['total_gpu_energy'], errors='raise') * 1000 # kWh to Wh conversion
         df['energy_score'] = df['energy_score'].astype(int)
-        df['GPU Energy (Wh)'] = (pd.to_numeric(df['total_gpu_energy'], errors='raise') * 1000).apply(lambda x: f"{x:.4f}")
-        df['Model'] = df['model'].apply(make_link)
-        df['Score'] = df['energy_score'].apply(format_stars)
+        max_energy_overall = max(max_energy_overall, df['total_gpu_energy'].max()) # Update overall max
+
         all_df = pd.concat([all_df, df], ignore_index=True)
     all_df = all_df.drop_duplicates(subset=['model'])
-    all_df = all_df.sort_values(by='GPU Energy (Wh)')
+
+    # Create HTML bar chart for GPU Energy column, passing dynamic max_energy_overall
+    all_df['GPU Energy (Wh)'] = all_df.apply(lambda row: create_minimal_bar_html(row['total_gpu_energy'], row['energy_score'], max_energy_overall), axis=1)
+    all_df['Model'] = all_df['model'].apply(make_link)
+    all_df['Score'] = all_df['energy_score'].apply(format_stars)
+    all_df = all_df.sort_values(by='total_gpu_energy') # Sort by underlying energy value for table order
+    all_df = all_df.drop('total_gpu_energy', axis=1) # remove the original energy column that was used for sorting
     return all_df[['Model', 'GPU Energy (Wh)', 'Score']]
 
 
@@ -204,21 +103,25 @@ def get_text_generation_model_names(model_class):
         df = df.iloc[:, 1:]
     if 'class' in df.columns:
         df = df[df['class'] == model_class]
+    df['total_gpu_energy'] = pd.to_numeric(df['total_gpu_energy'], errors='raise') * 1000 # kWh to Wh conversion
     df['energy_score'] = df['energy_score'].astype(int)
-    df['GPU Energy (Wh)'] = (pd.to_numeric(df['total_gpu_energy'], errors='raise') * 1000).apply(lambda x: f"{x:.4f}")
+    max_energy_for_class = df['total_gpu_energy'].max() # Calculate max energy for this class
+
+    # Create HTML bar chart for GPU Energy column, passing dynamic max_energy_for_class
+    df['GPU Energy (Wh)'] = df.apply(lambda row: create_minimal_bar_html(row['total_gpu_energy'], row['energy_score'], max_energy_for_class), axis=1)
+
     df['Model'] = df['model'].apply(make_link)
     df['Score'] = df['energy_score'].apply(format_stars)
-    # Remove the Class column if it exists
-    df = df[['Model', 'GPU Energy (Wh)', 'Score']]
-    df = df.sort_values(by='GPU Energy (Wh)')
+    df = df[['Model', 'GPU Energy (Wh)', 'Score']] # Keep only these columns
+    df = df.sort_values(by='total_gpu_energy') # Sort by underlying energy value for table order
+    df = df.drop('total_gpu_energy', axis=1) # remove the original energy column that was used for sorting
     return df
 
 def update_text_generation(model_class):
-    plot = get_text_generation_plots(model_class)
     table = get_text_generation_model_names(model_class)
-    return plot, table
+    return table
 
-# --- Build the Gradio Interface ---
+# --- Build the Gradio Interface (Plots Removed, Tables with Dynamic Bars) ---
 
 demo = gr.Blocks(css="""
 .gr-dataframe table {
@@ -231,6 +134,17 @@ demo = gr.Blocks(css="""
     overflow: hidden;
     text-overflow: ellipsis;
 }
+/* CSS for minimal bar chart inside table cell */
+.minimal-bar-container {
+    display: flex;
+    align-items: center;
+    gap: 5px; /* space between bar and text */
+}
+.minimal-bar {
+    height: 10px;
+    background-color: blue; /* default, will be overridden by dynamic color */
+    border-radius: 2px;
+}
 """)
 
 with demo:
@@ -243,89 +157,45 @@ Select different tasks to see scored models. Submit open models for testing and
     with gr.Tabs():
         # --- Text Generation Tab with Dropdown for Model Class ---
         with gr.TabItem("Text Generation 💬"):
-            # Dropdown moved above the plot and leaderboard
+            # Dropdown moved above the leaderboard
             model_class_dropdown = gr.Dropdown(choices=["A", "B", "C"],
                                                  label="Select Model Class",
                                                  value="A")
-            with gr.Row():
-                with gr.Column(scale=1.3):
-                    tg_plot = gr.Plot(get_text_generation_plots("A"))
-                with gr.Column(scale=1):
-                    tg_table = gr.Dataframe(get_text_generation_model_names("A"), datatype="markdown")
-            # Update plot and table when the dropdown value changes
+            tg_table = gr.Dataframe(get_text_generation_model_names("A"), datatype="markdown") # No plot anymore
+            # Update table when the dropdown value changes
             model_class_dropdown.change(fn=update_text_generation,
                                         inputs=model_class_dropdown,
-                                        outputs=[tg_plot, tg_table])
+                                        outputs=[tg_table])
 
         with gr.TabItem("Image Generation 📷"):
-            with gr.Row():
-                with gr.Column():
-                    plot = gr.Plot(get_plots('image_generation.csv'))
-                with gr.Column():
-                    table = gr.Dataframe(get_model_names('image_generation.csv'), datatype="markdown")
+            table = gr.Dataframe(get_model_names('image_generation.csv'), datatype="markdown")
 
         with gr.TabItem("Text Classification 🎭"):
-            with gr.Row():
-                with gr.Column():
-                    plot = gr.Plot(get_plots('text_classification.csv'))
-                with gr.Column():
-                    table = gr.Dataframe(get_model_names('text_classification.csv'), datatype="markdown")
+            table = gr.Dataframe(get_model_names('text_classification.csv'), datatype="markdown")
 
         with gr.TabItem("Image Classification 🖼️"):
-            with gr.Row():
-                with gr.Column():
-                    plot = gr.Plot(get_plots('image_classification.csv'))
-                with gr.Column():
-                    table = gr.Dataframe(get_model_names('image_classification.csv'), datatype="markdown")
+            table = gr.Dataframe(get_model_names('image_classification.csv'), datatype="markdown")
 
         with gr.TabItem("Image Captioning 📝"):
-            with gr.Row():
-                with gr.Column():
-                    plot = gr.Plot(get_plots('image_captioning.csv'))
-                with gr.Column():
-                    table = gr.Dataframe(get_model_names('image_captioning.csv'), datatype="markdown")
+            table = gr.Dataframe(get_model_names('image_captioning.csv'), datatype="markdown")
 
         with gr.TabItem("Summarization 📃"):
-            with gr.Row():
-                with gr.Column():
-                    plot = gr.Plot(get_plots('summarization.csv'))
-                with gr.Column():
-                    table = gr.Dataframe(get_model_names('summarization.csv'), datatype="markdown")
+            table = gr.Dataframe(get_model_names('summarization.csv'), datatype="markdown")
 
         with gr.TabItem("Automatic Speech Recognition 💬"):
-            with gr.Row():
-                with gr.Column():
-                    plot = gr.Plot(get_plots('asr.csv'))
-                with gr.Column():
-                    table = gr.Dataframe(get_model_names('asr.csv'), datatype="markdown")
+            table = gr.Dataframe(get_model_names('asr.csv'), datatype="markdown")
 
         with gr.TabItem("Object Detection 🚘"):
-            with gr.Row():
-                with gr.Column():
-                    plot = gr.Plot(get_plots('object_detection.csv'))
-                with gr.Column():
-                    table = gr.Dataframe(get_model_names('object_detection.csv'), datatype="markdown")
+            table = gr.Dataframe(get_model_names('object_detection.csv'), datatype="markdown")
 
         with gr.TabItem("Sentence Similarity 📚"):
-            with gr.Row():
-                with gr.Column():
-                    plot = gr.Plot(get_plots('sentence_similarity.csv'))
-                with gr.Column():
-                    table = gr.Dataframe(get_model_names('sentence_similarity.csv'), datatype="markdown")
+            table = gr.Dataframe(get_model_names('sentence_similarity.csv'), datatype="markdown")
 
         with gr.TabItem("Extractive QA ❔"):
-            with gr.Row():
-                with gr.Column():
-                    plot = gr.Plot(get_plots('question_answering.csv'))
-                with gr.Column():
-                    table = gr.Dataframe(get_model_names('question_answering.csv'), datatype="markdown")
+            table = gr.Dataframe(get_model_names('question_answering.csv'), datatype="markdown")
 
         with gr.TabItem("All Tasks 💡"):
-            with gr.Row():
-                with gr.Column():
-                    plot = gr.Plot(get_all_plots())
-                with gr.Column():
-                    table = gr.Dataframe(get_all_model_names(), datatype="markdown")
+            table = gr.Dataframe(get_all_model_names(), datatype="markdown")
 
     with gr.Accordion("📙 Citation", open=False):
         citation_button = gr.Textbox(