Update leaderboard display

app.py

@@ -0,0 +1,803 @@
+import gradio as gr
+import json
+import pandas as pd
+import numpy as np
+import plotly.express as px
+import plotly.graph_objects as go
+from plotly.subplots import make_subplots
+import os
+import traceback
+from datetime import datetime
+from packaging import version
+
+# Color scheme for charts
+COLORS = px.colors.qualitative.Plotly
+
+# Line colors for radar charts
+line_colors = [
+    "#EE4266",
+    "#00a6ed",
+    "#ECA72C",
+    "#B42318",
+    "#3CBBB1",
+]
+
+# Fill colors for radar charts
+fill_colors = [
+    "rgba(238,66,102,0.05)",
+    "rgba(0,166,237,0.05)",
+    "rgba(236,167,44,0.05)",
+    "rgba(180,35,24,0.05)",
+    "rgba(60,187,177,0.05)",
+]
+
+# Define the question categories
+QUESTION_CATEGORIES = ["simple", "set", "mh", "cond", "comp"]
+METRIC_TYPES = ["retrieval", "generation"]
+
+def load_results():
+    """Load results from the results.json file."""
+    try:
+        # Get the directory of the current script
+        script_dir = os.path.dirname(os.path.abspath(__file__))
+        # Build the path to results.json
+        results_path = os.path.join(script_dir, 'results.json')
+        
+        print(f"Loading results from: {results_path}")
+        
+        with open(results_path, 'r', encoding='utf-8') as f:
+            results = json.load(f)
+            print(f"Successfully loaded results with {len(results.get('items', {}))} version(s)")
+            return results
+    except FileNotFoundError:
+        # Return empty structure if file doesn't exist
+        print(f"Results file not found, creating empty structure")
+        return {"items": {}, "last_version": "1.0", "n_questions": "0"}
+    except Exception as e:
+        print(f"Error loading results: {e}")
+        print(traceback.format_exc())
+        return {"items": {}, "last_version": "1.0", "n_questions": "0"}
+
+def filter_and_process_results(results, n_versions, only_actual_versions):
+    """Filter results by version and process them for display."""
+    if not results or "items" not in results:
+        return pd.DataFrame(), [], [], []
+    
+    all_items = results["items"]
+    last_version_str = results.get("last_version", "1.0")
+    last_version = version.parse(last_version_str)
+
+    print(f"Last version: {last_version_str}")
+    
+    # Group items by model_name
+    model_groups = {}
+
+    for version_str, version_items in all_items.items():
+        version_obj = version.parse(version_str)
+        for item_id, item in version_items.items():
+            model_name = item.get("model_name", "Unknown")
+            
+            if model_name not in model_groups:
+                model_groups[model_name] = []
+            
+            # Add version info to the item (both as string and as parsed version object for comparison)
+            item["version_str"] = version_str
+            item["version_obj"] = version_obj
+            model_groups[model_name].append(item)
+    
+    rows = []
+    for model_name, items in model_groups.items():
+        # Sort items by version (newest first)
+        items.sort(key=lambda x: x["version_obj"], reverse=True)
+        
+        # Filter versions based on selection
+        filtered_items = []
+        
+        if only_actual_versions:
+            # Get the n most recent actual dataset versions
+            all_versions = sorted([version.parse(v_str) for v_str in all_items.keys()], reverse=True)
+            # Take at most n_versions
+            versions_to_consider = all_versions[:n_versions] if all_versions else []
+            
+            # Filter items that match those versions
+            filtered_items = [item for item in items if any(item["version_obj"] == v for v in versions_to_consider)]
+        else:
+            # Consider n_versions most recent items for this model
+            filtered_items = items[:n_versions]
+        
+        if not filtered_items:
+            continue
+        
+        config = filtered_items[0]["config"]  # Use config from most recent version
+        
+        # Create row with basic info
+        row = {
+            'Model': model_name,
+            'Embeddings': config.get('embedding_model', 'N/A'),
+            'Retriever': config.get('retriever_type', 'N/A'),
+            'Top-K': config.get('retrieval_config', {}).get('top_k', 'N/A'),
+            'Versions': ", ".join([item["version_str"] for item in filtered_items]),
+            'Last Updated': filtered_items[0].get("timestamp", "")
+        }
+        
+        # Format timestamp if available
+        if row['Last Updated']:
+            try:
+                dt = datetime.fromisoformat(row['Last Updated'].replace('Z', '+00:00'))
+                row['Last Updated'] = dt.strftime("%Y-%m-%d")
+            except:
+                pass
+        
+        # Process metrics based on categories
+        category_metrics = {
+            category: {
+                metric_type: {
+                    "avg": 0.0,
+                    "count": 0
+                } for metric_type in METRIC_TYPES
+            } for category in QUESTION_CATEGORIES
+        }
+        
+        # Collect metrics by category
+        for item in filtered_items:
+            metrics = item.get("metrics", {})
+            for category in QUESTION_CATEGORIES:
+                if category in metrics:
+                    for metric_type in METRIC_TYPES:
+                        if metric_type in metrics[category]:
+                            metric_values = metrics[category][metric_type]
+                            avg_value = sum(metric_values.values()) / len(metric_values)
+                            
+                            # Add to the running sum for this category and metric type
+                            category_metrics[category][metric_type]["avg"] += avg_value
+                            category_metrics[category][metric_type]["count"] += 1
+        
+        # Calculate averages and add to row
+        for category in QUESTION_CATEGORIES:
+            for metric_type in METRIC_TYPES:
+                metric_data = category_metrics[category][metric_type]
+                if metric_data["count"] > 0:
+                    avg_value = metric_data["avg"] / metric_data["count"]
+                    # Add to row with appropriate column name
+                    col_name = f"{category}_{metric_type}"
+                    row[col_name] = round(avg_value, 4)
+        
+        # Calculate overall averages for each metric type
+        for metric_type in METRIC_TYPES:
+            total_sum = 0
+            total_count = 0
+            
+            for category in QUESTION_CATEGORIES:
+                metric_data = category_metrics[category][metric_type]
+                if metric_data["count"] > 0:
+                    total_sum += metric_data["avg"]
+                    total_count += metric_data["count"]
+            
+            if total_count > 0:
+                row[f"{metric_type}_avg"] = round(total_sum / total_count, 4)
+        
+        rows.append(row)
+    
+    # Create DataFrame
+    df = pd.DataFrame(rows)
+    
+    # Get lists of metrics for each category
+    category_metrics = []
+    for category in QUESTION_CATEGORIES:
+        metrics = []
+        for metric_type in METRIC_TYPES:
+            col_name = f"{category}_{metric_type}"
+            if col_name in df.columns:
+                metrics.append(col_name)
+        if metrics:
+            category_metrics.append((category, metrics))
+    
+    # Define retrieval and generation columns for radar charts
+    retrieval_metrics = [f"{category}_retrieval" for category in QUESTION_CATEGORIES if f"{category}_retrieval" in df.columns]
+    generation_metrics = [f"{category}_generation" for category in QUESTION_CATEGORIES if f"{category}_generation" in df.columns]
+    
+    return df, retrieval_metrics, generation_metrics, category_metrics
+
+def create_radar_chart(df, selected_models, metrics, title):
+    """Create a radar chart for the selected models and metrics."""
+    if not metrics or len(selected_models) == 0:
+        # Return empty figure if no metrics or models selected
+        fig = go.Figure()
+        fig.update_layout(
+            title=title,
+            title_font_size=16,
+            height=400,
+            width=500,
+            margin=dict(l=30, r=30, t=50, b=30)
+        )
+        return fig
+    
+    # Filter dataframe for selected models
+    filtered_df = df[df['Model'].isin(selected_models)]
+    
+    if filtered_df.empty:
+        # Return empty figure if no data
+        fig = go.Figure()
+        fig.update_layout(
+            title=title,
+            title_font_size=16,
+            height=400,
+            width=500,
+            margin=dict(l=30, r=30, t=50, b=30)
+        )
+        return fig
+    
+    # Limit to top 5 models for better visualization (similar to inspiration file)
+    if len(filtered_df) > 5:
+        filtered_df = filtered_df.head(5)
+    
+    # Prepare data for radar chart
+    categories = [m.split('_', 1)[0] for m in metrics]  # Get category name (simple, set, etc.)
+    
+    fig = go.Figure()
+    
+    # Process in reverse order to match inspiration file
+    for i, (_, row) in enumerate(filtered_df.iterrows()):
+        values = [row[m] for m in metrics]
+        # Close the loop for radar chart
+        values.append(values[0])
+        categories_loop = categories + [categories[0]]
+        
+        fig.add_trace(go.Scatterpolar(
+            name=row['Model'],
+            r=values,
+            theta=categories_loop,
+            showlegend=True,
+            mode="lines",
+            line=dict(width=2, color=line_colors[i % len(line_colors)]),
+            fill="toself",
+            fillcolor=fill_colors[i % len(fill_colors)]
+        ))
+    
+    fig.update_layout(
+        font=dict(size=13, color="black"),
+        template="plotly_white",
+        polar=dict(
+            radialaxis=dict(
+                visible=True,
+                gridcolor="black",
+                linecolor="rgba(0,0,0,0)",
+                gridwidth=1,
+                showticklabels=False,
+                ticks="",
+                range=[0, 1]  # Ensure consistent range for scores
+            ),
+            angularaxis=dict(
+                gridcolor="black", 
+                gridwidth=1.5, 
+                linecolor="rgba(0,0,0,0)"
+            ),
+        ),
+        legend=dict(
+            orientation="h",
+            yanchor="bottom",
+            y=-0.35,
+            xanchor="center",
+            x=0.4,
+            itemwidth=30,
+            font=dict(size=13),
+            entrywidth=0.6,
+            entrywidthmode="fraction",
+        ),
+        margin=dict(l=0, r=16, t=30, b=30),
+        autosize=True,
+    )
+    
+    return fig
+
+def create_summary_df(df, retrieval_metrics, generation_metrics):
+    """Create a summary dataframe with averaged metrics for display."""
+    if df.empty:
+        return pd.DataFrame()
+    
+    summary_df = df.copy()
+    
+    # Add retrieval average
+    if retrieval_metrics:
+        retrieval_avg = summary_df[retrieval_metrics].mean(axis=1).round(4)
+        summary_df['Retrieval (avg)'] = retrieval_avg
+    
+    # Add generation average
+    if generation_metrics:
+        generation_avg = summary_df[generation_metrics].mean(axis=1).round(4)
+        summary_df['Generation (avg)'] = generation_avg
+    
+    # Add total score if both averages exist
+    if 'Retrieval (avg)' in summary_df.columns and 'Generation (avg)' in summary_df.columns:
+        summary_df['Total Score'] = summary_df['Retrieval (avg)'] + summary_df['Generation (avg)']
+        summary_df = summary_df.sort_values('Total Score', ascending=False)
+    
+    # Select columns for display
+    summary_cols = ['Model', 'Embeddings', 'Retriever', 'Top-K']
+    if 'Retrieval (avg)' in summary_df.columns:
+        summary_cols.append('Retrieval (avg)')
+    if 'Generation (avg)' in summary_df.columns:
+        summary_cols.append('Generation (avg)')
+    if 'Total Score' in summary_df.columns:
+        summary_cols.append('Total Score')
+    if 'Versions' in summary_df.columns:
+        summary_cols.append('Versions')
+    if 'Last Updated' in summary_df.columns:
+        summary_cols.append('Last Updated')
+    
+    return summary_df[summary_cols]
+
+def create_category_df(df, category, retrieval_col, generation_col):
+    """Create a dataframe for a specific category with detailed metrics."""
+    if df.empty or retrieval_col not in df.columns or generation_col not in df.columns:
+        return pd.DataFrame()
+    
+    category_df = df.copy()
+    
+    # Calculate total score for this category
+    category_df[f'{category} Score'] = category_df[retrieval_col] + category_df[generation_col]
+    
+    # Sort by total score
+    category_df = category_df.sort_values(f'{category} Score', ascending=False)
+    
+    # Select columns for display
+    category_cols = ['Model', 'Embeddings', 'Retriever', retrieval_col, generation_col, f'{category} Score']
+    
+    # Rename columns for display
+    category_df = category_df[category_cols].rename(columns={
+        retrieval_col: 'Retrieval',
+        generation_col: 'Generation'
+    })
+    
+    return category_df
+
+# Load initial data
+results = load_results()
+last_version = results.get("last_version", "1.0")
+n_questions = results.get("n_questions", "100")
+date_title = results.get("date_title", "---")
+
+# Initial data processing
+df, retrieval_metrics, generation_metrics, category_metrics = filter_and_process_results(
+    results, n_versions=1, only_actual_versions=True
+)
+
+# Pre-generate charts for initial display
+default_models = df['Model'].head(5).tolist() if not df.empty else []
+initial_gen_chart = create_radar_chart(df, default_models, generation_metrics, "Performance on Generation Tasks")
+initial_ret_chart = create_radar_chart(df, default_models, retrieval_metrics, "Performance on Retrieval Tasks")
+
+# Create summary dataframe
+summary_df = create_summary_df(df, retrieval_metrics, generation_metrics)
+
+with gr.Blocks(css="""
+    .title-container { 
+        text-align: center; 
+        margin-bottom: 10px; 
+    }
+    .description-text {
+        text-align: left;
+        padding: 10px;
+        margin-bottom: 0px;
+    }
+    .version-info {
+        text-align: center;
+        padding: 10px;
+        background-color: #f0f0f0;
+        border-radius: 8px;
+        margin-bottom: 15px;
+    }
+    .version-selector {
+        padding: 15px;
+        border: 1px solid #ddd;
+        border-radius: 8px;
+        margin-bottom: 20px;
+        background-color: #f9f9f9;
+        height: 100%;
+    }
+    .citation-block {
+        padding: 15px;
+        border: 1px solid #ddd;
+        border-radius: 8px;
+        margin-bottom: 20px;
+        background-color: #f9f9f9;
+        font-family: monospace;
+        font-size: 14px;
+        overflow-x: auto;
+        height: 100%;
+    }
+    .flex-row-container {
+        display: flex;
+        justify-content: space-between;
+        gap: 20px;
+        width: 100%;
+    }
+    .charts-container {
+        display: flex;
+        gap: 20px;
+        margin-bottom: 20px;
+    }
+    .chart-box {
+        flex: 1;
+        border: 1px solid #eee;
+        border-radius: 8px;
+        padding: 10px;
+        background-color: white;
+        min-height: 550px; /* Increased height to accommodate legend at bottom */
+    }
+    .metrics-table {
+        border: 1px solid #eee;
+        border-radius: 8px;
+        padding: 15px;
+        background-color: white;
+    }
+    .info-text {
+        font-size: 0.9em;
+        font-style: italic;
+        color: #666;
+        margin-top: 5px;
+    }
+    footer {
+        text-align: center;
+        margin-top: 30px;
+        font-size: 0.9em;
+        color: #666;
+    }
+    /* Style for selected rows */
+    table tbody tr.selected {
+        background-color: rgba(25, 118, 210, 0.1) !important;
+        border-left: 3px solid #1976d2;
+    }
+    /* Add this class via JavaScript */
+    .gr-table tbody tr.selected td:first-child {
+        font-weight: bold;
+        color: #1976d2;
+    }
+    .category-tab {
+        padding: 10px;
+    }
+    .chart-title {
+        font-size: 1.2em;
+        font-weight: bold;
+        margin-bottom: 10px;
+        text-align: center;
+    }
+    .clear-charts-button {
+        display: flex;
+        justify-content: center;
+        margin-top: 10px;
+        margin-bottom: 20px;
+    }
+""") as demo:
+    # Title
+    with gr.Row(elem_classes=["title-container"]):
+        gr.Markdown("# 🐙 Dynamic RAG Benchmark")
+
+    # Version info
+    with gr.Row(elem_classes=["description-text"]):
+        gr.Markdown(f"На этом лидерборде можно сравнить RAG системы в разрезе генеративных и поисковых метрик моделей по вопросам разного типа (простые вопросы, сравнения, multi-hop, условные и др.). <li>Вопросы автоматичеки генерируются на основе новостных источников.</li><li>Обновление датасета с вопросами происходит регулярно, при этом пересчитываются все метрики для открытых моделей.</li><li>Для пользовательских сабмитов учитываются последние посчитанные для них метрики.</li><li>Чтобы посчитать ранее отправленную конфигурацию на последней версии данных, используйте submit_id, полученный при первой отправке через клиент (см. инструкцию ниже).</li>")
+    
+    # Version info
+    with gr.Row(elem_classes=["version-info"]):
+        gr.Markdown(f"## Версия {last_version} → {n_questions} вопросов, сгенерированных по новостным источникам → {date_title}")
+    
+    # Radar Charts
+    with gr.Row(elem_classes=["charts-container"]):
+        with gr.Column(elem_classes=["chart-box"]):
+            gr.Markdown("### Генеративные метрики", elem_classes=["chart-title"])
+            generation_chart = gr.Plot(value=initial_gen_chart)
+        
+        with gr.Column(elem_classes=["chart-box"]):
+            gr.Markdown("### Метрики поиска", elem_classes=["chart-title"])
+            retrieval_chart = gr.Plot(value=initial_ret_chart)
+    
+    # Clear Charts Button
+    with gr.Row(elem_classes=["clear-charts-button"]):
+        clear_charts_btn = gr.Button("Очистить графики", variant="secondary")
+    
+    # Metrics table with tabs
+    with gr.Tabs(elem_classes=["metrics-table"]) as metrics_tabs:
+        with gr.TabItem("Общая таблица"):
+            selected_models = gr.State(default_models)
+            
+            # If dataframe is empty, show a message
+            if df.empty:
+                gr.Markdown("No data available. Please submit some results.")
+                metrics_table = gr.DataFrame()
+            else:
+                metrics_table = gr.DataFrame(
+                    value=summary_df,
+                    headers=summary_df.columns.tolist(),
+                    datatype=["str"] * len(summary_df.columns),
+                    row_count=(min(10, len(summary_df)) if not summary_df.empty else 0),
+                    col_count=(len(summary_df.columns) if not summary_df.empty else 0),
+                    interactive=False,
+                    wrap=True
+                )
+        
+        with gr.TabItem("По типам вопросов"):
+            # Create tabs for each category
+            category_tabs = gr.Tabs()
+            category_tables = {}
+            
+            # Dictionary to map category codes to display names
+            category_display_names = {
+                "simple": "Simple Questions",
+                "set": "Set-based",
+                "mh": "Multi-hop",
+                "cond": "Conditional",
+                "comp": "Comparison"
+            }
+            
+            with category_tabs:
+                for category, _ in category_metrics:
+                    if f"{category}_retrieval" in df.columns and f"{category}_generation" in df.columns:
+                        with gr.TabItem(category_display_names.get(category, category.capitalize()), elem_classes=["category-tab"]):
+                            # Create dataframe for this category
+                            category_df = create_category_df(df, category, f"{category}_retrieval", f"{category}_generation")
+                            
+                            if category_df.empty:
+                                gr.Markdown(f"No data available for {category_display_names.get(category, category)} category.")
+                                category_tables[category] = gr.DataFrame()
+                            else:
+                                gr.Markdown(f"#### Performance on {category_display_names.get(category, category)}")
+                                category_tables[category] = gr.DataFrame(
+                                    value=category_df,
+                                    headers=category_df.columns.tolist(),
+                                    datatype=["str"] * len(category_df.columns),
+                                    row_count=(min(10, len(category_df)) if not category_df.empty else 0),
+                                    col_count=(len(category_df.columns) if not category_df.empty else 0),
+                                    interactive=False,
+                                    wrap=True
+                                )
+    
+    # Version selector and Citation block in a flex container
+    with gr.Row():
+        # Citation block (left side)
+        with gr.Column(scale=1, elem_classes=["citation-block"]):
+            gr.Markdown("### Цитирование")
+            gr.Markdown("""
+            ```
+            @article{dynamic-rag-benchmark,
+              title={Dynamic RAG Benchmark},
+              author={RAG Benchmark Team},
+              journal={arXiv preprint},
+              year={2024},
+              url={https://github.com/rag-benchmark}
+            }
+            ```
+            
+            Шаблон для цитирования нашего бенча.
+            """)
+        
+        # Version selector (right side)
+        with gr.Column(scale=1, elem_classes=["version-selector"]):
+            gr.Markdown("### Выбор версий")
+            with gr.Column():
+                with gr.Row():
+                    with gr.Column(scale=3):
+                        only_actual_versions = gr.Checkbox(
+                            label="Только актуальные версии", 
+                            value=True,
+                            info="Считать, начиная с актуальной версии датасета"
+                        ) 
+                    with gr.Column(scale=5):
+                        n_versions_slider = gr.Slider(
+                            minimum=1, 
+                            maximum=5, 
+                            value=1, 
+                            step=1, 
+                            label="Взять n последних версий",
+                            info="Количество версий для подсчета метрик"
+                        )
+                with gr.Row():
+                    filter_btn = gr.Button("Применить фильтр", variant="primary")
+                
+                gr.Markdown(
+                    "Кликайте на модели в таблице, чтобы добавить их в графики", 
+                    elem_classes=["info-text"]
+                )
+    
+    # Footer
+    with gr.Row():
+        gr.Markdown("""
+        <footer>Dynamic RAG Benchmark Leaderboard</footer>
+        """)
+    
+    # Handle row selection for radar charts
+    def update_charts(evt: gr.SelectData, selected_models):
+        try:
+            # Get current data with the latest filters
+            current_df, current_ret_metrics, current_gen_metrics, _ = filter_and_process_results(
+                results, n_versions=n_versions_slider.value, only_actual_versions=only_actual_versions.value
+            )
+            
+            # Debug info
+            print(f"Selection event: {evt}, type: {type(evt)}")
+            
+            selected_model = None
+            
+            # Extract the selected model based on the row index
+            try:
+                # Get the table component that was clicked
+                component = evt.target
+                
+                # Get the row index
+                row_idx = evt.index[0] if isinstance(evt.index, list) else evt.index
+                print(f"Row index: {row_idx}")
+                
+                # Determine what type of data we're dealing with and extract model name
+                # First check if it's a summary table
+                if component is metrics_table:
+                    # Summary table was clicked
+                    if isinstance(summary_df, pd.DataFrame) and 0 <= row_idx < len(summary_df):
+                        selected_model = summary_df.iloc[row_idx]['Model']
+                    print(f"Selected from summary table: {selected_model}")
+                else:
+                    # Check if it's a category table
+                    for category, table in category_tables.items():
+                        if component is table:
+                            # Get the category dataframe
+                            category_df = create_category_df(
+                                current_df, 
+                                category, 
+                                f"{category}_retrieval", 
+                                f"{category}_generation"
+                            )
+                            
+                            if isinstance(category_df, pd.DataFrame) and 0 <= row_idx < len(category_df):
+                                selected_model = category_df.iloc[row_idx]['Model']
+                            print(f"Selected from {category} table: {selected_model}")
+                            break
+                
+                # If we still couldn't identify the model, try to get it from the raw data
+                if selected_model is None and hasattr(component, "value"):
+                    table_value = component.value
+                    if isinstance(table_value, pd.DataFrame) and 0 <= row_idx < len(table_value):
+                        selected_model = table_value.iloc[row_idx]['Model']
+                    elif isinstance(table_value, list) and 0 <= row_idx < len(table_value):
+                        selected_model = table_value[row_idx][0]  # Assuming Model is the first column
+                    elif isinstance(table_value, dict) and 'data' in table_value and 0 <= row_idx < len(table_value['data']):
+                        selected_model = table_value['data'][row_idx][0]
+            except Exception as e:
+                print(f"Error extracting model name: {e}")
+                traceback.print_exc()
+            
+            # If we found a model name, toggle its selection
+            if selected_model:
+                print(f"Selected model: {selected_model}")
+                
+                # Make sure the model exists in the current dataframe
+                available_models = current_df['Model'].tolist() if not current_df.empty else []
+                
+                if selected_model in available_models:
+                    # Add to list if not already there, otherwise remove (toggle selection)
+                    if selected_model in selected_models:
+                        selected_models.remove(selected_model)
+                    else:
+                        selected_models.append(selected_model)
+                else:
+                    print(f"Model {selected_model} not found in current dataframe")
+            
+            # Ensure only models from the current dataframe are included
+            available_models = current_df['Model'].tolist() if not current_df.empty else []
+            selected_models = [model for model in selected_models if model in available_models]
+            
+            # If no models are selected after filtering, use the first available model
+            if not selected_models and available_models:
+                selected_models = [available_models[0]]
+            
+            # Create radar charts using the current dataframe and metrics
+            gen_chart = create_radar_chart(current_df, selected_models, current_gen_metrics, "Performance on Generation Tasks")
+            ret_chart = create_radar_chart(current_df, selected_models, current_ret_metrics, "Performance on Retrieval Tasks")
+            
+            return selected_models, gen_chart, ret_chart
+        except Exception as e:
+            print(f"Error in update_charts: {e}")
+            print(traceback.format_exc())
+            return selected_models, generation_chart.value, retrieval_chart.value
+    
+    # Use custom event handler for row selection
+    metrics_table.select(
+        fn=update_charts,
+        inputs=[selected_models],
+        outputs=[selected_models, generation_chart, retrieval_chart]
+    )
+    
+    # Add selection handlers for category tables too
+    for category_table in category_tables.values():
+        category_table.select(
+            fn=update_charts,
+            inputs=[selected_models],
+            outputs=[selected_models, generation_chart, retrieval_chart]
+        )
+    
+    # Handle version filter changes
+    def update_data(n_versions, only_actual, current_selected_models):
+        try:
+            # Get updated data
+            new_df, new_ret_metrics, new_gen_metrics, new_category_metrics = filter_and_process_results(
+                results, n_versions=n_versions, only_actual_versions=only_actual
+            )
+            
+            # Get available models
+            available_models = new_df['Model'].tolist() if not new_df.empty else []
+            
+            # Filter selected models to only include those that exist in the new dataset
+            filtered_selected_models = [model for model in current_selected_models if model in available_models]
+            
+            # If no previously selected models remain, select the top models
+            if not filtered_selected_models and available_models:
+                filtered_selected_models = available_models[:min(5, len(available_models))]
+            
+            # Create radar charts
+            gen_chart = create_radar_chart(new_df, filtered_selected_models, new_gen_metrics, "Performance on Generation Tasks")
+            ret_chart = create_radar_chart(new_df, filtered_selected_models, new_ret_metrics, "Performance on Retrieval Tasks")
+            
+            # Create summary dataframe
+            summary_df = create_summary_df(new_df, new_ret_metrics, new_gen_metrics)
+            
+            # Create category tables dictionary for output
+            category_tables_output = {}
+            
+            # First initialize all tables to empty DataFrame
+            for category in category_tables.keys():
+                category_tables_output[category] = pd.DataFrame()
+            
+            # Then populate available tables
+            for category, _ in new_category_metrics:
+                if f"{category}_retrieval" in new_df.columns and f"{category}_generation" in new_df.columns:
+                    category_df = create_category_df(new_df, category, f"{category}_retrieval", f"{category}_generation")
+                    if category in category_tables:
+                        category_tables_output[category] = category_df if not category_df.empty else pd.DataFrame()
+            
+            # Prepare all outputs
+            outputs = [summary_df, gen_chart, ret_chart, filtered_selected_models]
+            
+            # Add category tables to outputs in the same order as in category_tables
+            for category in category_tables.keys():
+                outputs.append(category_tables_output.get(category, pd.DataFrame()))
+            
+            # Update global df for later use
+            global df, retrieval_metrics, generation_metrics
+            df = new_df
+            retrieval_metrics = new_ret_metrics
+            generation_metrics = new_gen_metrics
+            
+            return outputs
+        except Exception as e:
+            print(f"Error in update_data: {e}")
+            print(traceback.format_exc())
+            # Return original values in case of error
+            empty_tables = [pd.DataFrame() for _ in category_tables]
+            return summary_df, generation_chart.value, retrieval_chart.value, current_selected_models, *empty_tables
+    
+    # Define filter button outputs
+    filter_outputs = [metrics_table, generation_chart, retrieval_chart, selected_models]
+    # Add category tables to outputs
+    for category_table in category_tables.values():
+        filter_outputs.append(category_table)
+    
+    filter_btn.click(
+        fn=update_data,
+        inputs=[n_versions_slider, only_actual_versions, selected_models],
+        outputs=filter_outputs
+    )
+    
+    # Function to clear charts
+    def clear_charts():
+        empty_models = []
+        # Create empty charts
+        empty_gen_chart = create_radar_chart(df, empty_models, generation_metrics, "Performance on Generation Tasks")
+        empty_ret_chart = create_radar_chart(df, empty_models, retrieval_metrics, "Performance on Retrieval Tasks")
+        return empty_models, empty_gen_chart, empty_ret_chart
+    
+    # Connect clear charts button
+    clear_charts_btn.click(
+        fn=clear_charts,
+        inputs=[],
+        outputs=[selected_models, generation_chart, retrieval_chart]
+    )
+
+if __name__ == "__main__":
+    demo.launch()