add subset avg for pro baselines

src/streamlit_app.py

@@ -366,11 +366,30 @@ def create_bar_chart(data: pd.DataFrame, metric: str, title: str):
         for baseline_name, baseline_metrics in BASELINES[dataset].items():
             metric_key = metric.replace('_avg', '').replace('avg', 'overall')
             if metric_key in baseline_metrics:
-                chart_data.append({
-                    'Model': baseline_name,
-                    'Score': baseline_metrics[metric_key],
-                    'Type': 'Baseline'
-                })
+                baseline_value = baseline_metrics[metric_key]
+                
+                # Check performance bounds if filter is enabled
+                should_include = True
+                if st.session_state.get('perf_filter_enabled', False):
+                    filter_metric = st.session_state.get('perf_filter_metric', 'overall')
+                    min_perf = st.session_state.get('perf_filter_min', 0.0)
+                    max_perf = st.session_state.get('perf_filter_max', 100.0)
+                    
+                    # Only filter if we're filtering by the same metric being displayed
+                    if filter_metric == metric and (baseline_value < min_perf or baseline_value > max_perf):
+                        should_include = False
+                    # Or if filtering by a different metric, check that metric's value
+                    elif filter_metric != metric and filter_metric in baseline_metrics:
+                        filter_value = baseline_metrics[filter_metric]
+                        if filter_value < min_perf or filter_value > max_perf:
+                            should_include = False
+                
+                if should_include:
+                    chart_data.append({
+                        'Model': baseline_name,
+                        'Score': baseline_value,
+                        'Type': 'Baseline'
+                    })
     
     if not chart_data:
         return None
@@ -565,6 +584,75 @@ def main():
         # If no models selected, show empty dataframe
         filtered_df = pd.DataFrame()
     
+    # Performance bounds filter
+    st.sidebar.divider()
+    st.sidebar.subheader("Performance Filters")
+    
+    # Enable/disable performance filtering
+    enable_perf_filter = st.sidebar.checkbox("Enable performance bounds", value=False)
+    
+    if enable_perf_filter:
+        # Get the metric to filter on
+        filter_metric_help = "Filter models based on their performance in the selected metric"
+        
+        # Determine available metrics for filtering
+        if selected_dataset == 'screenspot-v2':
+            filter_metrics = ['overall', 'desktop_text', 'desktop_icon', 'web_text', 'web_icon']
+            filter_metric_names = {
+                'overall': 'Overall Average',
+                'desktop_text': 'Desktop (Text)',
+                'desktop_icon': 'Desktop (Icon)',
+                'web_text': 'Web (Text)',
+                'web_icon': 'Web (Icon)'
+            }
+        elif selected_dataset == 'screenspot-pro':
+            filter_metrics = ['overall', 'text', 'icon']
+            filter_metric_names = {
+                'overall': 'Overall Average',
+                'text': 'Text',
+                'icon': 'Icon'
+            }
+        else:
+            filter_metrics = ['overall']
+            filter_metric_names = {'overall': 'Overall Average'}
+        
+        # Metric selector for filtering
+        filter_metric = st.sidebar.selectbox(
+            "Filter by metric:",
+            options=filter_metrics,
+            format_func=lambda x: filter_metric_names[x],
+            help=filter_metric_help
+        )
+        
+        # Performance bounds inputs
+        col1, col2 = st.sidebar.columns(2)
+        with col1:
+            min_perf = st.number_input(
+                "Min %",
+                min_value=0.0,
+                max_value=100.0,
+                value=0.0,
+                step=5.0,
+                help="Minimum performance threshold"
+            )
+        with col2:
+            max_perf = st.number_input(
+                "Max %",
+                min_value=0.0,
+                max_value=100.0,
+                value=100.0,
+                step=5.0,
+                help="Maximum performance threshold"
+            )
+        
+        # Store filter settings in session state
+        st.session_state['perf_filter_enabled'] = True
+        st.session_state['perf_filter_metric'] = filter_metric
+        st.session_state['perf_filter_min'] = min_perf
+        st.session_state['perf_filter_max'] = max_perf
+    else:
+        st.session_state['perf_filter_enabled'] = False
+    
     # Main content
     st.header(f"Results for {selected_dataset}")
     
@@ -589,6 +677,30 @@ def main():
     # Parse UI type metrics
     ui_metrics_df = parse_ui_type_metrics(filtered_df, selected_dataset)
     
+    # Apply performance bounds filter if enabled
+    if st.session_state.get('perf_filter_enabled', False) and not ui_metrics_df.empty:
+        filter_metric = st.session_state.get('perf_filter_metric', 'overall')
+        min_perf = st.session_state.get('perf_filter_min', 0.0)
+        max_perf = st.session_state.get('perf_filter_max', 100.0)
+        
+        # Check if the filter metric exists in the dataframe
+        if filter_metric in ui_metrics_df.columns:
+            # Filter models based on performance bounds
+            ui_metrics_df = ui_metrics_df[
+                (ui_metrics_df[filter_metric] >= min_perf) & 
+                (ui_metrics_df[filter_metric] <= max_perf)
+            ]
+            
+            # Update selected models to only include those within bounds
+            models_in_bounds = ui_metrics_df['model'].tolist()
+            filtered_models = [m for m in selected_models if m in models_in_bounds]
+            
+            # Show info about filtered models
+            total_models = len(selected_models)
+            shown_models = len(filtered_models)
+            if shown_models < total_models:
+                st.info(f"Showing {shown_models} of {total_models} selected models within performance bounds ({min_perf:.1f}% - {max_perf:.1f}% {filter_metric})")
+    
     # Add metric selector for screenspot datasets
     selected_metric = 'overall'  # Default metric
     if not ui_metrics_df.empty:
@@ -634,9 +746,9 @@ def main():
     # Display results table
     st.subheader("📊 Results Table")
     
-    # Filter ui_metrics_df to only include selected models
+    # Use the already filtered ui_metrics_df which respects performance bounds
     if not ui_metrics_df.empty:
-        table_df = ui_metrics_df[ui_metrics_df['model'].isin(selected_models)].copy()
+        table_df = ui_metrics_df.copy()
         
         # Add baselines to the table if available
         if selected_dataset in BASELINES:
@@ -672,7 +784,20 @@ def main():
                     # For other datasets (showdown-clicks, etc.)
                     baseline_row['overall'] = baseline_metrics.get('overall', 0)
                 
-                baseline_rows.append(baseline_row)
+                # Apply performance filter to baselines if enabled
+                should_include_baseline = True
+                if st.session_state.get('perf_filter_enabled', False):
+                    filter_metric = st.session_state.get('perf_filter_metric', 'overall')
+                    min_perf = st.session_state.get('perf_filter_min', 0.0)
+                    max_perf = st.session_state.get('perf_filter_max', 100.0)
+                    
+                    if filter_metric in baseline_row:
+                        metric_value = baseline_row[filter_metric]
+                        if metric_value < min_perf or metric_value > max_perf:
+                            should_include_baseline = False
+                
+                if should_include_baseline:
+                    baseline_rows.append(baseline_row)
             
             # Append baselines to table
             if baseline_rows: