add gpu layers

src/app.py

@@ -34,7 +34,7 @@ def get_filter_values(
     cache_type_v = sorted(df["cache_type_v"].unique().tolist())
     cache_type_k = sorted(df["cache_type_k"].unique().tolist())
     n_threads = (df["n_threads"].min(), df["n_threads"].max())
-    max_n_gpu_layers = max(df["n_gpu_layers"].unique().tolist())
+    max_n_gpu_layers = (0, max(df["n_gpu_layers"].unique().tolist()))
     pp_range = (df["PP Config"].min(), df["PP Config"].max())
     tg_range = (df["TG Config"].min(), df["TG Config"].max())
     versions = sorted(df["Version"].unique().tolist())

src/components/filters.py

@@ -14,10 +14,11 @@ def render_grouping_options(key_prefix: str = "") -> List[str]:
         "cache_type_v",
         "PP Config",
         "TG Config",
-        "n_context",
-        "n_batch",
-        "n_ubatch",
+        #"n_context",
+        #"n_batch",
+        #"n_ubatch",
         "Version",
+        "n_gpu_layers",
     ]
 
     default_groups = [
@@ -53,7 +54,7 @@ def render_column_visibility() -> Set[str]:
             "CPU Cores",
             "Total Memory (GB)",
             "Peak Memory (GB)",
-            "Memory Usage (%)",
+            #"Memory Usage (%)",
         ],
         "Benchmark Info": [
             "PP Config",
@@ -70,13 +71,13 @@ def render_column_visibility() -> Set[str]:
         ],
         "Advanced": [
             "n_threads",
-            "n_gpu_layers",
+            #"n_gpu_layers",
             "flash_attn",
             "cache_type_k",
             "cache_type_v",
-            "n_context",
-            "n_batch",
-            "n_ubatch",
+            #  "n_context",
+            #  "n_batch",
+            #  "n_ubatch",
         ],
         "App": [
             "Version",
@@ -148,7 +149,7 @@ def render_filters(
     )
 
     # Row 2 continued
-    col2, col3, col4, col5, col6, col7, col8, col9, col10 = st.columns(9)
+    col2, col3, col4, col5, col6, col7, col8, col9, col10, col11 = st.columns(10)
 
     with col2:
         filters["platform"] = st.selectbox(
@@ -162,7 +163,7 @@ def render_filters(
 
     with col4:
         filters["flash_attn"] = st.selectbox(
-            "Flash Attention",
+            "Attn",
             options=["All", True, False],
             key=f"{key_prefix}_filter_flash_attn",
         )
@@ -211,9 +212,19 @@ def render_filters(
         )
 
     with col10:
+        filters["n_gpu_layers"] = st.slider(
+            "GPU Layers",
+            min_value=0,
+            max_value=max_n_gpu_layers[1],
+            value=max_n_gpu_layers,
+            key=f"{key_prefix}_filter_n_gpu_layers",
+        )
+
+    with col11:
         filters["Version"] = st.selectbox(
             "Version", options=["All"] + versions, key=f"{key_prefix}_filter_version"
         )
+    
 
     # Column visibility control as a small button/dropdown
     filters["visible_columns"] = render_column_visibility()

src/components/visualizations.py

@@ -83,6 +83,13 @@ def filter_dataframe(df: pd.DataFrame, filters: Dict) -> pd.DataFrame:
             (n_threads >= n_threads_min) & (n_threads <= n_threads_max)
         ]
 
+    n_gpu_layers_min, n_gpu_layers_max = filters["n_gpu_layers"]
+    if n_gpu_layers_min is not None and n_gpu_layers_max is not None:
+        n_gpu_layers = filtered_df["n_gpu_layers"]
+        filtered_df = filtered_df[
+            (n_gpu_layers >= n_gpu_layers_min) & (n_gpu_layers <= n_gpu_layers_max)
+        ]
+
     # Version filter - handle multiple selections
     if filters.get("Version") != "All" and filters.get("Version"):
         filtered_df = filtered_df[filtered_df["Version"] == filters["Version"]]
@@ -216,48 +223,56 @@ def render_leaderboard_table(df: pd.DataFrame, filters: Dict):
         st.warning("No data matches the selected filters.")
         return
 
+    # Define the preferred column order (grouped logically)
+    column_order = [
+        # Device Info
+        "Device",
+        "Platform",
+        "CPU Cores",
+        "Total Memory (GB)",
+        "Peak Memory (GB)",
+        "Memory Usage (%)"
+        # Benchmark Results
+        "PP Config",
+        "PP Avg (t/s)",
+        "PP Std (t/s)",
+        "TG Config",
+        "TG Avg (t/s)",
+        "TG Std (t/s)",
+        # Model Config
+        "Model ID",
+        "Model Size",
+        "n_threads",
+        "flash_attn",
+        "cache_type_k",
+        "cache_type_v",
+        "n_context",
+        "n_batch",
+        "n_ubatch",
+        "Version",
+    ]
+
     # Group by selected columns
     grouping_cols = filters["grouping"]
     if not grouping_cols:
         grouping_cols = ["Model ID", "Device", "Platform"]  # Default grouping
 
-    # Define aggregations (excluding grouping columns)
+    # Create aggregations (excluding grouping columns)
     agg_dict = {
         col: agg
         for col, agg in {
             "Prompt Processing": ["mean", "std"],
             "Token Generation": ["mean", "std"],
-            # "Memory Usage (%)": "mean",
-            "Peak Memory (GB)": "mean",  # For a given model, device, platform, mem should be the same.
-            "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
+            "Peak Memory (GB)": "mean",
+            "Total Memory (GB)": "first",
+            "CPU Cores": "first",
+            "Model Size": "first",
+            "Version": lambda x: ", ".join(sorted(set(x))),
+            "n_gpu_layers": lambda x: ", ".join(sorted(set(str(x)))),
         }.items()
         if col not in grouping_cols
     }
 
-    # # Extract initSettings if needed
-    # init_settings_cols = {
-    #     "n_threads": "n_threads",
-    #     "flash_attn": "flash_attn",
-    #     "cache_type_k": "cache_type_k",
-    #     "cache_type_v": "cache_type_v",
-    #     "n_context": "n_context",
-    #     "n_batch": "n_batch",
-    #     "n_ubatch": "n_ubatch",
-    # }
-
-    # for col, setting in init_settings_cols.items():
-    #     if col not in filtered_df.columns:
-    #         filtered_df[col] = filtered_df["initSettings"].apply(
-    #             lambda x: x.get(setting)
-    #         )
-    #         if col not in grouping_cols:
-    #             agg_dict[col] = "first"
-
     # Group and aggregate
     grouped_df = filtered_df.groupby(grouping_cols).agg(agg_dict).reset_index()
 
@@ -266,33 +281,10 @@ def render_leaderboard_table(df: pd.DataFrame, filters: Dict):
         col[0] if col[1] == "" else f"{col[0]} ({col[1]})" for col in grouped_df.columns
     ]
 
-    # Round numeric columns
-    numeric_cols = [
-        col
-        for col in grouped_df.columns
-        if any(x in col for x in ["mean", "std", "Memory", "Size"])
-    ]
-    grouped_df[numeric_cols] = grouped_df[numeric_cols].round(2)
-
-    # Sort using the actual column names we have
-    sort_cols = []
-    if "Model Size (first)" in grouped_df.columns:
-        sort_cols.append("Model Size (first)")
-    if "PP Config (first)" in grouped_df.columns:
-        sort_cols.append("PP Config (first)")
-    if "Token Generation (mean)" in grouped_df.columns:
-        sort_cols.append("Token Generation (mean)")
-
-    if sort_cols:  # Only sort if we have columns to sort by
-        grouped_df = grouped_df.sort_values(
-            by=sort_cols, ascending=[False] + [True] * (len(sort_cols) - 1)
-        )
-
     # Rename columns for display
     column_mapping = {
         "Prompt Processing (mean)": "PP Avg (t/s)",
         "Prompt Processing (std)": "PP Std (t/s)",
-        "Prompt Processing (count)": "Runs",
         "Token Generation (mean)": "TG Avg (t/s)",
         "Token Generation (std)": "TG Std (t/s)",
         "Memory Usage (%) (mean)": "Memory Usage (%)",
@@ -352,34 +344,26 @@ def render_leaderboard_table(df: pd.DataFrame, filters: Dict):
         # Combine both sets to get unique columns
         all_cols = mapped_visible | mapped_grouping
 
-        # Create final display columns list while preserving grouping columns order
+        # Create final display columns list
         display_cols = []
 
-        # First add grouping columns in their original order
-        for col in filters["grouping"]:
-            mapped_col = column_name_mapping.get(col, col)
-            if mapped_col in all_cols:
-                display_cols.append(mapped_col)
-                all_cols.remove(mapped_col)
+        # Get all available columns we want to display
+        available_cols = set(all_cols)
 
-        # Then add remaining columns
-        display_cols.extend(sorted(all_cols))
+        # Add columns in the predefined order
+        for col in column_order:
+            if col in available_cols:
+                display_cols.append(col)
+
+        # Add any remaining columns that weren't in our predefined order
+        remaining_cols = sorted(list(available_cols - set(display_cols)))
+        display_cols.extend(remaining_cols)
     else:
         # Default columns if none selected
-        display_cols = [
-            "Device",
-            "Platform",
-            "Model ID",
-            "Model Size",
-            "PP Avg (ms)",
-            "TG Avg (ms)",
-            "Memory Usage (%)",
-        ]
-
-    # Ensure all display columns exist in the DataFrame
-    display_cols = [col for col in display_cols if col in grouped_df.columns]
+        display_cols = column_order[:8]  # First 8 columns from the predefined order
 
     # Display the filtered and grouped table
+    st.markdown("#### 📊 Benchmark Results")
     st.dataframe(
         grouped_df[display_cols],
         use_container_width=True,