mode viz fix

app.py

@@ -805,9 +805,17 @@ with demo:
                             interactive=True,
                             visible=False
                         )
-                        model_selector = gr.Dropdown(
-                            choices=update_model_choices(CURRENT_VERSION),
-                            label="Select Models to Compare",
+                        # New: Mode selector
+                        def get_model_mode_choices(version):
+                            df = get_leaderboard_df(version=version)
+                            if df.empty:
+                                return []
+                            # Return list of tuples (model_name, mode)
+                            return sorted([f"{row['model_name']} [{row['mode']}]" for _, row in df.drop_duplicates(subset=["model_name", "mode"]).iterrows()])
+
+                        model_mode_selector = gr.Dropdown(
+                            choices=get_model_mode_choices(CURRENT_VERSION),
+                            label="Select Model(s) [Mode] to Compare",
                             multiselect=True,
                             interactive=True
                         )
@@ -830,18 +838,83 @@ with demo:
                 plot_output = gr.Plot()
 
                 # Update visualization when any selector changes
-                for control in [viz_version_selector, model_selector, category_selector, metric_selector]:
+                def update_visualization_with_mode(selected_model_modes, selected_category, selected_metric, version):
+                    if not selected_model_modes:
+                        return go.Figure()
+                    df = get_leaderboard_df(version=version) if selected_category == "All Results" else get_category_leaderboard_df(selected_category, version=version)
+                    if df.empty:
+                        return go.Figure()
+                    # Parse selected_model_modes into model_name and mode
+                    selected_pairs = [s.rsplit(" [", 1) for s in selected_model_modes]
+                    selected_pairs = [(name.strip(), mode.strip("] ")) for name, mode in selected_pairs]
+                    mask = df.apply(lambda row: (row['model_name'], str(row['mode'])) in selected_pairs, axis=1)
+                    filtered_df = df[mask]
+                    metric_cols = [col for col in filtered_df.columns if selected_metric in col]
+                    fig = go.Figure()
+                    colors = ['#8FCCCC', '#C2A4B6', '#98B4A6', '#B68F7C']
+                    for idx, (model_name, mode) in enumerate(selected_pairs):
+                        model_data = filtered_df[(filtered_df['model_name'] == model_name) & (filtered_df['mode'] == mode)]
+                        if not model_data.empty:
+                            values = model_data[metric_cols].values[0].tolist()
+                            values = values + [values[0]]
+                            categories = [col.replace(f'_{selected_metric}', '') for col in metric_cols]
+                            categories = categories + [categories[0]]
+                            fig.add_trace(go.Scatterpolar(
+                                r=values,
+                                theta=categories,
+                                name=f"{model_name} [{mode}]",
+                                line_color=colors[idx % len(colors)],
+                                fill='toself'
+                            ))
+                    fig.update_layout(
+                        paper_bgcolor='#000000',
+                        plot_bgcolor='#000000',
+                        font={'color': '#ffffff'},
+                        title={
+                            'text': f'{selected_category} - {selected_metric.upper()} Score Comparison',
+                            'font': {'color': '#ffffff', 'size': 24}
+                        },
+                        polar=dict(
+                            bgcolor='#000000',
+                            radialaxis=dict(
+                                visible=True,
+                                range=[0, 1],
+                                gridcolor='#333333',
+                                linecolor='#333333',
+                                tickfont={'color': '#ffffff'},
+                            ),
+                            angularaxis=dict(
+                                gridcolor='#333333',
+                                linecolor='#333333',
+                                tickfont={'color': '#ffffff'},
+                            )
+                        ),
+                        height=600,
+                        showlegend=True,
+                        legend=dict(
+                            yanchor="top",
+                            y=0.99,
+                            xanchor="right",
+                            x=0.99,
+                            bgcolor='rgba(0,0,0,0.5)',
+                            font={'color': '#ffffff'}
+                        )
+                    )
+                    return fig
+
+                # Connect selectors to update function
+                for control in [viz_version_selector, model_mode_selector, category_selector, metric_selector]:
                     control.change(
-                        fn=lambda sm, sc, s_metric, v: update_visualization(sm, CATEGORY_REVERSE_MAP.get(sc, sc), s_metric, v),
-                        inputs=[model_selector, category_selector, metric_selector, viz_version_selector],
+                        fn=lambda smm, sc, s_metric, v: update_visualization_with_mode(smm, CATEGORY_REVERSE_MAP.get(sc, sc), s_metric, v),
+                        inputs=[model_mode_selector, category_selector, metric_selector, viz_version_selector],
                         outputs=plot_output
                     )
 
-                # Update model choices when version changes
+                # Update model_mode_selector choices when version changes
                 viz_version_selector.change(
-                    fn=update_model_choices,
+                    fn=get_model_mode_choices,
                     inputs=[viz_version_selector],
-                    outputs=[model_selector]
+                    outputs=[model_mode_selector]
                 )
 
             # with gr.TabItem("About", elem_id="guardbench-about-tab", id=2):