heatmap + rank ordering

app.py

@@ -11,6 +11,8 @@ import pandas as pd
 from apscheduler.schedulers.background import BackgroundScheduler
 from datasets import VerificationMode, load_dataset, Dataset
 from huggingface_hub import HfApi, snapshot_download
+from collections import defaultdict
+import seaborn as sns
 
 from content import (
     CITATION_BUTTON_LABEL,
@@ -193,15 +195,13 @@ class LeaderboardData:
         df = pd.DataFrame(local_df)
         avail_columns = list(df.columns)
         missing_columns = list(set(filtered_columns) - set(avail_columns))
-        df[missing_columns] = "-"
+        df[missing_columns] = ""
 
         df = df[filtered_columns]
         # Unit conversion
         for col in df.columns:
             if "mae" in col.lower():
-                df[col] = (df[col] * 1000).round(2)
-            elif pd.api.types.is_numeric_dtype(df[col]):
-                df[col] = df[col].round(4)
+                df[col] = df[col] * 1000
         df = df.sort_values(by=[f"{subsplit}_energy_mae"], ascending=True)
         df[f"{subsplit}_energy_mae"] = df[f"{subsplit}_energy_mae"]
         df[f"{subsplit}_forces_mae"] = df[f"{subsplit}_forces_mae"]
@@ -231,16 +231,15 @@ class LeaderboardData:
         df = pd.DataFrame(local_df)
         avail_columns = list(df.columns)
         missing_columns = list(set(filtered_columns) - set(avail_columns))
-        df[missing_columns] = "-"
+        df[missing_columns] = ""
 
         df = df[filtered_columns]
         # Unit conversion
         for col in df.columns:
             if "mae" in col.lower():
-                df[col] = (df[col] * 1000).round(2)
-            elif pd.api.types.is_numeric_dtype(df[col]):
-                df[col] = df[col].round(4)
+                df[col] = df[col] * 1000
         df = df.sort_values(by=[eval_columns[0]], ascending=True)
+
         df = df.rename(columns=COLUMN_MAPPING)
         return df
 
@@ -427,6 +426,8 @@ def create_dataframe_tab(
         # Model | Organization |Energy Conserving | Training Set | Metrics | date
         widths = ["10%", "5%", "5%", "5%"] + ["5%"] * (num_cols - fixed_cols) + ["10%"]
 
+    cm = sns.color_palette("viridis_r", as_cmap=True)
+    df = df.style.format(precision=2).background_gradient(cmap=cm)
     with gr.Tab(tab_name) as tab:
         gr.Dataframe(
             value=df,
@@ -434,6 +435,7 @@ def create_dataframe_tab(
             interactive=False,
             show_search="filter",
             column_widths=widths,
+            show_copy_button=True,
         )
     return tab
 
@@ -463,7 +465,7 @@ def create_evaluation_tabs(results_dfs: Dict[str, pd.DataFrame]) -> None:
     overview_df = create_overview_dataframe(results_dfs)
     n_overview_columns = len(overview_df.columns)
     create_dataframe_tab(
-        "Overview", overview_df, widths=["20%"] + ["10%"] * (n_overview_columns - 1)
+        "Overview", overview_df, widths=["15%"] + ["10%"] * (n_overview_columns - 1)
     )
 
     # Create individual evaluation tabs
@@ -476,14 +478,8 @@ def create_overview_dataframe(results_dfs: Dict[str, pd.DataFrame]) -> pd.DataFr
     """
     Create an overview dataframe combining all models with only the first metric from each eval type.
     """
-    # Initialize overview data with model info
-    overview_data = {}
 
-    # Get all unique model-dataset combinations across all dataframes
-    all_model_entries = set()
     model_info = {}
-
-    # Collect all models and their info from all evaluation types
     for eval_type, df in results_dfs.items():
         if eval_type.startswith("Validation_") or eval_type.startswith("Test_"):
             continue
@@ -491,10 +487,7 @@ def create_overview_dataframe(results_dfs: Dict[str, pd.DataFrame]) -> pd.DataFr
         for _, row in df.iterrows():
             model_name = row["Model"]
             dataset = row["Training Set"]
-            # Create unique identifier combining model name and training set
             model_entry = (model_name, dataset)
-            all_model_entries.add(model_entry)
-            # Store model metadata for this specific entry
             model_info[model_entry] = {
                 "Model": model_name,
                 "Organization": row.get("Organization", ""),
@@ -502,7 +495,6 @@ def create_overview_dataframe(results_dfs: Dict[str, pd.DataFrame]) -> pd.DataFr
                 "Training Set": dataset,
             }
 
-    # Initialize overview data structure
     overview_data = {
         "Model": [],
         "Organization": [],
@@ -510,25 +502,18 @@ def create_overview_dataframe(results_dfs: Dict[str, pd.DataFrame]) -> pd.DataFr
         "Training Set": [],
     }
 
-    # Add columns for the primary metric from each evaluation type
     metric_columns = {}
-
-    # Add primary metric from each OTHER evaluation type (skip S2EF)
     for eval_type in OTHER_EVAL_TYPES:
         if eval_type in results_dfs and eval_type in LEADERBOARD_COLUMNS:
-            primary_metric = LEADERBOARD_COLUMNS[eval_type][0]  # First metric
-            # Map to display name using COLUMN_MAPPING
-            metric_display_name = COLUMN_MAPPING.get(primary_metric, primary_metric)
-            # Include task name to avoid conflicts when multiple tasks have same metric
+            metric_display_name = COLUMN_MAPPING[LEADERBOARD_COLUMNS[eval_type][0]]
             task_display_name = "IE/EA" if eval_type == "IE_EA" else eval_type
             full_display_name = f"{task_display_name}\n{metric_display_name}"
             overview_data[full_display_name] = []
             metric_columns[full_display_name] = (eval_type, metric_display_name)
 
-    # Populate data for each model entry
-    for model_entry in sorted(
-        all_model_entries, key=lambda x: (x[0], x[1])
-    ):  # Sort by model name, then dataset
+    all_model_entries = model_info.keys()
+    model_rankings = defaultdict(list)
+    for model_entry in sorted(all_model_entries, key=lambda x: (x[0], x[1])):
         model_name, dataset = model_entry
         entry_info = model_info[model_entry]
 
@@ -540,35 +525,32 @@ def create_overview_dataframe(results_dfs: Dict[str, pd.DataFrame]) -> pd.DataFr
         # Fill in metrics for each column
         for display_col, (eval_type, source_col) in metric_columns.items():
             if eval_type in results_dfs:
-                df = results_dfs[eval_type]
+                df = results_dfs[eval_type].reset_index(drop=True)
                 # Match both model name and training set
                 model_row = df[
                     (df["Model"] == model_name) & (df["Training Set"] == dataset)
                 ]
                 if not model_row.empty and source_col in model_row.columns:
                     value = model_row.iloc[0][source_col]
+                    rank = model_row.index[0]
                 else:
-                    value = "-"
-            else:
-                value = "-"
-            overview_data[display_col].append(value)
+                    value = ""
+                    rank = df.shape[0]
+                overview_data[display_col].append(value)
+                model_rankings[model_entry].append(rank)
 
     overview_df = pd.DataFrame(overview_data)
 
-    # Sort by the average of all metric columns (ascending for MAE metrics)
-    metric_cols = [
-        col
-        for col in overview_df.columns
-        if col not in PRE_COLUMN_NAMES + POST_COLUMN_NAMES
-    ]
-    if metric_cols:
-        # Calculate average across all metric columns for each row
-        # Convert all metric columns to numeric, keeping "-" as NaN
-        numeric_metrics = overview_df[metric_cols].apply(pd.to_numeric, errors="coerce")
-        # Calculate mean across columns, ignoring NaN values
-        avg_scores = numeric_metrics.mean(axis=1)
-        # Sort by average score (ascending for MAE metrics)
-        overview_df = overview_df.loc[avg_scores.sort_values().index]
+    def get_rank(row):
+        model_name = row["Model"]
+        dataset = row["Training Set"]
+        rank = np.mean(model_rankings[(model_name, dataset)])
+        return rank
+
+    overview_df["overall_rank"] = overview_df.apply(get_rank, axis=1)
+    overview_df = overview_df.sort_values(by="overall_rank").drop(
+        columns=["overall_rank"]
+    )
 
     return overview_df