add Versions

src/components/filters.py

@@ -17,6 +17,7 @@ def render_grouping_options() -> List[str]:
         "n_context",
         "n_batch",
         "n_ubatch",
+        "Version",
     ]
 
     default_groups = [
@@ -31,7 +32,7 @@ def render_grouping_options() -> List[str]:
         "TG Config",
     ]
 
-    #st.markdown("### Group Results")
+    # st.markdown("### Group Results")
     selected_groups = st.multiselect(
         "Group By",
         options=available_groups,
@@ -113,16 +114,25 @@ def render_column_visibility() -> Set[str]:
     return selected_columns
 
 
-def render_filters(models: List[str], platforms: List[str], devices: List[str], 
-                   cache_type_v: List[str], cache_type_k: List[str], pp_range: Tuple[int, int], 
-                   tg_range: Tuple[int, int], n_threads: Tuple[int, int], versions: List[str], max_n_gpu_layers: int) -> Dict:
+def render_filters(
+    models: List[str],
+    platforms: List[str],
+    devices: List[str],
+    cache_type_v: List[str],
+    cache_type_k: List[str],
+    pp_range: Tuple[int, int],
+    tg_range: Tuple[int, int],
+    n_threads: Tuple[int, int],
+    versions: List[str],
+    max_n_gpu_layers: int,
+) -> Dict:
     """Render all filters in a compact two-row layout"""
     filters = {}
 
     # Row 1: Grouping
     filters["grouping"] = render_grouping_options()
 
-    st.markdown("**Filters**")
+    # st.markdown("**Filters**")
     # Row 2: All filters in columns
     # col1 = st.columns(1)
 
@@ -159,7 +169,6 @@ def render_filters(models: List[str], platforms: List[str], devices: List[str],
             "Cache Type V", options=["All"] + cache_type_v, key="filter_cache_type_v"
         )
 
-
     with col7:
         filters["pp_range"] = st.slider(
             "PP Range",
@@ -182,11 +191,15 @@ def render_filters(models: List[str], platforms: List[str], devices: List[str],
 
     with col9:
         filters["n_threads"] = st.slider(
-            "Threads", min_value=n_threads[0], max_value=n_threads[1], value=n_threads, key="filter_threads"
+            "Threads",
+            min_value=n_threads[0],
+            max_value=n_threads[1],
+            value=n_threads,
+            key="filter_threads",
         )
 
     with col10:
-        filters["Version"] = st.multiselect(
+        filters["Version"] = st.selectbox(
             "Version", options=["All"] + versions, key="filter_version"
         )
 
@@ -197,14 +210,54 @@ def render_filters(models: List[str], platforms: List[str], devices: List[str],
 
 
 def render_table_filters(
-    models: List[str], platforms: List[str], devices: List[str], cache_type_v: List[str], cache_type_k: List[str], pp_range: Tuple[int, int], tg_range: Tuple[int, int], n_threads: Tuple[int, int], versions: List[str], max_n_gpu_layers: int
+    models: List[str],
+    platforms: List[str],
+    devices: List[str],
+    cache_type_v: List[str],
+    cache_type_k: List[str],
+    pp_range: Tuple[int, int],
+    tg_range: Tuple[int, int],
+    n_threads: Tuple[int, int],
+    versions: List[str],
+    max_n_gpu_layers: int,
 ) -> Dict:
     """Main entry point for table filters"""
-    return render_filters(models, platforms, devices, cache_type_v, cache_type_k, pp_range, tg_range, n_threads, versions, max_n_gpu_layers)
+    return render_filters(
+        models,
+        platforms,
+        devices,
+        cache_type_v,
+        cache_type_k,
+        pp_range,
+        tg_range,
+        n_threads,
+        versions,
+        max_n_gpu_layers,
+    )
 
 
 def render_plot_filters(
-    models: List[str], platforms: List[str], devices: List[str], cache_type_v: List[str], cache_type_k: List[str], pp_range: Tuple[int, int], tg_range: Tuple[int, int], n_threads: Tuple[int, int], versions: List[str], max_n_gpu_layers: int
+    models: List[str],
+    platforms: List[str],
+    devices: List[str],
+    cache_type_v: List[str],
+    cache_type_k: List[str],
+    pp_range: Tuple[int, int],
+    tg_range: Tuple[int, int],
+    n_threads: Tuple[int, int],
+    versions: List[str],
+    max_n_gpu_layers: int,
 ) -> Dict:
     """Main entry point for plot filters"""
-    return render_filters(models, platforms, devices, cache_type_v, cache_type_k, pp_range, tg_range, n_threads, versions, max_n_gpu_layers)
+    return render_filters(
+        models,
+        platforms,
+        devices,
+        cache_type_v,
+        cache_type_k,
+        pp_range,
+        tg_range,
+        n_threads,
+        versions,
+        max_n_gpu_layers,
+    )

src/components/visualizations.py

@@ -55,10 +55,14 @@ def filter_dataframe(df: pd.DataFrame, filters: Dict) -> pd.DataFrame:
 
     # Cache Type filters
     if filters["cache_type_k"] != "All":
-        filtered_df = filtered_df[filtered_df["cache_type_k"] == filters["cache_type_k"]]
+        filtered_df = filtered_df[
+            filtered_df["cache_type_k"] == filters["cache_type_k"]
+        ]
 
     if filters["cache_type_v"] != "All":
-        filtered_df = filtered_df[filtered_df["cache_type_v"] == filters["cache_type_v"]]
+        filtered_df = filtered_df[
+            filtered_df["cache_type_v"] == filters["cache_type_v"]
+        ]
 
     # Range filters
     pp_min, pp_max = filters["pp_range"]
@@ -71,7 +75,6 @@ def filter_dataframe(df: pd.DataFrame, filters: Dict) -> pd.DataFrame:
         tg_values = filtered_df["TG Config"]
         filtered_df = filtered_df[(tg_values >= tg_min) & (tg_values <= tg_max)]
 
-
     n_threads_min, n_threads_max = filters["n_threads"]
 
     if n_threads_min is not None and n_threads_max is not None:
@@ -81,9 +84,8 @@ def filter_dataframe(df: pd.DataFrame, filters: Dict) -> pd.DataFrame:
         ]
 
     # Version filter - handle multiple selections
-    if filters.get("version") != "All" and filters.get("version"):
-        filtered_df = filtered_df[filtered_df["Version"].isin(filters["version"])]
-
+    if filters.get("Version") != "All" and filters.get("Version"):
+        filtered_df = filtered_df[filtered_df["Version"] == filters["Version"]]
 
     return filtered_df
 
@@ -230,6 +232,9 @@ def render_leaderboard_table(df: pd.DataFrame, filters: Dict):
             "Total Memory (GB)": "first",  # For a given model, device, platform, mem should be the same.
             "CPU Cores": "first",  # For a given model, device, platform, cpu cores should be the same.
             "Model Size": "first",  # model size should be the same for all.
+            "Version": lambda x: ", ".join(
+                sorted(set(x))
+            ),  # Concatenate unique versions
         }.items()
         if col not in grouping_cols
     }
@@ -283,6 +288,7 @@ def render_leaderboard_table(df: pd.DataFrame, filters: Dict):
             by=sort_cols, ascending=[False] + [True] * (len(sort_cols) - 1)
         )
 
+
     # Rename columns for display
     column_mapping = {
         "Prompt Processing (mean)": "PP Avg (t/s)",
@@ -304,6 +310,7 @@ def render_leaderboard_table(df: pd.DataFrame, filters: Dict):
         "n_context (first)": "n_context",
         "n_batch (first)": "n_batch",
         "n_ubatch (first)": "n_ubatch",
+        "Version (<lambda>)": "Version",
     }
     grouped_df = grouped_df.rename(columns=column_mapping)