update

app.py

@@ -2,70 +2,105 @@ import gradio as gr
 import pandas as pd
 import numpy as np
 
-# Sample data structure - replace this with your actual CSV loading
-# df = pd.read_csv('your_leaderboard_data.csv')
-
-# For demonstration, I'll create sample data matching your structure
+# Sample data based on your CSV structure
 data = {
-    'Model': ['Llama-3-70B-UltraMedical', 'MMed-Llama-3-8B', 'Llama-3.1-8B-UltraMedical', 'meditron-70b', 'meditron-7b'],
-    'Domain': ['Medical', 'Medical', 'Medical', 'Medical', 'Medical'],
-    'License': ['Llama-3', 'Llama-3', 'Llama-3', 'Apache 2.0', 'Apache 2.0'],
-    'Size (B)': [70, 8, 8, 70, 7],
-    'Size_Category': ['40-80', '5-10', '5-10', '40-80', '5-10'],  # Added for filtering
-    'Accessibility': ['Open Source', 'Open Source', 'Open Source', 'Open Source', 'Open Source'],
-    'Average Performance': [33.4, 20.37, 20.16, 15.68, 9.52],
-    'ADE-Identification': [77.96, 83.15, 64.43, 51.8, 39.01],
-    'BrainMRI-AIS': [95.91, 91.82, 92.48, 87.27, 64.47],
-    'Brateca-Hospitalization': [59.23, 55.1, 35.42, 43.18, 40.1]
+    'Model Name': [
+        'deepseek-ai/DeepSeek-R1-Distill-Qwen-14B',
+        'VIDraft/Gemma-3-R1984-27B',
+        'meta-llama/Llama-3.3-70B-Instruct',
+        'Qwen/Qwen3-30B-A3B',
+        'Qwen/Qwen3-4B',
+        'Qwen/Qwen3-32B',
+        'deepseek-ai/DeepSeek-R1-Distill-Llama-8B',
+        'Qwen/Qwen3-8B',
+        'Qwen/Qwen3-14B',
+        'google/gemma-3-27b-it',
+        'Qwen/Qwen2.5-VL-32B-Instruct',
+        'meta-llama/Llama-3.1-70B-Instruct',
+        'google/gemma-3-12b-it',
+        'google/gemma-3-4b-it',
+        'Qwen/Qwen3-1.7B'
+    ],
+    'Separate Grounding Score': [
+        0.817797, 0.93617, 0.842553, 0.812766, 0.770213, 0.740426,
+        0.766949, 0.748936, 0.778723, 0.936, 0.621277, 0.855932,
+        0.944, 0.9, 0.702128
+    ],
+    'Separate Quality Score': [
+        0.542373, 0.459574, 0.510638, 0.540426, 0.540426, 0.553191,
+        0.516949, 0.523404, 0.502128, 0.391, 0.570213, 0.389831,
+        0.343, 0.33, 0.451064
+    ],
+    'Combined Score': [
+        0.457627, 0.434043, 0.425532, 0.425532, 0.425532, 0.417021,
+        0.40678, 0.4, 0.382979, 0.378, 0.357447, 0.334746,
+        0.313, 0.3, 0.297872
+    ]
 }
 
+# Create DataFrame
 df = pd.DataFrame(data)
 
-def filter_and_search_models(search_query, domain_filter, size_ranges, accessibility_filter):
+# Extract size from model name for filtering
+def extract_size(model_name):
+    """Extract size from model name (e.g., '14B' -> 14)"""
+    import re
+    # Look for patterns like 14B, 1.7B, 70B, etc.
+    match = re.search(r'(\d+\.?\d*)B', model_name)
+    if match:
+        return float(match.group(1))
+    return 0
+
+df['Size'] = df['Model Name'].apply(extract_size)
+
+# Add size category for filtering
+def get_size_category(size):
+    if size <= 5:
+        return "0-5B"
+    elif size <= 10:
+        return "5-10B"
+    elif size <= 20:
+        return "10-20B"
+    elif size <= 40:
+        return "20-40B"
+    elif size <= 80:
+        return "40-80B"
+    else:
+        return ">80B"
+
+df['Size_Category'] = df['Size'].apply(get_size_category)
+
+def filter_and_search_models(search_query, size_ranges, sort_by):
     """Filter and search models based on user inputs"""
     filtered_df = df.copy()
     
     # Apply search filter
     if search_query:
-        mask = filtered_df['Model'].str.contains(search_query, case=False, na=False)
+        mask = filtered_df['Model Name'].str.contains(search_query, case=False, na=False)
         filtered_df = filtered_df[mask]
     
-    # Apply domain filter
-    if domain_filter:
-        if domain_filter == "Medical":
-            filtered_df = filtered_df[filtered_df['Domain'] == 'Medical']
-        elif domain_filter == "General":
-            filtered_df = filtered_df[filtered_df['Domain'] == 'General']
-    
     # Apply size range filter
     if size_ranges and len(size_ranges) > 0:
         filtered_df = filtered_df[filtered_df['Size_Category'].isin(size_ranges)]
     
-    # Apply accessibility filter
-    if accessibility_filter:
-        if accessibility_filter == "Open Source":
-            filtered_df = filtered_df[filtered_df['Accessibility'] == 'Open Source']
-        elif accessibility_filter == "Proprietary":
-            filtered_df = filtered_df[filtered_df['Accessibility'] == 'Proprietary']
+    # Sort by selected metric
+    if sort_by in filtered_df.columns:
+        filtered_df = filtered_df.sort_values(sort_by, ascending=False)
     
-    # Sort by Average Performance (descending)
-    filtered_df = filtered_df.sort_values('Average Performance', ascending=False)
-    
-    # Format the dataframe for display
-    display_df = filtered_df[['Model', 'Domain', 'License', 'Size (B)', 
-                              'Average Performance', 'ADE-Identification', 
-                              'BrainMRI-AIS', 'Brateca-Hospitalization']]
+    # Select only the columns to display
+    display_df = filtered_df[['Model Name', 'Separate Grounding Score', 
+                              'Separate Quality Score', 'Combined Score']]
     
     # Round numerical values for better display
-    for col in ['Average Performance', 'ADE-Identification', 'BrainMRI-AIS', 'Brateca-Hospitalization']:
-        display_df[col] = display_df[col].round(2)
+    for col in ['Separate Grounding Score', 'Separate Quality Score', 'Combined Score']:
+        display_df.loc[:, col] = display_df[col].round(6)
     
     return display_df
 
 # Create the Gradio interface
 with gr.Blocks(title="FACT Leaderboard", theme=gr.themes.Base()) as app:
     gr.Markdown("# 🏆 FACT Leaderboard")
-    gr.Markdown("### Filter and search medical AI models by performance metrics")
+    gr.Markdown("### Benchmark for evaluating factuality in language models")
     
     with gr.Row():
         with gr.Column(scale=1):
@@ -76,75 +111,71 @@ with gr.Blocks(title="FACT Leaderboard", theme=gr.themes.Base()) as app:
                 value=""
             )
             
-            # Domain filter
-            gr.Markdown("**Filter Model: Domain**")
-            domain_radio = gr.Radio(
-                choices=["All", "General", "Medical"],
-                value="All",
-                label="",
-                elem_classes="domain-filter"
-            )
-            
             # Size range filter
-            gr.Markdown("**Filter Model: Size Range**")
+            gr.Markdown("**Filter by Model Size**")
             size_checkboxes = gr.CheckboxGroup(
-                choices=["0-5", "5-10", "10-40", "40-80", ">80"],
-                value=["0-5", "5-10", "10-40", "40-80", ">80"],
+                choices=["0-5B", "5-10B", "10-20B", "20-40B", "40-80B", ">80B"],
+                value=["0-5B", "5-10B", "10-20B", "20-40B", "40-80B", ">80B"],
                 label="",
                 elem_classes="size-filter"
             )
             
-            # Accessibility filter
-            gr.Markdown("**Filter Model: Accessibility**")
-            accessibility_radio = gr.Radio(
-                choices=["All", "Open Source", "Proprietary"],
-                value="All",
+            # Sort by dropdown
+            gr.Markdown("**Sort by Metric**")
+            sort_dropdown = gr.Dropdown(
+                choices=["Combined Score", "Separate Grounding Score", "Separate Quality Score"],
+                value="Combined Score",
                 label="",
-                elem_classes="accessibility-filter"
+                elem_classes="sort-dropdown"
             )
+            
+            # Add legend/explanation
+            gr.Markdown("---")
+            gr.Markdown("**Metric Explanations:**")
+            gr.Markdown("""
+            - **Grounding Score**: Measures factual accuracy
+            - **Quality Score**: Measures response quality
+            - **Combined Score**: Overall performance metric
+            """)
         
         with gr.Column(scale=3):
             # Results table
             results_table = gr.Dataframe(
-                value=filter_and_search_models("", "All", ["0-5", "5-10", "10-40", "40-80", ">80"], "All"),
-                headers=["Model", "Model: Domain", "Model: License", "Size (B)", 
-                        "Average Performance", "ADE-Identification", 
-                        "BrainMRI-AIS", "Brateca-Hospitalization"],
-                datatype=["str", "str", "str", "number", "number", "number", "number", "number"],
+                value=filter_and_search_models("", ["0-5B", "5-10B", "10-20B", "20-40B", "40-80B", ">80B"], "Combined Score"),
+                headers=["Model Name", "Separate Grounding Score", 
+                        "Separate Quality Score", "Combined Score"],
+                datatype=["str", "number", "number", "number"],
                 elem_id="leaderboard-table",
                 interactive=False,
                 wrap=True
             )
+            
+            # Add statistics
+            total_models = gr.Markdown(f"**Total Models: {len(df)}**")
     
     # Update table when filters change
-    def update_table(search, domain, sizes, accessibility):
-        domain_val = None if domain == "All" else domain
-        accessibility_val = None if accessibility == "All" else accessibility
-        return filter_and_search_models(search, domain_val, sizes, accessibility_val)
+    def update_table(search, sizes, sort_by):
+        filtered_df = filter_and_search_models(search, sizes, sort_by)
+        model_count = f"**Total Models: {len(filtered_df)}**"
+        return filtered_df, model_count
     
     # Connect all inputs to the update function
     search_box.change(
         fn=update_table,
-        inputs=[search_box, domain_radio, size_checkboxes, accessibility_radio],
-        outputs=results_table
-    )
-    
-    domain_radio.change(
-        fn=update_table,
-        inputs=[search_box, domain_radio, size_checkboxes, accessibility_radio],
-        outputs=results_table
+        inputs=[search_box, size_checkboxes, sort_dropdown],
+        outputs=[results_table, total_models]
     )
     
     size_checkboxes.change(
         fn=update_table,
-        inputs=[search_box, domain_radio, size_checkboxes, accessibility_radio],
-        outputs=results_table
+        inputs=[search_box, size_checkboxes, sort_dropdown],
+        outputs=[results_table, total_models]
     )
     
-    accessibility_radio.change(
+    sort_dropdown.change(
         fn=update_table,
-        inputs=[search_box, domain_radio, size_checkboxes, accessibility_radio],
-        outputs=results_table
+        inputs=[search_box, size_checkboxes, sort_dropdown],
+        outputs=[results_table, total_models]
     )
     
     # Add custom CSS for better styling
@@ -153,24 +184,50 @@ with gr.Blocks(title="FACT Leaderboard", theme=gr.themes.Base()) as app:
         font-size: 14px;
     }
     
-    .domain-filter label,
-    .size-filter label,
-    .accessibility-filter label {
+    #leaderboard-table td:first-child {
+        font-weight: 500;
+    }
+    
+    #leaderboard-table td:not(:first-child) {
+        text-align: center;
+    }
+    
+    .size-filter label {
         display: flex;
         align-items: center;
         margin: 5px 0;
     }
     
-    .domain-filter input[type="radio"],
-    .accessibility-filter input[type="radio"] {
+    .size-filter input[type="checkbox"] {
         margin-right: 8px;
     }
     
-    .size-filter input[type="checkbox"] {
-        margin-right: 8px;
+    .sort-dropdown {
+        margin-top: 10px;
+    }
+    
+    /* Highlight rows based on model family */
+    #leaderboard-table tr:has(td:contains("meta-llama")) {
+        background-color: #fffbf0;
+    }
+    
+    #leaderboard-table tr:has(td:contains("deepseek")) {
+        background-color: #f0f8ff;
+    }
+    
+    #leaderboard-table tr:has(td:contains("Qwen")) {
+        background-color: #f0fff0;
+    }
+    
+    #leaderboard-table tr:has(td:contains("google")) {
+        background-color: #fff0f5;
     }
     """
 
+# To load from CSV file, replace the sample data with:
+# df = pd.read_csv('your_fact_leaderboard.csv')
+# Then add the Size extraction and Size_Category as shown above
+
 # Launch the app
 if __name__ == "__main__":
     app.launch(share=True)