Update app.py

app.py

@@ -3,164 +3,186 @@ import plotly.graph_objects as go
 import numpy as np
 import pandas as pd
 
-
-def create_sota_plot():
-    # State-of-the-art models data
-    sota_models = {
-        'SIFT + FVs': (2012, 53),
-        'AlexNet': (2012.5, 65),
-        'SPPNet': (2014.5, 74),
-        'Inception V3': (2015.5, 81),
-        'NASNET-A(6)': (2017, 82.7),
-        'CoAtNet-7': (2021.5, 90.88),
-        '': (2022, 87.79),  # Last point
-        '': (2022.2, 87.73)  # Final value shown
-    }
-
-    # Extract data for SOTA models
-    sota_years = [year for year, _ in sota_models.values() if year != '']
-    sota_accuracy = [acc for _, acc in sota_models.values() if acc != '']
-    sota_labels = [name for name in sota_models.keys() if name != '']
-
-    # Generate synthetic "other models" data (gray points)
-    np.random.seed(42)
-    n_other = 300
-    other_years = np.random.uniform(2010, 2023, n_other)
-    # Create a distribution that's mostly below SOTA but with some variance
-    other_accuracy = []
-    for year in other_years:
-        # Find approximate SOTA accuracy for this year
-        sota_at_year = np.interp(year, sota_years[:len(sota_accuracy)], sota_accuracy[:len(sota_accuracy)])
-        # Add models mostly below SOTA with some variance
-        if year < 2012:
-            acc = np.random.normal(45, 8)
-        else:
-            acc = np.random.normal(sota_at_year - 10, 5)
-            # Some models can be close to SOTA
-            if np.random.random() < 0.1:
-                acc = sota_at_year - np.random.uniform(0, 3)
-        other_accuracy.append(max(30, min(92, acc)))  # Clip to reasonable range
-
+def create_sota_plot(df):
+    """
+    Create a plot showing model performance evolution over time.
+    
+    Parameters:
+    df: DataFrame with columns ['model_name', 'release_date', 'score']
+    """
+    # Sort by release date to ensure chronological order
+    df_sorted = df.sort_values('release_date').copy()
+    
+    # Calculate cumulative best (SOTA) for each point
+    df_sorted['cumulative_best'] = df_sorted['score'].cummax()
+    
+    # Identify which models are SOTA (where score equals cumulative best)
+    df_sorted['is_sota'] = df_sorted['score'] == 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 other models (gray scatter points)
+    
+    # Add all models as scatter points (gray for non-SOTA, cyan for SOTA)
     fig.add_trace(go.Scatter(
-        x=other_years,
-        y=other_accuracy,
+        x=df_sorted['release_date'],
+        y=df_sorted['score'],
         mode='markers',
-        name='Other models',
+        name='All models',
         marker=dict(
-            color='lightgray',
-            size=6,
-            opacity=0.5
+            color=['#00CED1' if is_sota else 'lightgray' 
+                   for is_sota in df_sorted['is_sota']],
+            size=8,
+            opacity=0.7
         ),
-        hovertemplate='Year: %{x:.1f}<br>Accuracy: %{y:.1f}%<extra></extra>'
+        text=df_sorted['model_name'],
+        hovertemplate='<b>%{text}</b><br>Date: %{x}<br>Score: %{y:.2f}%<extra></extra>'
     ))
-
-    # Add SOTA models line
+    
+    # Add SOTA line (cumulative best)
     fig.add_trace(go.Scatter(
-        x=sota_years[:len(sota_accuracy)],
-        y=sota_accuracy,
-        mode='lines+markers',
-        name='State-of-the-art models',
-        line=dict(color='#00CED1', width=3),
-        marker=dict(size=10, color='#00CED1'),
-        hovertemplate='%{text}<br>Year: %{x:.1f}<br>Accuracy: %{y:.1f}%<extra></extra>',
-        text=sota_labels[:len(sota_accuracy)]
+        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='SOTA Score: %{y:.2f}%<br>Date: %{x}<extra></extra>'
     ))
-
-    # Add labels for SOTA models
-    for i, (name, (year, acc)) in enumerate(sota_models.items()):
-        if name and i < len(sota_accuracy):  # Only label points with names
-            fig.add_annotation(
-                x=year,
-                y=acc,
-                text=name,
-                showarrow=False,
-                yshift=15,
-                font=dict(size=12)
-            )
-
-    # Add the final accuracy values
-    fig.add_annotation(
-        x=2022,
-        y=87.79,
-        text="87.79",
-        showarrow=False,
-        xshift=30,
-        font=dict(size=12, weight='bold')
-    )
-
-    fig.add_annotation(
-        x=2022.2,
-        y=87.73,
-        text="87.73",
-        showarrow=False,
-        xshift=30,
-        yshift=-10,
-        font=dict(size=12)
-    )
-
+    
+    # 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['score'],
+            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='Evolution of Model Performance on ImageNet',
-        xaxis_title='Year',
-        yaxis_title='TOP-1 ACCURACY',
+        title='Evolution of Model Performance Over Time',
+        xaxis_title='Release Date',
+        yaxis_title='Score (%)',
         xaxis=dict(
-            range=[2010, 2023],
-            tickmode='linear',
-            tick0=2012,
-            dtick=2,
             showgrid=True,
             gridcolor='lightgray'
         ),
         yaxis=dict(
-            range=[35, 100],
-            tickmode='linear',
-            tick0=40,
-            dtick=10,
             showgrid=True,
             gridcolor='lightgray'
         ),
         plot_bgcolor='white',
         paper_bgcolor='white',
-        height=500,
+        height=600,
         legend=dict(
-            yanchor="bottom",
-            y=0.01,
-            xanchor="center",
-            x=0.5,
-            orientation="h"
-        )
+            yanchor="top",
+            y=0.99,
+            xanchor="left",
+            x=0.01
+        ),
+        hovermode='closest'
     )
-
+    
     return fig
 
+def create_sample_dataframe():
+    """
+    Create a sample DataFrame with model performance data.
+    """
+    # Create sample data
+    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'
+        ]),
+        'score': [
+            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 (below SOTA at their time)
+            58.0, 62.0, 68.0, 72.0, 73.5,
+            75.0, 78.5, 80.0, 82.0, 84.0
+        ]
+    }
+    
+    return pd.DataFrame(data)
 
 # Create Gradio interface
 with gr.Blocks(theme=gr.themes.Soft()) as demo:
-    gr.Markdown("# State-of-the-Art Models Timeline")
-    gr.Markdown(
-        "This visualization shows the evolution of state-of-the-art models' performance over time, similar to the ImageNet benchmark progression.")
-
+    gr.Markdown("# State-of-the-Art Models Timeline with Cumulative Best")
+    gr.Markdown("""
+    This visualization shows the evolution of model performance over time.
+    The line represents the cumulative best (SOTA) score achieved up to each point in time.
+    """)
+    
     plot = gr.Plot(label="Model Performance Evolution")
-
+    
+    # Create the main DataFrame inline
+    df_main = create_sample_dataframe()
+    
+    # Display data info
+    with gr.Row():
+        with gr.Column():
+            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()}")
+            gr.Markdown(f"**Best score achieved:** {df_main['score'].max():.2f}%")
+    
     # Create plot on load
-    demo.load(fn=create_sota_plot, outputs=plot)
-
+    demo.load(fn=lambda: create_sota_plot(df_main), outputs=plot)
+    
     # Add interactive controls
     with gr.Row():
         refresh_btn = gr.Button("Refresh Plot")
-
-    refresh_btn.click(fn=create_sota_plot, outputs=plot)
-
+        show_data_btn = gr.Button("Show DataFrame")
+    
+    # DataFrame display (initially hidden)
+    df_display = gr.Dataframe(
+        value=df_main,
+        label="Model Performance Data",
+        visible=False
+    )
+    
+    refresh_btn.click(fn=lambda: create_sota_plot(df_main), outputs=plot)
+    
+    def toggle_dataframe(current_df):
+        return gr.Dataframe(value=current_df, visible=True)
+    
+    show_data_btn.click(
+        fn=lambda: toggle_dataframe(df_main),
+        outputs=df_display
+    )
+    
     gr.Markdown("""
     ### About this visualization:
-    - **Cyan line**: State-of-the-art models showing the progression of best performance
-    - **Gray dots**: Other models representing the broader research landscape
-    - The plot shows how breakthrough models like AlexNet, Inception, and NASNET pushed the boundaries
-    - Notice the rapid improvement from 2012-2018, followed by more incremental gains
+    - **Cyan line**: Cumulative best (SOTA) score over time - shows the highest score achieved up to each date
+    - **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 scores
+    - The SOTA line only increases or stays flat, never decreases (cumulative maximum)
     """)
 
 demo.launch()