Changed structure

app.py

@@ -3,96 +3,40 @@ import json
 import gradio as gr
 import re
 import random
-import time
 from collections import defaultdict
-from functools import partial
-import openai 
-from openai import OpenAI
-import anthropic
 import pandas as pd
-from together import Together
 import os   
+from dotenv import load_dotenv
+from gen_api_answer import get_model_response
+from common import *
 
-anthropic_client = anthropic.Anthropic()  
-openai_client = OpenAI()
-together_client = Together()  
+load_dotenv() 
 
 # Model and ELO score data
-DEFAULT_ELO = 1000  # Starting ELO for new models
+DEFAULT_ELO = 1500  # Starting ELO for new models
+K_FACTOR = 32  # Standard chess K-factor, adjust as needed
 elo_scores = defaultdict(lambda: DEFAULT_ELO)
 vote_counts = defaultdict(int)
-model_data = {
-    'Meta Llama 3.1 70B Instruct Turbo': {
-        'organization': 'Meta', 
-        'license': 'Open Source',
-        'api_model': 'meta-llama/Meta-Llama-3.1-70B-Instruct-Turbo'
-    },
-    'Meta Llama 3.1 405B Instruct Turbo': {
-        'organization': 'Meta',
-        'license': 'Open Source',
-        'api_model': 'meta-llama/Meta-Llama-3.1-405B-Instruct-Turbo'
-    },
-    'Gemma 2 27B': {
-        'organization': 'Google',
-        'license': 'Open Source',
-        'api_model': 'google/gemma-2-27b-it'
-    },
-    'Gemma 2 9B': {
-        'organization': 'Google',
-        'license': 'Open Source',
-        'api_model': 'google/gemma-2-9b-it'
-    },
-    'Qwen 2 Instruct (72B)': {
-        'organization': 'Alibaba',
-        'license': 'Open Source',
-        'api_model': 'Qwen/Qwen2-72B-Instruct'
-    },
-    'Mistral (7B) Instruct v0.3': {
-        'organization': 'Mistral AI',
-        'license': 'Open Source',
-        'api_model': 'mistralai/Mistral-7B-Instruct-v0.3'
-    },
-    'GPT-4o': {
-        'organization': 'OpenAI',
-        'license': 'Proprietary',
-        'api_model': 'gpt-4o'
-    },
-    'GPT-4 Turbo': {
-        'organization': 'OpenAI',
-        'license': 'Proprietary',
-        'api_model': 'gpt-4-turbo'
-    },
-    'GPT-3.5 Turbo': {
-        'organization': 'OpenAI',
-        'license': 'Proprietary',
-        'api_model': 'gpt-3.5-turbo'
-    },
-    'Claude 3 Haiku': {
-        'organization': 'Anthropic',
-        'license': 'Proprietary',
-        'api_model': 'claude-3-haiku-20240307'
-    },
-    'Claude 3 Sonnet': {
-        'organization': 'Anthropic',
-        'license': 'Proprietary',
-        'api_model': 'claude-3-sonnet-20240229'
-    },
-    'Claude 3 Opus': {
-        'organization': 'Anthropic',
-        'license': 'Proprietary',
-        'api_model': 'claude-3-opus-20240229'
-    },
-    'Meta Llama 3.1 8B Instruct Turbo': {
-        'organization': 'Meta', 
-        'license': 'Open Source',
-        'api_model': 'meta-llama/Meta-Llama-3.1-8B-Instruct-Turbo'
-    },
-    'Meta Llama 3.1 70B Instruct Turbo': {
-        'organization': 'Meta', 
-        'license': 'Open Source',
-        'api_model': 'meta-llama/Meta-Llama-3.1-70B-Instruct-Turbo'
-    },
-}
+
+
+# Load the model_data from JSONL
+def load_model_data():
+    model_data = {}
+    try:
+        with open('data/models.jsonl', 'r') as f:
+            for line in f:
+                model = json.loads(line)
+                model_data[model['name']] = {
+                    'organization': model['organization'],
+                    'license': model['license'],
+                    'api_model': model['api_model']
+                }
+    except FileNotFoundError:
+        print("Warning: models.jsonl not found")
+        return {}
+    return model_data
+
+model_data = load_model_data()
 
 current_session_id = 0
 voting_data = []
@@ -115,7 +59,7 @@ def store_vote_data(prompt, response_a, response_b, model_a, model_b, winner, ju
     }
     voting_data.append(vote_entry)
     
-    # Optionally save to file after each vote
+    # Save to file after each vote
     with open('voting_data.json', 'w') as f:
         json.dump(voting_data, f, indent=2)
 
@@ -133,56 +77,6 @@ def get_final_prompt(eval_prompt, variable_values):
         eval_prompt = eval_prompt.replace('{{' + var + '}}', val)
     return eval_prompt
 
-# Add this near the top with other constants
-SYSTEM_PROMPT = """Please act as an impartial judge and evaluate based on the user's instruction. Your output format should be a JSON as follows: {{"feedback": "(write a feedback for the evaluation criteria)", "result": "(a score based on the evaluation criteria)"}}"""
-
-def get_openai_response(model_name, prompt):
-    try:
-        response = openai_client.chat.completions.create(
-            model=model_name,
-            messages=[
-                {"role": "system", "content": SYSTEM_PROMPT},
-                {"role": "user", "content": prompt}
-            ]
-        )
-        return response.choices[0].message.content
-    except Exception as e:
-        return f"Error with OpenAI model {model_name}: {str(e)}"
-
-def get_anthropic_response(model_name, prompt):
-    try:
-        response = anthropic_client.messages.create(
-            model=model_name,
-            max_tokens=1000,
-            temperature=0,
-            system=SYSTEM_PROMPT,
-            messages=[
-                {"role": "user", "content": [{"type": "text", "text": prompt}]}
-            ]
-        )
-        return response.content[0].text
-    except Exception as e:
-        return f"Error with Anthropic model {model_name}: {str(e)}"
-
-def get_model_response(model_name, prompt):
-    model_info = model_data.get(model_name)
-    if not model_info:
-        return "Model not found or unsupported."
-    
-    api_model = model_info['api_model']
-    organization = model_info['organization']
-    
-    try:
-        if organization == 'OpenAI':
-            return get_openai_response(api_model, prompt)
-        elif organization == 'Anthropic':
-            return get_anthropic_response(api_model, prompt)
-        else:
-            # All other organizations use Together API
-            return get_together_response(api_model, prompt)
-    except Exception as e:
-        return f"Error with {organization} model {model_name}: {str(e)}"
-
 def submit_prompt(eval_prompt, *variable_values):
     try:
         variables = parse_variables(eval_prompt)
@@ -193,20 +87,19 @@ def submit_prompt(eval_prompt, *variable_values):
         model1, model2 = random.sample(models, 2)
         model_a, model_b = (model1, model2) if random.random() < 0.5 else (model2, model1)
 
-        response_a = get_model_response(model_a, final_prompt)
-        response_b = get_model_response(model_b, final_prompt)
+        response_a = get_model_response(model_a, model_data.get(model_a), final_prompt)
+        response_b = get_model_response(model_b, model_data.get(model_b), final_prompt)
 
         return (
-            response_a,                  # response_a textbox
-            response_b,                  # response_b textbox
-            gr.update(visible=True),     # action_buttons_row
-            gr.update(visible=True),     # regenerate_button
-            model_a,                     # model_a_state
-            model_b                      # model_b_state
+            response_a,
+            response_b,
+            gr.update(visible=True),
+            gr.update(visible=True),
+            model_a,
+            model_b
         )
     except Exception as e:
         print(f"Error in submit_prompt: {str(e)}")
-        # Return default values in case of error
         return (
             "Error generating response",
             "Error generating response",
@@ -220,7 +113,6 @@ def vote(choice, model_a, model_b, prompt, response_a, response_b, judge_id):
     # Update ELO scores based on user choice
     elo_a = elo_scores[model_a]
     elo_b = elo_scores[model_b]
-    K = 32  # ELO K-factor
 
     # Calculate expected scores
     Ea = 1 / (1 + 10 ** ((elo_b - elo_a) / 400))
@@ -235,8 +127,8 @@ def vote(choice, model_a, model_b, prompt, response_a, response_b, judge_id):
         Sa, Sb = 0.5, 0.5
 
     # Update scores and vote counts
-    elo_scores[model_a] += K * (Sa - Ea)
-    elo_scores[model_b] += K * (Sb - Eb)
+    elo_scores[model_a] += K_FACTOR * (Sa - Ea)
+    elo_scores[model_b] += K_FACTOR * (Sb - Eb)
     vote_counts[model_a] += 1
     vote_counts[model_b] += 1
 
@@ -252,6 +144,8 @@ def vote(choice, model_a, model_b, prompt, response_a, response_b, judge_id):
         regenerate_button: gr.update(visible=True, interactive=True)
     }
 
+
+
 def get_leaderboard():
     # Generate leaderboard data
     leaderboard = []
@@ -286,8 +180,8 @@ def regenerate_prompt(model_a, model_b, eval_prompt, *variable_values):
         # Fallback to allowing previous models if necessary
         model1, model2 = random.sample(list(model_data.keys()), 2)
     
-    response_a = get_model_response(model1, final_prompt)
-    response_b = get_model_response(model2, final_prompt)
+    response_a = get_model_response(model1, model_data.get(model1), final_prompt)
+    response_b = get_model_response(model2, model_data.get(model2), final_prompt)
 
     # Parse the responses
     score_a, critique_a = parse_model_response(response_a)
@@ -305,10 +199,6 @@ def regenerate_prompt(model_a, model_b, eval_prompt, *variable_values):
         model2               # model_b_state
     )
 
-# Add these constants at the top of your file
-K_FACTOR = 32  # Standard chess K-factor, adjust as needed
-DEFAULT_ELO = 1500  # Starting ELO for new models
-
 def calculate_elo_change(rating_a, rating_b, winner):
     """Calculate ELO rating changes for both players."""
     expected_a = 1 / (1 + 10 ** ((rating_b - rating_a) / 400))
@@ -400,72 +290,117 @@ leaderboard_table = gr.Dataframe(
     datatype=['str', 'number', 'str', 'number', 'str', 'str', 'str']
 )
 
-def get_together_response(model_name, prompt):
+def parse_model_response(response):
     try:
-        response = together_client.chat.completions.create(
-            model=model_name,
-            messages=[
-                {"role": "system", "content": SYSTEM_PROMPT},
-                {"role": "user", "content": prompt}
-            ],
-            stream=False
-        )
-        return response.choices[0].message.content
+        # Debug print
+        print(f"Raw model response: {response}")
+        
+        # First try to parse the entire response as JSON
+        try:
+            data = json.loads(response)
+            return str(data.get('result', 'N/A')), data.get('feedback', 'N/A')
+        except json.JSONDecodeError:
+            # If that fails (typically for smaller models), try to find JSON within the response
+            json_match = re.search(r'{.*}', response)
+            if json_match:
+                data = json.loads(json_match.group(0))
+                return str(data.get('result', 'N/A')), data.get('feedback', 'N/A')
+            else:
+                return 'Error', f"Failed to parse response: {response}"
+                
     except Exception as e:
-        return f"Error with Together model {model_name}: {str(e)}"
+        # Debug print for error case
+        print(f"Failed to parse response: {str(e)}")
+        return 'Error', f"Failed to parse response: {response}"
 
-def parse_model_response(response):
+def get_leaderboard_stats():
+    """Get summary statistics for the leaderboard."""
     try:
-        # Parse JSON response
-        data = json.loads(response)
-        return data.get('result', 'N/A'), data.get('feedback', 'N/A')
-    except:
-        # If JSON parsing fails, return original response
-        return 'Error', response
-
-with gr.Blocks(theme='default', css="""
-    .prompt-row {
-        align-items: flex-start !important;
-    }
-    .send-button-row {
-        display: flex;
-        justify-content: flex-end;
-        margin-top: 8px;
-    }
-""") as demo:
+        with open('voting_data.json', 'r') as f:
+            voting_data = json.load(f)
+        
+        total_votes = len(voting_data)
+        total_models = len(model_data)
+        last_updated = datetime.now().strftime("%Y-%m-%d %H:%M:%S UTC")
+        
+        return f"""
+### Leaderboard Stats
+- **Total Models**: {total_models}
+- **Total Votes**: {total_votes}
+- **Last Updated**: {last_updated}
+"""
+    except FileNotFoundError:
+        return "No voting data available"
+
+def initialize_voting_data():
+    """Initialize or clear the voting data file."""
+    empty_data = []
+    with open('voting_data.json', 'w') as f:
+        json.dump(empty_data, f)
+
+# Add this near the start of your app initialization, before the Gradio interface setup
+if __name__ == "__main__":
+    initialize_voting_data()
+    
+    # ... rest of your Gradio app setup ...
+
+with gr.Blocks(theme='default', css=CSS_STYLES) as demo:
     judge_id = gr.State(get_new_session_id())
-    gr.Markdown("# Judge Arena")
-    gr.Markdown("*Free LLM Evals to test your GenAI application.*")
+    gr.Markdown(MAIN_TITLE)
+    gr.Markdown(SUBTITLE)
     
     with gr.Tabs():
         with gr.TabItem("Judge Arena"):
-            # Add introduction section with side-by-side rules and scoring
-            gr.Markdown("""
-            # How the Arena Works:
-
-            ## Test two anonymous LLM judges side by side
-            Try out different eval metrics - from simple hallucination detection to qualitative interpretations
-            """)
+            gr.Markdown(HOW_IT_WORKS)
             
             with gr.Row():
                 with gr.Column():
-                    gr.Markdown("""
-                    ## 🤺 Battle Rules:
-                    - Both AIs stay anonymous - if either reveals its identity, the duel is void
-                    - Evaluate anything: coding, analysis, creative writing, math, or general knowledge
-                    """)
-                with gr.Column():
-                    gr.Markdown("""
-                    ## 🧮 Scoring System:
-                    - Choose the LLM judge that most aligned with your choice as a human
-                    - If both score the same - choose the critique that you prefer more!
-                    - Your votes shape our real-time leaderboard 
-                    """)
+                    gr.Markdown(BATTLE_RULES)
+            
+            # Add heading for Eval Prompt
+            gr.Markdown("\n")
+            
+            # Eval Prompt and Variables side by side
+            with gr.Row():
+                # Left column - Eval Prompt
+                with gr.Column(scale=1):
+                    eval_prompt = gr.TextArea(
+                        label="Eval Prompt",
+                        lines=1, 
+                        value=DEFAULT_EVAL_PROMPT,
+                        placeholder="Type your eval prompt here... denote variables in {{curly brackets}} to be populated on the right.",
+                        show_label=True
+                    )
+
+                # Right column - Variable Mapping
+                with gr.Column(scale=1):
+                    gr.Markdown("### Variable Mapping")
+                    # Create inputs for up to 5 variables, with first two visible by default
+                    variable_rows = []
+                    for i in range(5):
+                        initial_visibility = True if i < 2 else False
+                        with gr.Group(visible=initial_visibility) as var_row:
+                            # Variable input with direct label
+                            initial_value = DEFAULT_INPUT if i == 0 else DEFAULT_RESPONSE
+                            initial_label = "input" if i == 0 else "response" if i == 1 else f"variable_{i+1}"
+                            var_input = gr.Textbox(
+                                label=initial_label,
+                                value=initial_value,
+                                container=True
+                            )
+                            variable_rows.append((var_row, var_input))
+
+            # Send button
+            with gr.Row(elem_classes="send-button-row"):
+                send_btn = gr.Button(
+                    value="Send",
+                    variant="primary",
+                    size="lg",
+                    scale=1
+                )
             
-            # Add divider heading
-            gr.Markdown("""
-            # Start Voting Now
-            """)
+            # Add divider heading for model outputs
+            gr.Markdown(VOTING_HEADER)
             
             # Model Responses side-by-side
             with gr.Row():
@@ -479,163 +414,27 @@ with gr.Blocks(theme='default', css="""
                     score_b = gr.Textbox(label="Score", interactive=False)
                     critique_b = gr.TextArea(label="Critique", lines=8, interactive=False)
                     model_name_b = gr.Markdown("*Model: Unknown*")
+            
             # Initially hide vote buttons and regenerate button
             with gr.Row(visible=False) as action_buttons_row:
                 vote_a = gr.Button("Choose A", variant="primary")
                 vote_tie = gr.Button("Tie", variant="secondary")
                 vote_b = gr.Button("Choose B", variant="primary")
             regenerate_button = gr.Button("Regenerate with different models", variant="secondary", visible=False)
-            # Eval Prompt and Variables below
-            with gr.Row(elem_classes="prompt-row"):
-                eval_prompt = gr.TextArea(
-                    label="Eval Prompt", 
-                    lines=1, 
-                    value="""You are assessing a chat bot response to a user's input based on the helpfulness of the response.\n                    
-
-Score:
-
-A score of 1 means that the response's answer meets all of the evaluation criteria.
-
-A score of 0 means that the response's answer does not meet all of the evaluation criteria.
-
-Here is the data:\n
-
-[BEGIN DATA]
-
-***
-
-[User Query]: {{input}}
-
-***
-
-[Response]: {{response}}
-
-***
-
-[END DATA]""",
-                    placeholder="Type your eval prompt here... denote variables like a ground truth response with {{variable}} to be populated below.",
-                    show_label=True,
-                    scale=8
-                )
-            with gr.Row(elem_classes="send-button-row"):
-                send_btn = gr.Button(
-                    value="Send",
-                    variant="primary",
-                    size="lg",
-                    scale=1  # Make button larger
-                )
-            gr.Markdown("### Variable Mapping")
-            # Create inputs for up to 5 variables, with first two visible by default
-            variable_rows = []
-            for i in range(5):
-                # Set initial visibility True for first two rows (input and response)
-                initial_visibility = True if i < 2 else False
-                with gr.Row(visible=initial_visibility) as var_row:
-                    with gr.Column(scale=0.2, min_width=80):
-                        # Set initial labels for input and response
-                        initial_label = "**input:**" if i == 0 else "**response:**" if i == 1 else "Variable"
-                        var_label = gr.Markdown(initial_label)
-                    with gr.Column(scale=1):
-                        # Set initial values for input and response
-                        initial_value = "Hello! Can you tell me the weather today?" if i == 0 else \
-                                      "Hi there! It is 27 degrees Celsius today. Would you like the weather for the week ahead?" if i == 1 else ""
-                        var_input = gr.Textbox(label="", container=False, value=initial_value)
-                    variable_rows.append((var_row, var_label, var_input))
             
             # Add spacing and acknowledgements at the bottom
-            gr.Markdown("""
-            <br><br><br>
-            # Acknowledgements
-
-            We thank [LMSYS Org](https://lmsys.org/) for their hard work on the Chatbot Arena and fully credit them for the inspiration to build this.
-
-            We thank [Clementine Fourrier](https://huggingface.co/clefourrier) and Hugging Face for their guidance and partnership in setting this up.
-            """)
+            gr.Markdown(ACKNOWLEDGEMENTS)
 
         with gr.TabItem("Leaderboard"):
             refresh_button = gr.Button("Refresh")
+            stats_display = gr.Markdown()
             leaderboard_table = gr.Dataframe(
                 headers=['Model', 'ELO', '95% CI', 'Matches', 'Organization', 'License'],
                 datatype=['str', 'number', 'str', 'number', 'str', 'str']
             )
 
         with gr.TabItem("Policy"):
-            gr.Markdown("""
-# About Atla
-
-Atla is an applied research organization that trains models as evaluators to capture human preferences. We're a team of researchers, engineers, and operational leaders, with experience spanning a variety of disciplines, all working together to build reliable and understandable AI systems. Our research is informed by our experiences conducting AI safety research at the UK AI Task Force, OpenAI and the Stanford Existential Risks Initiative.
-
-# Our Mission
-
-By creating advanced evaluation models, we enable AI developers to identify and fix risks, leading to safer, more reliable AI that can be trusted and widely used. Our aim is to surpass the current state-of-the-art evaluation methods by training models specifically for evaluation. AIs will probably become very powerful, and perform tasks that are difficult for us to verify. We want to enable humans to oversee AI systems that are solving tasks too difficult for humans to evaluate. We have written more about [our approach to scalable oversight](https://www.atla-ai.com/post/scaling-alignment) on our blog.
-
-# Judge Arena Policy
-
-## Overview
-
-Judge Arena is an open-source platform dedicated to improving the standard of evaluation of generative AI models in their role as judges. Users can run evals and assess anonymized responses from two competing model judges, choosing the better judgement or declaring a tie. This policy outlines our commitments and guidelines to ensure a fair, open, and collaborative environment for both users and model providers.
-
-## Transparency
-
-- **Open-Source**: Judge Arena's code is open-source and available on GitHub. This approach allows anyone to review, replicate, or modify the platform to suit their needs. We use proprietary model provider APIs where provided and Together AI's API to serve leading open-source models.
-- **Community Engagement**: We actively encourage contributions from the community. Feedback, code contributions, and discussions are welcome to improve the platform's functionality, fairness, and transparency.
-- **Methodology**: All processes related to model evaluation, rating calculations, and model selection are openly documented. This transparency ensures that our processes are understandable and reproducible by others.
-- **Data Sharing**: Periodically, we will share 20% of the collected evaluation data with the community. This data includes anonymized prompts, model responses, and aggregated evaluation results.
-
-## Model Inclusion Criteria
-
-Judge Arena is specifically designed to assess AI models that function as evaluators (a.k.a judges), including but not limited to powerful general-purpose models and the latest language models designed for evaluation tasks. Models are eligible for inclusion if they meet the following criteria:
-
-- **Judge Capability**: The model must possess the ability to score AND critique responses, content, or other models' outputs effectively.
-- **Adaptable:** The model must be prompt-able to be evaluate in different scoring formats, for different criteria.
-- **Accessibility**:
-   - **Public API Access**: Models accessible through public APIs without restrictive barriers.
-   - **Open-Source Models**: Models with publicly available weights that can be downloaded and run by the community.
-
-## Evaluation Methodology
-
-- **User Participation**: Users run evaluations and select preferred model responses based on quality, relevance, and accuracy contributing to the model's overall rating.
-- **Blind Testing**: All model evaluations are conducted blindly. Users are not informed which model produced which response to eliminate bias.
-- **Data Collection**: We collect sufficient data to ensure statistical significance in our evaluations. We additionally show the 95% confidence interval in the leaderboard to provide a signal of reliability.
-- **Anomaly Detection**: We monitor user activity to detect and mitigate anomalous behavior or voting patterns that could skew results.
-
-## Leaderboard Management
-
-- **ELO Ranking System**: Models are ranked on a public leaderboard based on aggregated user evaluations. We use an ELO rating system to rank AI judges on the public leaderboard. Each model begins with an initial rating of 1500 (as is used by the International Chess Federation), and we use a K-factor of 32 to determine the maximum rating adjustment after each evaluation.
-- **Minimum Period**: Listed models remain accessible on Judge Arena for a minimum period of two weeks to allow for comprehensive community evaluation.
-- **Deprecation Policy**: Models may be removed from the leaderboard if they become inaccessible, are no longer publicly available.
-
-## Privacy and Data Protection
-
-- **Anonymization**: All shared data is anonymized to prevent the identification of individual users.
-
-## Policy Updates and Communication
-
-- **Ongoing Revisions**: This policy may be updated to reflect changes in our practices or in response to community feedback.
-- **Notification of Changes**: Policy changes will be communicated to users and stakeholders on this page.
-
-# FAQ
-
-**Isn't this the same as Chatbot Arena?**
-
-- We are big fans of what the LMSYS team have done with Chatbot Arena and fully credit them for the inspiration to develop this. We were looking for a dynamic leaderboard that graded on AI judge capabilities and didn't manage to find one, so we created Judge Arena. This UI is designed especially for evals; to match the format of the model-based eval prompts that you would use in your LLM evaluation / monitoring tool.
-
-\n\n**Why should I trust this leaderboard?**
-
-- We have listed out our efforts to be fully transparent in the policies above. All of the code for this leaderboard is open-source and can be found on our [Github](https://github.com/atla-ai/judge-arena).
-
-\n\n**Who funds this effort?**
-
-- Atla currently funds this out of our own pocket. We are looking for API credits (with no strings attached) to support this effort - please get in touch if you or someone you know might be able to help.
-
-\n\n**What is Atla working on?**
-
-- We are training a general-purpose evaluator that you will soon be able to run in this Judge Arena. Our next step will be to open-source a powerful model that the community can use to run fast and accurate evaluations.
-
-## Get in touch
-
-Feel free to email us at [support@atla-ai.com](mailto:support@atla-ai.com) or leave feedback on our [Github](https://github.com/atla-ai/judge-arena)!
-            """)
+            gr.Markdown(POLICY_CONTENT)
 
     # Define state variables for model tracking
     model_a_state = gr.State()
@@ -646,17 +445,17 @@ Feel free to email us at [support@atla-ai.com](mailto:support@atla-ai.com) or le
         variables = parse_variables(eval_prompt)
         updates = []
         for i in range(5):
-            var_row, var_label, var_input = variable_rows[i]
+            var_row, var_input = variable_rows[i]
             if i < len(variables):
                 updates.extend([
                     gr.update(visible=True),  # var_row
-                    gr.update(value=f"**{variables[i]}:**"),  # var_label
+                    gr.update(value=f"**{variables[i]}:**"),  # var_input
                     gr.update(visible=True)  # var_input
                 ])
             else:
                 updates.extend([
                     gr.update(visible=False),  # var_row
-                    gr.update(),  # var_label
+                    gr.update(),  # var_input
                     gr.update(visible=False, value="")  # var_input
                 ])
         return updates
@@ -666,7 +465,7 @@ Feel free to email us at [support@atla-ai.com](mailto:support@atla-ai.com) or le
     # Regenerate button functionality
     regenerate_button.click(
         fn=regenerate_prompt,
-        inputs=[model_a_state, model_b_state, eval_prompt] + [var_input for _, _, var_input in variable_rows],
+        inputs=[model_a_state, model_b_state, eval_prompt] + [var_input for _, var_input in variable_rows],
         outputs=[
             score_a,
             critique_a,
@@ -687,15 +486,6 @@ Feel free to email us at [support@atla-ai.com](mailto:support@atla-ai.com) or le
     # Store the last submitted prompt and variables for comparison
     last_submission = gr.State({})
 
-    def handle_input_changes(prompt, *variables):
-        """Enable send button and disable regenerate button if inputs have changed"""
-        last_inputs = last_submission.value
-        current_inputs = {"prompt": prompt, "variables": variables}
-        inputs_changed = last_inputs != current_inputs
-        return [
-            gr.update(interactive=True),  # Always keep send button enabled
-            gr.update(visible=False)      # Hide regenerate button when inputs change
-        ]
 
     # Update the vote button click handlers
     vote_a.click(
@@ -731,7 +521,7 @@ Feel free to email us at [support@atla-ai.com](mailto:support@atla-ai.com) or le
             score_b,
             critique_b,
             buttons_visible,
-            gr.update(visible=False),  # Hide regenerate button on new submission
+            gr.update(visible=True),  # Show regenerate button
             model_a,
             model_b,
             gr.update(value="*Model: Unknown*"),
@@ -740,7 +530,7 @@ Feel free to email us at [support@atla-ai.com](mailto:support@atla-ai.com) or le
 
     send_btn.click(
         fn=submit_and_store,
-        inputs=[eval_prompt] + [var_input for _, _, var_input in variable_rows],
+        inputs=[eval_prompt] + [var_input for _, var_input in variable_rows],
         outputs=[
             score_a,
             critique_a,
@@ -757,31 +547,31 @@ Feel free to email us at [support@atla-ai.com](mailto:support@atla-ai.com) or le
 
     # Update the input change handlers to also disable regenerate button
     def handle_input_changes(prompt, *variables):
-        """Enable send button and disable regenerate button if inputs have changed"""
+        """Enable send button and manage regenerate button based on input changes"""
         last_inputs = last_submission.value
         current_inputs = {"prompt": prompt, "variables": variables}
         inputs_changed = last_inputs != current_inputs
         return [
-            gr.update(interactive=inputs_changed),           # send button
-            gr.update(interactive=not inputs_changed)        # regenerate button
+            gr.update(interactive=True),                    # send button always enabled
+            gr.update(interactive=not inputs_changed)       # regenerate button disabled if inputs changed
         ]
 
     # Update the change handlers for prompt and variables
     eval_prompt.change(
         fn=handle_input_changes,
-        inputs=[eval_prompt] + [var_input for _, _, var_input in variable_rows],
+        inputs=[eval_prompt] + [var_input for _, var_input in variable_rows],
         outputs=[send_btn, regenerate_button]
     )
 
-    for _, _, var_input in variable_rows:
+    for _, var_input in variable_rows:
         var_input.change(
             fn=handle_input_changes,
-            inputs=[eval_prompt] + [var_input for _, _, var_input in variable_rows],
+            inputs=[eval_prompt] + [var_input for _, var_input in variable_rows],
             outputs=[send_btn, regenerate_button]
         )
 
     # Update the leaderboard
-    def update_leaderboard():
+    def refresh_leaderboard():
         leaderboard = get_leaderboard()
         data = [
             [
@@ -793,10 +583,20 @@ Feel free to email us at [support@atla-ai.com](mailto:support@atla-ai.com) or le
                 entry['License']
             ] for entry in leaderboard
         ]
-        return gr.update(value=data)
+        stats = get_leaderboard_stats()
+        return [gr.update(value=data), gr.update(value=stats)]
 
-    refresh_button.click(fn=update_leaderboard, inputs=None, outputs=leaderboard_table)
-
-demo.launch()
+    refresh_button.click(
+        fn=refresh_leaderboard,
+        inputs=None,
+        outputs=[leaderboard_table, stats_display]
+    )
 
+    # Add the load event at the very end, just before demo.launch()
+    demo.load(
+        fn=refresh_leaderboard,
+        inputs=None,
+        outputs=[leaderboard_table, stats_display]
+    )
 
+demo.launch()