fix caching of elements

src/streamlit_app.py

@@ -411,19 +411,12 @@ def main():
     
     if selected_model != 'All':
         filtered_df = filtered_df[filtered_df['model'] == selected_model]
-
-    # Create placeholders for components that update when dataset or metric changes
-    header_placeholder = st.empty()
-    metrics_placeholder = st.empty()
-    chart_placeholder = st.empty()
-    view_metrics_expander_placeholder = st.empty()
-    progression_expander_placeholder = st.empty()
-
+    
     # Main content
-    header_placeholder.header(f"Results for {selected_dataset}")
+    st.header(f"Results for {selected_dataset}")
     
     # Overall metrics
-    col1, col2, col3 = metrics_placeholder.columns(3)
+    col1, col2, col3 = st.columns(3)
     with col1:
         st.metric("Models Evaluated", len(filtered_df))
     with col2:
@@ -482,281 +475,9 @@ def main():
         # Create single chart for selected metric
         chart = create_bar_chart(ui_metrics_df, selected_metric, metric_options[selected_metric])
         if chart:
-            chart_placeholder.altair_chart(chart, use_container_width=True)
+            st.altair_chart(chart, use_container_width=True)
         else:
             st.warning(f"No data available for {metric_options[selected_metric]}")
-        
-        # Show all metrics in an expandable section - available for all datasets
-        with view_metrics_expander_placeholder.expander("View All Metrics"):
-            if selected_dataset == 'screenspot-v2':
-                # First row: Overall, Desktop, Web averages
-                col1, col2, col3 = st.columns(3)
-                
-                with col1:
-                    chart = create_bar_chart(ui_metrics_df, 'overall', 'Overall Average (Desktop + Web) / 2')
-                    if chart:
-                        st.altair_chart(chart, use_container_width=True)
-                
-                with col2:
-                    chart = create_bar_chart(ui_metrics_df, 'desktop_avg', 'Desktop Average')
-                    if chart:
-                        st.altair_chart(chart, use_container_width=True)
-                
-                with col3:
-                    chart = create_bar_chart(ui_metrics_df, 'web_avg', 'Web Average')
-                    if chart:
-                        st.altair_chart(chart, use_container_width=True)
-                
-                # Second row: Individual UI type metrics
-                col1, col2, col3, col4 = st.columns(4)
-                
-                with col1:
-                    chart = create_bar_chart(ui_metrics_df, 'desktop_text', 'Desktop (Text)')
-                    if chart:
-                        st.altair_chart(chart, use_container_width=True)
-                
-                with col2:
-                    chart = create_bar_chart(ui_metrics_df, 'desktop_icon', 'Desktop (Icon)')
-                    if chart:
-                        st.altair_chart(chart, use_container_width=True)
-                
-                with col3:
-                    chart = create_bar_chart(ui_metrics_df, 'web_text', 'Web (Text)')
-                    if chart:
-                        st.altair_chart(chart, use_container_width=True)
-                
-                with col4:
-                    chart = create_bar_chart(ui_metrics_df, 'web_icon', 'Web (Icon)')
-                    if chart:
-                        st.altair_chart(chart, use_container_width=True)
-                
-                # Third row: Text vs Icon averages
-                col1, col2 = st.columns(2)
-                
-                with col1:
-                    chart = create_bar_chart(ui_metrics_df, 'text_avg', 'Text Average (Desktop + Web)')
-                    if chart:
-                        st.altair_chart(chart, use_container_width=True)
-                
-                with col2:
-                    chart = create_bar_chart(ui_metrics_df, 'icon_avg', 'Icon Average (Desktop + Web)')
-                    if chart:
-                        st.altair_chart(chart, use_container_width=True)
-            else:
-                # For screenspot-pro and showdown-clicks
-                st.info("No additional UI type metrics available for this dataset. Only overall accuracy is reported.")
-        
-        # Checkpoint progression visualization
-        with progression_expander_placeholder.expander("Checkpoint Progression Analysis"):
-            # Select a model with checkpoints
-            models_with_checkpoints = ui_metrics_df[ui_metrics_df['all_checkpoints'].apply(lambda x: len(x) > 1)]
-            
-            if not models_with_checkpoints.empty:
-                selected_checkpoint_model = st.selectbox(
-                    "Select a model to view checkpoint progression:",
-                    models_with_checkpoints['model'].str.replace('*', '').unique()
-                )
-                
-                # Get checkpoint data for selected model
-                model_row = models_with_checkpoints[models_with_checkpoints['model'].str.replace('*', '') == selected_checkpoint_model].iloc[0]
-                checkpoint_data = model_row['all_checkpoints']
-                
-                # Create DataFrame from checkpoint data
-                checkpoint_df = pd.DataFrame(checkpoint_data)
-                
-                # Prepare data for visualization
-                checkpoint_metrics = []
-                for _, cp in checkpoint_df.iterrows():
-                    ui_results = cp.get('ui_type_results', {})
-                    dataset_type_results = cp.get('dataset_type_results', {})
-                    results_by_file = cp.get('results_by_file', {})
-                    
-                    # Check if we have desktop/web breakdown in results_by_file
-                    desktop_file = None
-                    web_file = None
-                    
-                    for filename, file_results in results_by_file.items():
-                        if 'desktop' in filename.lower():
-                            desktop_file = file_results
-                        elif 'web' in filename.lower():
-                            web_file = file_results
-                    
-                    if desktop_file and web_file:
-                        # We have desktop/web breakdown
-                        desktop_text = desktop_file.get('by_ui_type', {}).get('text', {}).get('correct', 0) / max(desktop_file.get('by_ui_type', {}).get('text', {}).get('total', 1), 1) * 100
-                        desktop_icon = desktop_file.get('by_ui_type', {}).get('icon', {}).get('correct', 0) / max(desktop_file.get('by_ui_type', {}).get('icon', {}).get('total', 1), 1) * 100
-                        web_text = web_file.get('by_ui_type', {}).get('text', {}).get('correct', 0) / max(web_file.get('by_ui_type', {}).get('text', {}).get('total', 1), 1) * 100
-                        web_icon = web_file.get('by_ui_type', {}).get('icon', {}).get('correct', 0) / max(web_file.get('by_ui_type', {}).get('icon', {}).get('total', 1), 1) * 100
-                    else:
-                        # Fallback to simple UI type results
-                        desktop_text = ui_results.get('desktop_text', {}).get('correct', 0) / max(ui_results.get('desktop_text', {}).get('total', 1), 1) * 100
-                        desktop_icon = ui_results.get('desktop_icon', {}).get('correct', 0) / max(ui_results.get('desktop_icon', {}).get('total', 1), 1) * 100
-                        web_text = ui_results.get('web_text', {}).get('correct', 0) / max(ui_results.get('web_text', {}).get('total', 1), 1) * 100
-                        web_icon = ui_results.get('web_icon', {}).get('correct', 0) / max(ui_results.get('web_icon', {}).get('total', 1), 1) * 100
-                        
-                        # If still all zeros, try dataset_type_results
-                        if desktop_text == 0 and desktop_icon == 0 and web_text == 0 and web_icon == 0:
-                            for dataset_key in dataset_type_results:
-                                if 'screenspot' in dataset_key.lower():
-                                    dataset_data = dataset_type_results[dataset_key]
-                                    if 'by_ui_type' in dataset_data:
-                                        ui_data = dataset_data['by_ui_type']
-                                        # For simple text/icon without desktop/web
-                                        text_val = ui_data.get('text', {}).get('correct', 0) / max(ui_data.get('text', {}).get('total', 1), 1) * 100
-                                        icon_val = ui_data.get('icon', {}).get('correct', 0) / max(ui_data.get('icon', {}).get('total', 1), 1) * 100
-                                        # Assign same values to desktop and web as we don't have the breakdown
-                                        desktop_text = web_text = text_val
-                                        desktop_icon = web_icon = icon_val
-                                        break
-                    
-                    desktop_avg = (desktop_text + desktop_icon) / 2
-                    web_avg = (web_text + web_icon) / 2
-                    text_avg = (desktop_text + web_text) / 2
-                    icon_avg = (desktop_icon + web_icon) / 2
-                    overall = (desktop_avg + web_avg) / 2 if selected_dataset == 'screenspot-v2' else cp['overall_accuracy']
-                    
-                    checkpoint_metrics.append({
-                        'steps': cp['checkpoint_steps'] or 0,
-                        'overall': overall,
-                        'desktop_avg': desktop_avg,
-                        'web_avg': web_avg,
-                        'desktop_text': desktop_text,
-                        'desktop_icon': desktop_icon,
-                        'web_text': web_text,
-                        'web_icon': web_icon,
-                        'text_avg': text_avg,
-                        'icon_avg': icon_avg,
-                        'loss': cp['training_loss'],
-                        'neg_log_loss': -np.log(cp['training_loss']) if cp['training_loss'] and cp['training_loss'] > 0 else None
-                    })
-                
-                metrics_df = pd.DataFrame(checkpoint_metrics).sort_values('steps')
-                
-                # Plot metrics over training steps
-                col1, col2 = st.columns(2)
-                
-                with col1:
-                    st.write("**Accuracy over Training Steps**")
-                    
-                    # Determine which metrics to show based on selected metric
-                    if selected_metric == 'overall':
-                        # Show overall, desktop, and web averages
-                        metrics_to_show = ['overall', 'desktop_avg', 'web_avg']
-                        metric_labels = ['Overall', 'Desktop Avg', 'Web Avg']
-                        colors = ['#4ECDC4', '#45B7D1', '#96CEB4']
-                    elif 'desktop' in selected_metric:
-                        # Show all desktop metrics
-                        metrics_to_show = ['desktop_avg', 'desktop_text', 'desktop_icon']
-                        metric_labels = ['Desktop Avg', 'Desktop Text', 'Desktop Icon']
-                        colors = ['#45B7D1', '#FFA726', '#FF6B6B']
-                    elif 'web' in selected_metric:
-                        # Show all web metrics
-                        metrics_to_show = ['web_avg', 'web_text', 'web_icon']
-                        metric_labels = ['Web Avg', 'Web Text', 'Web Icon']
-                        colors = ['#96CEB4', '#9C27B0', '#E91E63']
-                    elif 'text' in selected_metric:
-                        # Show text metrics across environments
-                        metrics_to_show = ['text_avg', 'desktop_text', 'web_text']
-                        metric_labels = ['Text Avg', 'Desktop Text', 'Web Text']
-                        colors = ['#FF9800', '#FFA726', '#FFB74D']
-                    elif 'icon' in selected_metric:
-                        # Show icon metrics across environments
-                        metrics_to_show = ['icon_avg', 'desktop_icon', 'web_icon']
-                        metric_labels = ['Icon Avg', 'Desktop Icon', 'Web Icon']
-                        colors = ['#3F51B5', '#5C6BC0', '#7986CB']
-                    else:
-                        # Default: just show the selected metric
-                        metrics_to_show = [selected_metric]
-                        metric_labels = [metric_options.get(selected_metric, selected_metric)]
-                        colors = ['#4ECDC4']
-                    
-                    # Create multi-line chart data
-                    chart_data = []
-                    for i, (metric, label) in enumerate(zip(metrics_to_show, metric_labels)):
-                        for _, row in metrics_df.iterrows():
-                            if metric in row:
-                                chart_data.append({
-                                    'steps': row['steps'],
-                                    'value': row[metric],
-                                    'metric': label,
-                                    'color_idx': i
-                                })
-                    
-                    if chart_data:
-                        chart_df = pd.DataFrame(chart_data)
-                        
-                        # Create multi-line chart with distinct colors
-                        chart = alt.Chart(chart_df).mark_line(point=True, strokeWidth=2).encode(
-                            x=alt.X('steps:Q', title='Training Steps'),
-                            y=alt.Y('value:Q', scale=alt.Scale(domain=[0, 100]), title='Accuracy (%)'),
-                            color=alt.Color('metric:N', 
-                                          scale=alt.Scale(domain=metric_labels, range=colors),
-                                          legend=alt.Legend(title="Metric")),
-                            tooltip=['steps:Q', 'metric:N', alt.Tooltip('value:Q', format='.1f', title='Accuracy')]
-                        ).properties(
-                            width=500,
-                            height=400,
-                            title='Accuracy Progression During Training'
-                        )
-                        st.altair_chart(chart, use_container_width=True)
-                    else:
-                        st.warning("No data available for the selected metrics")
-                
-                with col2:
-                    st.write(f"**{metric_options[selected_metric]} vs. Training Loss**")
-                    
-                    if metrics_df['neg_log_loss'].notna().any():
-                        scatter_data = metrics_df[metrics_df['neg_log_loss'].notna()]
-                        
-                        chart = alt.Chart(scatter_data).mark_circle(size=100).encode(
-                            x=alt.X('neg_log_loss:Q', title='-log(Training Loss)'),
-                            y=alt.Y(f'{selected_metric}:Q', scale=alt.Scale(domain=[0, 100]), title=f'{metric_options[selected_metric]} (%)'),
-                            color=alt.Color('steps:Q', scale=alt.Scale(scheme='viridis'), title='Training Steps'),
-                            tooltip=['steps', 'loss', selected_metric]
-                        ).properties(
-                            width=500,  # Increased from 400
-                            height=400,  # Increased from 300
-                            title=f'{metric_options[selected_metric]} vs. -log(Training Loss)'
-                        )
-                        st.altair_chart(chart, use_container_width=True)
-                    else:
-                        st.info("No training loss data available for this model")
-                
-                # Show checkpoint details table with selected metric
-                st.write("**Checkpoint Details**")
-                
-                # Determine columns to display based on selected metric category
-                if selected_metric == 'overall':
-                    display_cols = ['steps', 'overall', 'desktop_avg', 'web_avg', 'loss']
-                    col_labels = ['Steps', 'Overall %', 'Desktop Avg %', 'Web Avg %', 'Training Loss']
-                elif 'desktop' in selected_metric:
-                    display_cols = ['steps', 'desktop_avg', 'desktop_text', 'desktop_icon', 'loss']
-                    col_labels = ['Steps', 'Desktop Avg %', 'Desktop Text %', 'Desktop Icon %', 'Training Loss']
-                elif 'web' in selected_metric:
-                    display_cols = ['steps', 'web_avg', 'web_text', 'web_icon', 'loss']
-                    col_labels = ['Steps', 'Web Avg %', 'Web Text %', 'Web Icon %', 'Training Loss']
-                elif 'text' in selected_metric:
-                    display_cols = ['steps', 'text_avg', 'desktop_text', 'web_text', 'loss']
-                    col_labels = ['Steps', 'Text Avg %', 'Desktop Text %', 'Web Text %', 'Training Loss']
-                elif 'icon' in selected_metric:
-                    display_cols = ['steps', 'icon_avg', 'desktop_icon', 'web_icon', 'loss']
-                    col_labels = ['Steps', 'Icon Avg %', 'Desktop Icon %', 'Web Icon %', 'Training Loss']
-                else:
-                    display_cols = ['steps', selected_metric, 'loss']
-                    col_labels = ['Steps', f'{metric_options[selected_metric]} %', 'Training Loss']
-                
-                display_metrics = metrics_df[display_cols].copy()
-                display_metrics.columns = col_labels
-                
-                # Format percentage columns
-                for col in col_labels:
-                    if '%' in col and col != 'Training Loss':
-                        display_metrics[col] = display_metrics[col].round(2)
-                
-                display_metrics['Training Loss'] = display_metrics['Training Loss'].apply(lambda x: f"{x:.4f}" if pd.notna(x) else "N/A")
-                st.dataframe(display_metrics, use_container_width=True)
-            else:
-                st.info("No models with multiple checkpoints available for progression analysis")
     
     else:
         # For non-ScreenSpot datasets, show a simple bar chart
@@ -772,7 +493,7 @@ def main():
             height=400
         )
         
-        chart_placeholder.altair_chart(chart, use_container_width=True)
+        st.altair_chart(chart, use_container_width=True)
 
 if __name__ == "__main__":
     main()