app.py

import gradio as gr
import plotly.graph_objects as go
import pandas as pd


def create_sota_plot(df, metric='accuracy'):
    """
    Create a plot showing model performance evolution over time for a selected metric.

    Parameters:
    df: DataFrame with columns ['model_name', 'release_date', and metric columns]
    metric: The metric column to visualize
    """
    # Sort by release date to ensure chronological order
    df_sorted = df.sort_values('release_date').copy()

    # Calculate cumulative best (SOTA) for the selected metric
    df_sorted['cumulative_best'] = df_sorted[metric].cummax()

    # Identify which models are SOTA (where metric equals cumulative best)
    df_sorted['is_sota'] = df_sorted[metric] == df_sorted['cumulative_best']

    # Get SOTA models for the line
    sota_df = df_sorted[df_sorted['is_sota']].copy()

    # Create the plot
    fig = go.Figure()

    # Add all models as scatter points (gray for non-SOTA, cyan for SOTA)
    fig.add_trace(go.Scatter(
        x=df_sorted['release_date'],
        y=df_sorted[metric],
        mode='markers',
        name='All models',
        marker=dict(
            color=['#00CED1' if is_sota else 'lightgray'
                   for is_sota in df_sorted['is_sota']],
            size=8,
            opacity=0.7
        ),
        text=df_sorted['model_name'],
        hovertemplate=f'<b>%{{text}}</b><br>Date: %{{x}}<br>{metric.capitalize()}: %{{y:.2f}}<extra></extra>'
    ))

    # Add SOTA line (cumulative best)
    fig.add_trace(go.Scatter(
        x=df_sorted['release_date'],
        y=df_sorted['cumulative_best'],
        mode='lines',
        name='State-of-the-art (cumulative best)',
        line=dict(color='#00CED1', width=2, dash='solid'),
        hovertemplate=f'SOTA {metric.capitalize()}: %{{y:.2f}}<br>Date: %{{x}}<extra></extra>'
    ))

    # Add labels for SOTA models (models that improved the best score)
    for _, row in sota_df.iterrows():
        fig.add_annotation(
            x=row['release_date'],
            y=row[metric],
            text=row['model_name'],
            showarrow=True,
            arrowhead=2,
            arrowsize=1,
            arrowwidth=1,
            arrowcolor='gray',
            ax=0,
            ay=-30,
            font=dict(size=10)
        )

    # Update layout
    fig.update_layout(
        title=f'Evolution of Model Performance Over Time - {metric.upper()}',
        xaxis_title='Release Date',
        yaxis_title=f'{metric.capitalize()} Score',
        xaxis=dict(
            showgrid=True,
            gridcolor='lightgray'
        ),
        yaxis=dict(
            showgrid=True,
            gridcolor='lightgray'
        ),
        plot_bgcolor='white',
        paper_bgcolor='white',
        height=600,
        legend=dict(
            yanchor="top",
            y=0.99,
            xanchor="left",
            x=0.01
        ),
        hovermode='closest'
    )

    return fig


def create_sample_dataframe():
    """
    Create a sample DataFrame with multiple metrics for model performance.
    """
    # Create sample data with multiple metrics
    data = {
        'model_name': [
            'SIFT + FVs', 'AlexNet', 'VGG-16', 'GoogLeNet', 'ResNet-50',
            'SPPNet', 'Inception V2', 'Inception V3', 'ResNet-152', 'DenseNet',
            'MobileNet', 'NASNET-A(6)', 'EfficientNet', 'Vision Transformer',
            'CoAtNet-7', 'CLIP', 'DALL-E', 'GPT-Vision', 'Model-X', 'Model-Y',
            # Add some models that don't improve SOTA
            'SmallNet-1', 'SmallNet-2', 'BasicCNN', 'SimpleDNN', 'QuickNet',
            'FastNet', 'LiteModel', 'CompactNet', 'MiniVGG', 'TinyResNet'
        ],
        'release_date': pd.to_datetime([
            '2012-01-15', '2012-09-30', '2014-04-10', '2014-09-17', '2015-12-10',
            '2014-06-18', '2015-02-11', '2015-12-02', '2016-05-11', '2016-08-25',
            '2017-04-17', '2017-11-04', '2019-05-28', '2020-10-22',
            '2021-06-09', '2021-01-05', '2021-01-05', '2022-03-14', '2022-07-20', '2022-11-15',
            # Dates for non-SOTA models
            '2013-03-10', '2013-07-22', '2014-01-15', '2015-03-20', '2016-02-14',
            '2017-06-30', '2018-09-12', '2019-02-28', '2020-04-15', '2021-08-30'
        ]),
        'accuracy': [
            53.0, 65.0, 71.5, 74.8, 76.0,
            74.0, 78.0, 81.0, 77.8, 79.2,
            70.6, 82.7, 84.3, 85.2,
            90.88, 86.5, 87.0, 87.79, 87.73, 88.1,
            # Scores for non-SOTA models
            58.0, 62.0, 68.0, 72.0, 73.5,
            75.0, 78.5, 80.0, 82.0, 84.0
        ],
        'top5_accuracy': [
            71.0, 82.0, 89.5, 91.2, 92.5,
            91.0, 93.5, 95.0, 94.0, 94.5,
            89.5, 96.2, 97.1, 97.5,
            98.5, 97.8, 98.0, 98.2, 98.1, 98.3,
            # Top-5 scores for non-SOTA models
            75.0, 80.0, 85.0, 88.0, 90.0,
            91.5, 93.0, 95.5, 96.0, 96.5
        ],
        'parameters_millions': [
            0.5, 62, 138, 6.8, 25.6,
            21.0, 11.2, 23.8, 60.3, 7.9,
            4.2, 88.9, 66.0, 86.0,
            2185.0, 428.0, 1200.0, 1750.0, 890.0, 920.0,
            # Parameters for non-SOTA models
            2.5, 3.8, 15.0, 8.5, 5.2,
            12.0, 3.5, 6.7, 9.0, 11.5
        ],
        'flops_billions': [
            0.1, 1.5, 15.5, 1.5, 3.8,
            2.5, 2.0, 5.7, 11.3, 2.8,
            0.57, 23.8, 9.9, 16.9,
            420.0, 85.0, 250.0, 380.0, 180.0, 195.0,
            # FLOPs for non-SOTA models
            0.3, 0.5, 2.0, 1.2, 0.8,
            1.8, 0.4, 1.0, 1.5, 2.2
        ],
        'inference_time_ms': [
            85, 23, 45, 28, 35,
            32, 26, 30, 48, 38,
            18, 65, 42, 55,
            120, 75, 95, 110, 88, 92,
            # Inference time for non-SOTA models
            15, 20, 30, 25, 22,
            28, 12, 18, 24, 35
        ]
    }

    return pd.DataFrame(data)


# Create Gradio interface
with gr.Blocks(theme=gr.themes.Soft()) as demo:
    gr.Markdown("# State-of-the-Art Models Timeline with Multiple Metrics")
    gr.Markdown("""
    This visualization shows the evolution of model performance over time across different metrics.
    Use the dropdown to switch between metrics. The line represents the cumulative best (SOTA) score achieved up to each point in time.
    """)

    # Create the main DataFrame inline
    df_main = create_sample_dataframe()

    # Get available metrics (exclude non-metric columns)
    metric_columns = [col for col in df_main.columns if col not in ['model_name', 'release_date']]

    # Create layout with dropdown in upper right
    with gr.Row():
        with gr.Column(scale=3):
            # Display data info
            gr.Markdown(f"**Total models in dataset:** {len(df_main)}")
            gr.Markdown(
                f"**Date range:** {df_main['release_date'].min().date()} to {df_main['release_date'].max().date()}")
        with gr.Column(scale=1):
            metric_dropdown = gr.Dropdown(
                choices=metric_columns,
                value='accuracy',
                label="Select Metric",
                interactive=True
            )

    plot = gr.Plot(label="Model Performance Evolution")


    # Function to update plot and statistics
    def update_plot_and_stats(selected_metric):
        fig = create_sota_plot(df_main, selected_metric)
        best_value = df_main[selected_metric].max()
        best_model = df_main.loc[df_main[selected_metric].idxmax(), 'model_name']

        # Format statistics based on metric type
        if selected_metric == 'parameters_millions':
            stats_text = f"**Best {selected_metric.replace('_', ' ').title()}:** {best_value:.1f}M ({best_model})"
        elif selected_metric == 'flops_billions':
            stats_text = f"**Best {selected_metric.replace('_', ' ').title()}:** {best_value:.1f}B ({best_model})"
        elif selected_metric == 'inference_time_ms':
            stats_text = f"**Best {selected_metric.replace('_', ' ').title()}:** {best_value:.1f}ms ({best_model})"
        else:
            stats_text = f"**Best {selected_metric.replace('_', ' ').title()}:** {best_value:.2f}% ({best_model})"

        return fig, stats_text


    # Display best score for selected metric
    metric_stats = gr.Markdown()

    # Create plot on load
    demo.load(
        fn=lambda: update_plot_and_stats('accuracy'),
        outputs=[plot, metric_stats]
    )

    # Update plot when metric changes
    metric_dropdown.change(
        fn=update_plot_and_stats,
        inputs=metric_dropdown,
        outputs=[plot, metric_stats]
    )

    # Add interactive controls
    with gr.Row():
        show_data_btn = gr.Button("Show/Hide DataFrame")
        export_stats_btn = gr.Button("Export Statistics")

    # DataFrame display (initially hidden)
    df_display = gr.Dataframe(
        value=df_main,
        label="Model Performance Data",
        visible=False
    )


    def toggle_dataframe():
        return gr.Dataframe(value=df_main, visible=True)


    def export_statistics():
        stats = []
        for metric in metric_columns:
            best_value = df_main[metric].max()
            best_model = df_main.loc[df_main[metric].idxmax(), 'model_name']
            avg_value = df_main[metric].mean()
            stats.append({
                'Metric': metric.replace('_', ' ').title(),
                'Best Value': f"{best_value:.2f}",
                'Best Model': best_model,
                'Average': f"{avg_value:.2f}"
            })
        stats_df = pd.DataFrame(stats)
        return gr.Dataframe(value=stats_df, visible=True)


    stats_display = gr.Dataframe(
        label="Statistics Summary",
        visible=False
    )

    show_data_btn.click(
        fn=toggle_dataframe,
        outputs=df_display
    )

    export_stats_btn.click(
        fn=export_statistics,
        outputs=stats_display
    )

    gr.Markdown("""
    ### About this visualization:
    - **Metric Selector**: Use the dropdown in the upper right to switch between different performance metrics
    - **Cyan line**: Cumulative best (SOTA) score over time for the selected metric
    - **Cyan dots**: Models that achieved a new SOTA when released
    - **Gray dots**: Other models that didn't beat the existing SOTA
    - **Hover over points**: See model names, release dates, and metric values

    ### Available Metrics:
    - **Accuracy**: Top-1 accuracy on ImageNet (%)
    - **Top5 Accuracy**: Top-5 accuracy on ImageNet (%)
    - **Parameters (Millions)**: Model size in millions of parameters
    - **FLOPs (Billions)**: Computational cost in billions of operations
    - **Inference Time (ms)**: Time to process a single image
    """)

demo.launch()