fix plots

src/app.py

@@ -3,7 +3,7 @@ import streamlit as st
 import pandas as pd
 from typing import Optional, List, Set, Tuple
 
-from .components.filters import render_table_filters, render_plot_filters
+from .components.filters import render_table_filters
 from .components.visualizations import (
     render_leaderboard_table,
     render_performance_plots,
@@ -13,7 +13,20 @@ from .services.firebase import fetch_leaderboard_data
 from .core.styles import CUSTOM_CSS
 
 
-def get_filter_values(df: pd.DataFrame) -> tuple[List[str], List[str], List[str], List[str], List[str], Tuple[int, int], Tuple[int, int], Tuple[int, int], List[str], int]:
+def get_filter_values(
+    df: pd.DataFrame,
+) -> tuple[
+    List[str],
+    List[str],
+    List[str],
+    List[str],
+    List[str],
+    Tuple[int, int],
+    Tuple[int, int],
+    Tuple[int, int],
+    List[str],
+    int,
+]:
     """Get unique values for filters"""
     models = sorted(df["Model ID"].unique().tolist())
     platforms = sorted(df["Platform"].unique().tolist())
@@ -25,7 +38,18 @@ def get_filter_values(df: pd.DataFrame) -> tuple[List[str], List[str], List[str]
     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())
-    return models, platforms, devices, cache_type_v, cache_type_k, pp_range, tg_range, n_threads, versions, max_n_gpu_layers
+    return (
+        models,
+        platforms,
+        devices,
+        cache_type_v,
+        cache_type_k,
+        pp_range,
+        tg_range,
+        n_threads,
+        versions,
+        max_n_gpu_layers,
+    )
 
 
 async def main():
@@ -50,10 +74,32 @@ async def main():
     render_header()
 
     # Get unique values for filters
-    models, platforms, devices, cache_type_v, cache_type_k, pp_range, tg_range, n_threads, versions, max_n_gpu_layers = get_filter_values(df)
+    (
+        models,
+        platforms,
+        devices,
+        cache_type_v,
+        cache_type_k,
+        pp_range,
+        tg_range,
+        n_threads,
+        versions,
+        max_n_gpu_layers,
+    ) = get_filter_values(df)
 
     # Render filters
-    table_filters = render_table_filters(models, platforms, devices, cache_type_v, cache_type_k, pp_range, tg_range, n_threads, versions, max_n_gpu_layers)
+    table_filters = render_table_filters(
+        models,
+        platforms,
+        devices,
+        cache_type_v,
+        cache_type_k,
+        pp_range,
+        tg_range,
+        n_threads,
+        versions,
+        max_n_gpu_layers,
+    )
 
     # Render the main leaderboard table
     render_leaderboard_table(df, table_filters)
@@ -61,7 +107,35 @@ async def main():
     # Render plot section
     st.markdown("---")
     st.title("📊 Performance Comparison")
-    plot_filters = render_plot_filters(models, platforms, devices, cache_type_v, cache_type_k, pp_range, tg_range, n_threads, versions, max_n_gpu_layers)
+
+    # Plot specific selectors in a row
+    plot_col1, plot_col2, plot_col3 = st.columns(3)
+
+    with plot_col1:
+        plot_model = st.selectbox(
+            "Select Model for Comparison", options=models, key="plot_model_selector"
+        )
+
+    with plot_col2:
+        plot_pp = st.selectbox(
+            "Select PP Config for Comparison",
+            options=sorted([int(x) for x in df["PP Config"].unique()]),
+            key="plot_pp_selector",
+        )
+
+    with plot_col3:
+        plot_tg = st.selectbox(
+            "Select TG Config for Comparison",
+            options=sorted([int(x) for x in df["TG Config"].unique()]),
+            key="plot_tg_selector",
+        )
+
+    # Create plot filters based on table filters but override the model and configs
+    plot_filters = table_filters.copy()
+    plot_filters["model"] = plot_model
+    plot_filters["pp_range"] = (plot_pp, plot_pp)  # Set exact PP value
+    plot_filters["tg_range"] = (plot_tg, plot_tg)  # Set exact TG value
+
     render_performance_plots(df, plot_filters)
 
 

src/components/filters.py

@@ -2,7 +2,7 @@ import streamlit as st
 from typing import List, Tuple, Dict, Set
 
 
-def render_grouping_options() -> List[str]:
+def render_grouping_options(key_prefix: str = "") -> List[str]:
     """Render grouping options selector"""
     available_groups = [
         "Model ID",
@@ -38,6 +38,7 @@ def render_grouping_options() -> List[str]:
         options=available_groups,
         default=default_groups,
         help="Select columns to group the results by",
+        key=f"{key_prefix}_group_by",
     )
 
     return selected_groups
@@ -125,12 +126,13 @@ def render_filters(
     n_threads: Tuple[int, int],
     versions: List[str],
     max_n_gpu_layers: int,
+    key_prefix: str = "",
 ) -> Dict:
     """Render all filters in a compact two-row layout"""
     filters = {}
 
     # Row 1: Grouping
-    filters["grouping"] = render_grouping_options()
+    filters["grouping"] = render_grouping_options(key_prefix)
 
     # st.markdown("**Filters**")
     # Row 2: All filters in columns
@@ -138,7 +140,10 @@ def render_filters(
 
     ##with col1:
     filters["model"] = st.selectbox(
-        "Model", options=["All"] + models, key="filter_model", help="Filters"
+        "Model",
+        options=["All"] + models,
+        key=f"{key_prefix}_filter_model",
+        help="Filters",
     )
 
     # Row 2 continued
@@ -146,27 +151,33 @@ def render_filters(
 
     with col2:
         filters["platform"] = st.selectbox(
-            "Platform", options=["All"] + platforms, key="filter_platform"
+            "Platform", options=["All"] + platforms, key=f"{key_prefix}_filter_platform"
         )
 
     with col3:
         filters["device"] = st.selectbox(
-            "Device", options=["All"] + devices, key="filter_device"
+            "Device", options=["All"] + devices, key=f"{key_prefix}_filter_device"
         )
 
     with col4:
         filters["flash_attn"] = st.selectbox(
-            "Flash Attention", options=["All", True, False], key="filter_flash_attn"
+            "Flash Attention",
+            options=["All", True, False],
+            key=f"{key_prefix}_filter_flash_attn",
         )
 
     with col5:
         filters["cache_type_k"] = st.selectbox(
-            "Cache Type K", options=["All"] + cache_type_k, key="filter_cache_type_k"
+            "Cache Type K",
+            options=["All"] + cache_type_k,
+            key=f"{key_prefix}_filter_cache_type_k",
         )
 
     with col6:
         filters["cache_type_v"] = st.selectbox(
-            "Cache Type V", options=["All"] + cache_type_v, key="filter_cache_type_v"
+            "Cache Type V",
+            options=["All"] + cache_type_v,
+            key=f"{key_prefix}_filter_cache_type_v",
         )
 
     with col7:
@@ -176,7 +187,7 @@ def render_filters(
             max_value=pp_range[1],
             value=pp_range,
             step=32,
-            key="filter_pp",
+            key=f"{key_prefix}_filter_pp",
         )
 
     with col8:
@@ -186,7 +197,7 @@ def render_filters(
             max_value=tg_range[1],
             value=tg_range,
             step=32,
-            key="filter_tg",
+            key=f"{key_prefix}_filter_tg",
         )
 
     with col9:
@@ -195,12 +206,12 @@ def render_filters(
             min_value=n_threads[0],
             max_value=n_threads[1],
             value=n_threads,
-            key="filter_threads",
+            key=f"{key_prefix}_filter_threads",
         )
 
     with col10:
         filters["Version"] = st.selectbox(
-            "Version", options=["All"] + versions, key="filter_version"
+            "Version", options=["All"] + versions, key=f"{key_prefix}_filter_version"
         )
 
     # Column visibility control as a small button/dropdown
@@ -233,31 +244,5 @@ def render_table_filters(
         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,
-) -> 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,
+        key_prefix="table",
     )