improved radar chart and added categories

app.py

@@ -5,36 +5,59 @@ import numpy as np
 import plotly.graph_objects as go
 
 df = pd.read_csv("results.csv").dropna()
-dataset_columns = df.columns[7:].tolist()
 
-def create_radar_plot(df, model_name):
-    model_data = df[df["Model"] == model_name].iloc[0]
+categories = {
+    "Overall": ["Model Avg"],
+    "Overall single turn": ["single turn perf"],
+    "Overall multi turn": ["multi turn perf"],
+    "Single func call": [
+        "xlam_single_tool_single_call",
+        "xlam_multiple_tool_single_call",
+    ],
+    "Multiple func call": [
+        "xlam_multiple_tool_multiple_call",
+        "xlam_single_tool_multiple_call",
+        "BFCL_v3_multi_turn_base_multi_func_call",
+    ],
+    "Irrelevant query": ["BFCL_v3_irrelevance"],
+    "Long context": ["tau_long_context", "BFCL_v3_multi_turn_long_context"],
+    "Missing func": ["xlam_tool_miss", "BFCL_v3_multi_turn_miss_func"],
+    "Missing params": ["BFCL_v3_multi_turn_miss_param"],
+    "Composite": ["BFCL_v3_multi_turn_composite"],
+}
+
+
+def create_radar_plot(df, model_names):
     datasets = df.columns[7:].tolist()
-    values = [model_data[m] for m in datasets]
-    values.append(values[0])
-    datasets.append(datasets[0])
-
-    fig = go.Figure(
-        data=go.Scatterpolar(
-            r=values,
-            theta=datasets,
-            fill="toself",
-            fillcolor="rgba(99, 102, 241, 0.3)",
-            line=dict(color="#4F46E5", width=2),
-            name=model_name,
-            text=[f"{val:.3f}" for val in values],
-            textposition="middle right",
-            mode="lines+markers+text",
+    fig = go.Figure()
+
+    colors = ["rgba(99, 102, 241, 0.3)", "rgba(34, 197, 94, 0.3)"]
+    line_colors = ["#4F46E5", "#16A34A"]
+
+    for idx, model_name in enumerate(model_names):
+        model_data = df[df["Model"] == model_name].iloc[0]
+        values = [model_data[m] for m in datasets]
+        values.append(values[0])
+        datasets_plot = datasets + [datasets[0]]
+
+        fig.add_trace(
+            go.Scatterpolar(
+                r=values,
+                theta=datasets_plot,
+                fill="toself",
+                fillcolor=colors[idx % len(colors)],
+                line=dict(color=line_colors[idx % len(line_colors)], width=2),
+                name=model_name,
+                text=[f"{val:.3f}" for val in values],
+                textposition="middle right",
+                mode="lines+markers+text",
+            )
         )
-    )
 
     fig.update_layout(
         polar=dict(
             radialaxis=dict(
-                visible=True,
-                range=[0, 1],
-                showline=False,
-                tickfont=dict(size=12),
+                visible=True, range=[0, 1], showline=False, tickfont=dict(size=12)
             ),
             angularaxis=dict(
                 tickfont=dict(size=13, family="Arial"),
@@ -42,9 +65,9 @@ def create_radar_plot(df, model_name):
                 direction="clockwise",
             ),
         ),
-        showlegend=False,
+        showlegend=True,
         title=dict(
-            text=model_name,
+            text="Model Comparison",
             x=0.5,
             y=0.95,
             font=dict(size=24, family="Arial", color="#1F2937"),
@@ -57,13 +80,13 @@ def create_radar_plot(df, model_name):
 
     return fig
 
-def model_info_tab(model_name=None):
-    if model_name is None:
-        model_name = df.sort_values("Model Avg", ascending=False).iloc[0]["Model"]
 
-    filtered_df = df[df["Model"] == model_name]
-    radar_chart = create_radar_plot(df, model_name)
+def model_info_tab(model_names=None):
+    if model_names is None or len(model_names) == 0:
+        model_names = [df.sort_values("Model Avg", ascending=False).iloc[0]["Model"]]
 
+    filtered_df = df[df["Model"].isin(model_names)]
+    radar_chart = create_radar_plot(df, model_names)
     info_html = filtered_df[
         [
             "Model",
@@ -81,14 +104,13 @@ def model_info_tab(model_name=None):
 
 def get_performance_chart(df):
     df_sorted = df.sort_values("Model Avg", ascending=True)
-    colors = {"Private": "#4169E1", "Open source": "#7B68EE"}
+    colors = {"Private": "#4F46E5", "Open source": "#16A34A"}
 
     fig, ax = plt.subplots(figsize=(16, 10))
-    bar_height = 0.4
     bars = ax.barh(
         np.arange(len(df_sorted)),
         df_sorted["Model Avg"],
-        height=bar_height,
+        height=0.4,
         color=[colors[t] for t in df_sorted["Model Type"]],
     )
 
@@ -113,12 +135,11 @@ def get_performance_chart(df):
     plt.tight_layout()
     return fig
 
-
 def get_performance_cost_chart(df):
     plt.figure(figsize=(12, 8), dpi=300)
     plt.grid(True, linestyle="--", alpha=0.2)
 
-    colors = {"Private": "#6366F1", "Open source": "#22C55E"}
+    colors = {"Private": "#4F46E5", "Open source": "#16A34A"}
     performance_colors = ["#DCFCE7", "#FEF9C3", "#FEE2E2"]
 
     for _, row in df.iterrows():
@@ -164,28 +185,28 @@ def get_performance_cost_chart(df):
     return plt.gcf()
 
 
-def filter_leaderboard(model_type, dataset):
+def filter_leaderboard(model_type, category):
     filtered_df = df.copy()
     if model_type != "All":
         filtered_df = filtered_df[filtered_df["Model Type"].str.strip() == model_type]
 
-    # Sort by selected dataset and add rank
-    filtered_df = filtered_df.sort_values(by=dataset, ascending=False)
+    dataset_columns = categories.get(category, ["Model Avg"])
+    avg_score = filtered_df[dataset_columns].mean(axis=1)
+    filtered_df["Category Score"] = avg_score
+
+    filtered_df = filtered_df.sort_values(by="Category Score", ascending=False)
     filtered_df["Rank"] = range(1, len(filtered_df) + 1)
 
     perf_chart = get_performance_chart(filtered_df)
     cost_chart = get_performance_cost_chart(filtered_df)
 
-    # Add Rank as first column
     display_columns = [
         "Rank",
         "Model",
         "Model Type",
-        dataset,
         "Input cost per million token",
         "Output cost per million token",
-        "single turn perf",
-        "multi turn perf",
+        "Category Score",
     ]
 
     table_html = filtered_df[display_columns].to_html(index=False)
@@ -203,10 +224,10 @@ with gr.Blocks(theme=gr.themes.Soft()) as app:
                         value="All",
                         label="Model Type",
                     )
-                    dataset = gr.Dropdown(
-                        choices=["Model Avg"] + dataset_columns,
-                        value="Model Avg",
-                        label="Dataset",
+                    category = gr.Dropdown(
+                        choices=list(categories.keys()),
+                        value=list(categories.keys())[0],
+                        label="Category",
                     )
 
                 with gr.Column(scale=4):
@@ -215,12 +236,13 @@ with gr.Blocks(theme=gr.themes.Soft()) as app:
                     plot1 = gr.Plot()
                     plot2 = gr.Plot()
 
-            for input_comp in [model_type, dataset]:
+            for input_comp in [model_type, category]:
                 input_comp.change(
                     fn=filter_leaderboard,
-                    inputs=[model_type, dataset],
+                    inputs=[model_type, category],
                     outputs=[output, plot1, plot2],
                 )
+
         with gr.Tab("Model Performance"):
             with gr.Row():
                 with gr.Column(scale=1):
@@ -229,7 +251,8 @@ with gr.Blocks(theme=gr.themes.Soft()) as app:
                         value=df.sort_values("Model Avg", ascending=False).iloc[0][
                             "Model"
                         ],
-                        label="Model",
+                        multiselect=True,
+                        label="Models",
                     )
                 with gr.Column(scale=4):
                     model_info = gr.HTML()
@@ -241,16 +264,14 @@ with gr.Blocks(theme=gr.themes.Soft()) as app:
                 outputs=[model_info, radar_plot],
             )
 
-    # Modify app.load to initialize only leaderboard
     app.load(
-        fn=lambda: filter_leaderboard("All", "Model Avg"),
+        fn=lambda: filter_leaderboard("All", list(categories.keys())[0]),
         outputs=[output, plot1, plot2],
     )
 
-    # Add separate load event for model info tab
     app.load(
         fn=lambda: model_info_tab(
-            df.sort_values("Model Avg", ascending=False).iloc[0]["Model"]
+            [df.sort_values("Model Avg", ascending=False).iloc[0]["Model"]]
         ),
         outputs=[model_info, radar_plot],
     )