Delete app.py

app.py

@@ -1,549 +0,0 @@
-import gradio as gr
-import plotly.graph_objs as go
-import plotly.express as px
-import pandas as pd
-import numpy as np
-from datetime import datetime
-import json
-
-# Enhanced model evaluation data with comprehensive metrics
-MODEL_EVALS = {
-    "Proteins": {
-        "models": {
-            "AlphaFold2 (Tertiary GDT-TS)": {
-                "score": 0.924,
-                "parameters": "2.3B",
-                "institution": "DeepMind",
-                "date": "2021-07-15",
-                "paper": "https://doi.org/10.1038/s41586-021-03819-2",
-                "task": "Protein Structure Prediction"
-            },
-            "Nexa Bio2 (Tertiary)": {
-                "score": 0.90,
-                "parameters": "1.8B",
-                "institution": "Nexa Research",
-                "date": "2024-11-20",
-                "paper": "https://arxiv.org/abs/2024.protein.nexa",
-                "task": "Protein Structure Prediction"
-            },
-            "DeepCNF (Secondary)": {
-                "score": 0.85,
-                "parameters": "450M",
-                "institution": "University of Missouri",
-                "date": "2019-03-12",
-                "paper": "https://doi.org/10.1186/s12859-019-2940-0",
-                "task": "Secondary Structure Prediction"
-            },
-            "Porter6 (Secondary)": {
-                "score": 0.8456,
-                "parameters": "120M",
-                "institution": "University of Padova",
-                "date": "2022-05-10",
-                "paper": "https://doi.org/10.1038/s41598-022-10847-w",
-                "task": "Secondary Structure Prediction"
-            },
-            "Nexa Bio1 (Secondary)": {
-                "score": 0.71,
-                "parameters": "800M",
-                "institution": "Nexa Research",
-                "date": "2024-09-15",
-                "paper": "https://arxiv.org/abs/2024.bio1.nexa",
-                "task": "Secondary Structure Prediction"
-            }
-        },
-        "metric": "Accuracy",
-        "description": "Protein structure prediction accuracy across secondary and tertiary structure tasks"
-    },
-    "Astronomy": {
-        "models": {
-            "Nexa Astro": {
-                "score": 0.97,
-                "parameters": "2.1B",
-                "institution": "Nexa Research",
-                "date": "2024-10-05",
-                "paper": "https://arxiv.org/abs/2024.astro.nexa",
-                "task": "Galaxy Classification"
-            },
-            "Baseline CNN": {
-                "score": 0.89,
-                "parameters": "50M",
-                "institution": "Various",
-                "date": "2020-01-01",
-                "paper": "Standard CNN Architecture",
-                "task": "Galaxy Classification"
-            }
-        },
-        "metric": "F1-Score",
-        "description": "Astronomical object classification and analysis performance"
-    },
-    "Materials Science": {
-        "models": {
-            "Nexa Materials": {
-                "score": 0.9999,
-                "parameters": "1.5B",
-                "institution": "Nexa Research",
-                "date": "2024-12-01",
-                "paper": "https://arxiv.org/abs/2024.materials.nexa",
-                "task": "Property Prediction"
-            },
-            "Random Forest Baseline": {
-                "score": 0.92,
-                "parameters": "N/A",
-                "institution": "Various",
-                "date": "2018-01-01",
-                "paper": "Standard ML Baseline",
-                "task": "Property Prediction"
-            }
-        },
-        "metric": "R² Score",
-        "description": "Materials property prediction and discovery performance"
-    },
-    "Quantum State Tomography": {
-        "models": {
-            "Quantum TomoNet": {
-                "score": 0.85,
-                "parameters": "890M",
-                "institution": "IBM Research",
-                "date": "2023-04-20",
-                "paper": "https://doi.org/10.1038/s41567-023-02020-x",
-                "task": "State Reconstruction"
-            },
-            "Nexa QST Model": {
-                "score": 0.80,
-                "parameters": "1.2B",
-                "institution": "Nexa Research",
-                "date": "2024-08-30",
-                "paper": "https://arxiv.org/abs/2024.qst.nexa",
-                "task": "State Reconstruction"
-            }
-        },
-        "metric": "Fidelity",
-        "description": "Quantum state reconstruction accuracy and fidelity measures"
-    },
-    "High Energy Physics": {
-        "models": {
-            "CMSNet": {
-                "score": 0.94,
-                "parameters": "3.2B",
-                "institution": "CERN",
-                "date": "2023-11-15",
-                "paper": "https://doi.org/10.1007/JHEP11(2023)045",
-                "task": "Particle Detection"
-            },
-            "Nexa HEP Model": {
-                "score": 0.91,
-                "parameters": "2.8B",
-                "institution": "Nexa Research",
-                "date": "2024-07-12",
-                "paper": "https://arxiv.org/abs/2024.hep.nexa",
-                "task": "Particle Detection"
-            }
-        },
-        "metric": "AUC-ROC",
-        "description": "High energy physics event detection and classification"
-    },
-    "Computational Fluid Dynamics": {
-        "models": {
-            "Nexa CFD Model": {
-                "score": 0.92,
-                "parameters": "1.9B",
-                "institution": "Nexa Research",
-                "date": "2024-06-18",
-                "paper": "https://arxiv.org/abs/2024.cfd.nexa",
-                "task": "Flow Prediction"
-            },
-            "FlowNet": {
-                "score": 0.89,
-                "parameters": "1.1B",
-                "institution": "Technical University of Munich",
-                "date": "2022-09-30",
-                "paper": "https://doi.org/10.1016/j.jcp.2022.111567",
-                "task": "Flow Prediction"
-            }
-        },
-        "metric": "RMSE",
-        "description": "Fluid dynamics simulation and prediction accuracy"
-    }
-}
-
-def create_overall_leaderboard():
-    """Create overall leaderboard across all domains"""
-    all_models = []
-    for domain, data in MODEL_EVALS.items():
-        for model_name, model_data in data["models"].items():
-            all_models.append({
-                "Model": model_name,
-                "Domain": domain,
-                "Score": model_data["score"],
-                "Parameters": model_data["parameters"],
-                "Institution": model_data["institution"],
-                "Date": model_data["date"],
-                "Paper": model_data["paper"],
-                "Task": model_data["task"]
-            })
-    
-    df = pd.DataFrame(all_models)
-    df = df.sort_values('Score', ascending=False)
-    return df
-
-def create_domain_plot(domain):
-    """Create domain-specific bar chart"""
-    if domain not in MODEL_EVALS:
-        return go.Figure()
-    
-    models_data = MODEL_EVALS[domain]["models"]
-    models = list(models_data.keys())
-    scores = [models_data[model]["score"] for model in models]
-    
-    # Color scheme: Nexa models in brand color, others in neutral
-    colors = ['#6366f1' if 'Nexa' in model else '#64748b' for model in models]
-    
-    fig = go.Figure()
-    fig.add_trace(go.Bar(
-        x=models,
-        y=scores,
-        marker_color=colors,
-        text=[f"{score:.3f}" for score in scores],
-        textposition='auto',
-        hovertemplate='<b>%{x}</b><br>Score: %{y:.3f}<extra></extra>'
-    ))
-    
-    fig.update_layout(
-        title=f"{domain} - Model Performance Comparison",
-        xaxis_title="Model",
-        yaxis_title=f"{MODEL_EVALS[domain]['metric']}",
-        yaxis_range=[0, 1.0],
-        template="plotly_white",
-        height=500,
-        font=dict(size=12),
-        title_font_size=16,
-        showlegend=False
-    )
-    
-    # Rotate x-axis labels for better readability
-    fig.update_xaxes(tickangle=45)
-    
-    return fig
-
-def create_radar_chart():
-    """Create radar chart showing Nexa models across domains"""
-    nexa_models = {}
-    categories = []
-    
-    for domain, data in MODEL_EVALS.items():
-        for model_name, model_data in data["models"].items():
-            if "Nexa" in model_name:
-                categories.append(domain)
-                nexa_models[domain] = model_data["score"]
-                break
-    
-    if not nexa_models:
-        return go.Figure()
-    
-    fig = go.Figure()
-    
-    fig.add_trace(go.Scatterpolar(
-        r=list(nexa_models.values()),
-        theta=categories,
-        fill='toself',
-        name='Nexa Models',
-        line_color='#6366f1',
-        fillcolor='rgba(99, 102, 241, 0.2)'
-    ))
-    
-    fig.update_layout(
-        polar=dict(
-            radialaxis=dict(
-                visible=True,
-                range=[0, 1]
-            )),
-        showlegend=True,
-        title="Nexa Models Performance Across Domains",
-        height=500
-    )
-    
-    return fig
-
-def create_timeline_plot():
-    """Create timeline showing model releases"""
-    all_models = []
-    for domain, data in MODEL_EVALS.items():
-        for model_name, model_data in data["models"].items():
-            all_models.append({
-                "Model": model_name,
-                "Domain": domain,
-                "Score": model_data["score"],
-                "Date": pd.to_datetime(model_data["date"]),
-                "Institution": model_data["institution"],
-                "IsNexa": "Nexa" in model_name
-            })
-    
-    df = pd.DataFrame(all_models)
-    df = df.sort_values('Date')
-    
-    fig = px.scatter(
-        df, 
-        x='Date', 
-        y='Score',
-        color='IsNexa',
-        size='Score',
-        hover_data=['Model', 'Domain', 'Institution'],
-        color_discrete_map={True: '#6366f1', False: '#64748b'},
-        title="Model Performance Timeline"
-    )
-    
-    fig.update_layout(
-        height=500,
-        showlegend=True,
-        legend=dict(title="Model Type")
-    )
-    
-    # Update trace names for better legend display
-    fig.for_each_trace(lambda t: t.update(name="Nexa Models" if t.name == "True" else "Other Models"))
-    
-    return fig
-
-def get_domain_details(domain):
-    """Get detailed information about a domain"""
-    if domain not in MODEL_EVALS:
-        return "Domain not found"
-    
-    data = MODEL_EVALS[domain]
-    details = {
-        "domain": domain,
-        "metric": data["metric"],
-        "description": data["description"],
-        "models": data["models"]
-    }
-    return json.dumps(details, indent=2)
-
-def format_leaderboard_table(df):
-    """Format the leaderboard table for display"""
-    # Create display-friendly format
-    df_display = df.copy()
-    # Truncate long URLs for better display
-    df_display['Paper'] = df_display['Paper'].apply(
-        lambda x: "📄 Link" if x.startswith('http') else x
-    )
-    return df_display
-
-# Custom CSS for styling
-custom_css = """
-<style>
-    .main-header {
-        text-align: center;
-        background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
-        color: white;
-        padding: 2rem;
-        border-radius: 10px;
-        margin-bottom: 2rem;
-    }
-    .metric-card {
-        background: #f8fafc;
-        border: 1px solid #e2e8f0;
-        border-radius: 8px;
-        padding: 1rem;
-        margin: 0.5rem;
-        text-align: center;
-    }
-    .metric-value {
-        font-size: 2rem;
-        font-weight: bold;
-        color: #6366f1;
-    }
-    .metric-label {
-        color: #64748b;
-        font-size: 0.9rem;
-    }
-</style>
-"""
-
-# Create Gradio interface
-with gr.Blocks(
-    title="🔬 Nexa Evals - Scientific ML Benchmark Leaderboard",
-    theme=gr.themes.Soft(),
-    css=custom_css
-) as demo:
-    
-    # Header
-    gr.HTML("""
-    <div class="main-header">
-        <h1>🔬 Nexa Evals</h1>
-        <h2>Scientific Machine Learning Benchmark Leaderboard</h2>
-        <p>Comprehensive evaluation suite comparing state-of-the-art models across scientific domains</p>
-    </div>
-    """)
-    
-    # Metrics overview
-    total_models = sum(len(data["models"]) for data in MODEL_EVALS.values())
-    total_domains = len(MODEL_EVALS)
-    nexa_models = sum(1 for data in MODEL_EVALS.values() 
-                     for model in data["models"].keys() if "Nexa" in model)
-    
-    with gr.Row():
-        gr.HTML(f"""
-        <div class="metric-card">
-            <div class="metric-value">{total_models}</div>
-            <div class="metric-label">Total Models</div>
-        </div>
-        """)
-        gr.HTML(f"""
-        <div class="metric-card">
-            <div class="metric-value">{total_domains}</div>
-            <div class="metric-label">Scientific Domains</div>
-        </div>
-        """)
-        gr.HTML(f"""
-        <div class="metric-card">
-            <div class="metric-value">{nexa_models}</div>
-            <div class="metric-label">Nexa Models</div>
-        </div>
-        """)
-    
-    # Main content tabs
-    with gr.Tabs():
-        
-        # Overall Leaderboard Tab
-        with gr.TabItem("🏆 Overall Leaderboard"):
-            gr.Markdown("""
-            ### Complete ranking of all models across scientific domains
-            Models are ranked by their performance scores within their respective domains.
-            """)
-            
-            overall_df = create_overall_leaderboard()
-            leaderboard_table = gr.Dataframe(
-                value=overall_df,
-                headers=["Model", "Domain", "Score", "Parameters", "Institution", "Date", "Paper", "Task"],
-                datatype=["str", "str", "number", "str", "str", "str", "str", "str"],
-                interactive=False
-            )
-        
-        # Domain Analysis Tab
-        with gr.TabItem("📊 Domain Analysis"):
-            gr.Markdown("""
-            ### Domain-specific model performance analysis
-            Select a domain to view detailed performance metrics and model comparisons.
-            """)
-            
-            with gr.Row():
-                domain_dropdown = gr.Dropdown(
-                    choices=list(MODEL_EVALS.keys()),
-                    value=list(MODEL_EVALS.keys())[0],
-                    label="Select Scientific Domain"
-                )
-                
-            with gr.Row():
-                domain_plot = gr.Plot(label="Performance Comparison")
-                
-            with gr.Row():
-                domain_details = gr.Code(
-                    label="Domain Details (JSON)",
-                    language="json"
-                )
-            
-            domain_dropdown.change(
-                fn=lambda x: [create_domain_plot(x), get_domain_details(x)],
-                inputs=domain_dropdown,
-                outputs=[domain_plot, domain_details]
-            )
-            
-            # Initialize with first domain
-            demo.load(
-                fn=lambda: [create_domain_plot(list(MODEL_EVALS.keys())[0]), 
-                           get_domain_details(list(MODEL_EVALS.keys())[0])],
-                outputs=[domain_plot, domain_details]
-            )
-        
-        # Nexa Models Tab
-        with gr.TabItem("🚀 Nexa Models"):
-            gr.Markdown("""
-            ### Nexa Research model performance overview
-            Comprehensive analysis of Nexa models across all scientific domains.
-            """)
-            
-            with gr.Row():
-                nexa_radar = gr.Plot(
-                    value=create_radar_chart(),
-                    label="Nexa Models - Cross-Domain Performance"
-                )
-            
-            nexa_df = overall_df[overall_df['Model'].str.contains('Nexa', na=False)]
-            nexa_table = gr.Dataframe(
-                value=nexa_df,
-                headers=["Model", "Domain", "Score", "Parameters", "Institution", "Date", "Paper", "Task"],
-                label="Nexa Models Detailed View"
-            )
-        
-        # Timeline Tab
-        with gr.TabItem("📈 Timeline"):
-            gr.Markdown("""
-            ### Model development timeline
-            Track the evolution of scientific ML models over time.
-            """)
-            
-            timeline_plot = gr.Plot(
-                value=create_timeline_plot(),
-                label="Model Performance Timeline"
-            )
-        
-        # About Tab
-        with gr.TabItem("ℹ️ About"):
-            gr.Markdown("""
-            ## About Nexa Evals
-            
-            Nexa Evals is a comprehensive benchmarking suite for evaluating machine learning models 
-            across diverse scientific domains. Our evaluation framework provides:
-            
-            ### 🎯 Evaluation Domains
-            - **Proteins**: Structure prediction (secondary/tertiary)
-            - **Astronomy**: Galaxy classification and analysis
-            - **Materials Science**: Property prediction and discovery
-            - **Quantum State Tomography**: State reconstruction
-            - **High Energy Physics**: Particle detection and classification
-            - **Computational Fluid Dynamics**: Flow prediction and simulation
-            
-            ### 📊 Evaluation Metrics
-            Each domain uses appropriate metrics:
-            - **Accuracy**: Classification tasks
-            - **F1-Score**: Balanced precision/recall evaluation
-            - **R² Score**: Regression performance
-            - **Fidelity**: Quantum state reconstruction accuracy
-            - **AUC-ROC**: Binary classification performance
-            - **RMSE**: Regression error measurement
-            
-            ### 🔬 Scientific Rigor
-            All benchmarks are based on established datasets and evaluation protocols 
-            from peer-reviewed research. Model scores are computed using standardized 
-            metrics to ensure fair comparison.
-            
-            ### 🚀 Nexa Research
-            Nexa Research is developing next-generation AI models specifically designed 
-            for scientific applications. Our models are trained on domain-specific data 
-            and optimized for scientific reasoning and discovery.
-            
-            ### 📚 Citations & References
-            For detailed information about evaluation protocols and datasets, please 
-            refer to the linked papers in the model details.
-            
-            ---
-            
-            **Last Updated**: {datetime.now().strftime("%B %d, %Y")}
-            
-            **Contact**: [Nexa Research](https://nexaresearch.ai) | [GitHub](https://github.com/nexa-research)
-            """)
-    
-    # Footer
-    gr.HTML("""
-    <div style="text-align: center; margin-top: 2rem; padding: 1rem; background: #f8fafc; border-radius: 8px;">
-        <p>🔬 <strong>Nexa Evals</strong> - Advancing Scientific Machine Learning</p>
-        <p>Built with ❤️ by <a href="https://nexaresearch.ai" target="_blank">Nexa Research</a></p>
-    </div>
-    """)
-
-if __name__ == "__main__":
-    demo.launch(
-        share=False,
-        server_name="0.0.0.0",
-        server_port=7860,
-        show_error=True
-    )