Create app.py

app.py

@@ -0,0 +1,658 @@
+import os
+import json
+import numpy as np
+import pandas as pd
+import gradio as gr
+from huggingface_hub import HfApi, hf_hub_download
+
+
+OWNER = "inceptionai"
+DATASET_REPO_ID = f"{OWNER}/requests-dataset"
+
+HEADER = """
+<center>
+<h1>AraGen Leaderboard: Generative Tasks Evaluation of Arabic LLMs</h1>
+</center>
+
+<br></br>
+
+<p>This leaderboard is designed to redefine the evaluation of Arabic Large Language Models (LLMs). Powered by the new <strong>3C3H</strong> evaluation measure, this framework delivers a transparent, robust, and holistic evaluation system that balances factual accuracy and usability assessment for a production ready setting.</p>
+
+<p>For more details, please consider going through the technical blogpost <a href="https://huggingface.co/blog/">here</a>.</p>
+"""
+
+ABOUT_SECTION = """
+## About:
+
+The AraGen Leaderboard is designed to evaluate and compare the performance of Chat Arabic Large Language Models (LLMs) on a set of generative tasks. By leveraging the new **3C3H** evaluation measure which evaluate the model's output across six dimensions —Correctness, Completeness, Conciseness, Helpfulness, Honesty, and Harmlessness— the leaderboard provides a comprehensive and holistic evaluation of a model's performance in generating human-like and ethically responsible content.
+
+### Why Focus on Chat Models?
+
+AraGen —And 3C3H in general— is specifically tailored to assess **chat models**, which interact in conversational settings, intended for end user interaction and require a blend of factual accuracy and user-centric dialogue capabilities. While it is technically possible to submit foundational models, we kindly ask users to refrain from doing so. For evaluations of foundational models using likelihood accuracy based benchmarks, please refer to the [Open Arabic LLM Leaderboard (OALL)](https://huggingface.co/spaces/OALL/Open-Arabic-LLM-Leaderboard).
+
+### How to Submit Your Model?
+
+avigate to the submission section below to submit your open chat model from the HuggingFace Hub for evaluation. Ensure that your model is public and the submmited metadata (precision, revision, #params) is accurate.
+
+### Contact
+
+For any inquiries or assistance, please reach out through the community tab at [Inception AraGen Community](https://huggingface.co/spaces/inceptionai/AraGen-Leaderboard/discussions) or via [email](mailto:ali.filali@inceptionai.ai).
+"""
+
+CITATION_BUTTON_TEXT = """
+CITATION
+"""
+
+CITATION_BUTTON_LABEL = """
+CITATION_BUTTON_LABEL
+"""
+
+def load_results():
+    # Get the current directory of the script and construct the path to results.json
+    current_dir = os.path.dirname(os.path.abspath(__file__))
+    results_file = os.path.join(current_dir, "assets", "results", "results.json")
+    
+    # Load the JSON data from the specified file
+    with open(results_file, 'r') as f:
+        data = json.load(f)
+    
+    # Lists to collect data
+    data_3c3h = []
+    data_tasks = []
+    
+    for model_data in data:
+        # Extract model meta data
+        meta = model_data.get('Meta', {})
+        model_name = meta.get('Model Name', 'UNK')
+        revision = meta.get('Revision', 'UNK')
+        precision = meta.get('Precision', 'UNK')
+        params = meta.get('Params', 'UNK')
+        license = meta.get('License', 'UNK')
+        
+        # Convert "Model Size" to numeric, treating "UNK" as infinity
+        try:
+            model_size_numeric = float(params)
+        except (ValueError, TypeError):
+            model_size_numeric = np.inf
+        
+        # 3C3H Scores
+        scores_data = model_data.get('claude-3.5-sonnet Scores', {})
+        scores_3c3h = scores_data.get('3C3H Scores', {})
+        scores_tasks = scores_data.get('Tasks Scores', {})
+        
+        # Multiply scores by 100 to get percentages (keep them as numeric values)
+        formatted_scores_3c3h = {k: v*100 for k, v in scores_3c3h.items()}
+        formatted_scores_tasks = {k: v*100 for k, v in scores_tasks.items()}
+        
+        # For 3C3H Scores DataFrame
+        data_entry_3c3h = {
+            'Model Name': model_name,
+            'Revision': revision,
+            'License': license,
+            'Precision': precision,
+            'Model Size': model_size_numeric,  # Numeric value for sorting
+            '3C3H Score': formatted_scores_3c3h.get("3C3H Score", np.nan),
+            'Correctness': formatted_scores_3c3h.get("Correctness", np.nan),
+            'Completeness': formatted_scores_3c3h.get("Completeness", np.nan),
+            'Conciseness': formatted_scores_3c3h.get("Conciseness", np.nan),
+            'Helpfulness': formatted_scores_3c3h.get("Helpfulness", np.nan),
+            'Honesty': formatted_scores_3c3h.get("Honesty", np.nan),
+            'Harmlessness': formatted_scores_3c3h.get("Harmlessness", np.nan),
+        }
+        data_3c3h.append(data_entry_3c3h)
+        
+        # For Tasks Scores DataFrame
+        data_entry_tasks = {
+            'Model Name': model_name,
+            'Revision': revision,
+            'License': license,
+            'Precision': precision,
+            'Model Size': model_size_numeric,  # Numeric value for sorting
+            **formatted_scores_tasks
+        }
+        data_tasks.append(data_entry_tasks)
+    
+    df_3c3h = pd.DataFrame(data_3c3h)
+    df_tasks = pd.DataFrame(data_tasks)
+    
+    # Round the numeric score columns to 4 decimal places
+    score_columns_3c3h = ['3C3H Score', 'Correctness', 'Completeness', 'Conciseness', 'Helpfulness', 'Honesty', 'Harmlessness']
+    df_3c3h[score_columns_3c3h] = df_3c3h[score_columns_3c3h].round(4)
+    
+    # Replace np.inf with a large number in 'Model Size Filter' for filtering
+    max_model_size_value = 1000  # Define a maximum value
+    df_3c3h['Model Size Filter'] = df_3c3h['Model Size'].replace(np.inf, max_model_size_value)
+    
+    # Sort df_3c3h by '3C3H Score' descending if column exists
+    if '3C3H Score' in df_3c3h.columns:
+        df_3c3h = df_3c3h.sort_values(by='3C3H Score', ascending=False)
+        df_3c3h.insert(0, 'Rank', range(1, len(df_3c3h) + 1))  # Add Rank column starting from 1
+    else:
+        df_3c3h.insert(0, 'Rank', range(1, len(df_3c3h) + 1))
+    
+    # Extract task columns
+    task_columns = [col for col in df_tasks.columns if col not in ['Model Name', 'Revision', 'License', 'Precision', 'Model Size', 'Model Size Filter']]
+    
+    # Round the task score columns to 4 decimal places
+    if task_columns:
+        df_tasks[task_columns] = df_tasks[task_columns].round(4)
+    
+    # Replace np.inf with a large number in 'Model Size Filter' for filtering
+    df_tasks['Model Size Filter'] = df_tasks['Model Size'].replace(np.inf, max_model_size_value)
+    
+    # Sort df_tasks by the first task column if it exists
+    if task_columns:
+        first_task = task_columns[0]
+        df_tasks = df_tasks.sort_values(by=first_task, ascending=False)
+        df_tasks.insert(0, 'Rank', range(1, len(df_tasks) + 1))  # Add Rank column starting from 1
+    else:
+        df_tasks = df_tasks.sort_values(by='Model Name', ascending=True)
+        df_tasks.insert(0, 'Rank', range(1, len(df_tasks) + 1))
+    
+    return df_3c3h, df_tasks, task_columns
+
+def load_requests(status_folder):
+    api = HfApi()
+    requests_data = []
+    folder_path_in_repo = status_folder  # 'pending', 'finished', or 'failed'
+
+    hf_api_token = os.environ.get('HF_API_TOKEN', None)
+
+    try:
+        # List files in the dataset repository
+        files_info = api.list_repo_files(
+            repo_id=DATASET_REPO_ID,
+            repo_type="dataset",
+            token=hf_api_token
+        )
+    except Exception as e:
+        print(f"Error accessing dataset repository: {e}")
+        return pd.DataFrame()  # Return empty DataFrame if repository not found or inaccessible
+
+    # Filter files in the desired folder
+    files_in_folder = [f for f in files_info if f.startswith(f"{folder_path_in_repo}/") and f.endswith('.json')]
+
+    for file_path in files_in_folder:
+        try:
+            # Download the JSON file
+            local_file_path = hf_hub_download(
+                repo_id=DATASET_REPO_ID,
+                filename=file_path,
+                repo_type="dataset",
+                token=hf_api_token
+            )
+            # Load JSON data
+            with open(local_file_path, 'r') as f:
+                request = json.load(f)
+            requests_data.append(request)
+        except Exception as e:
+            print(f"Error loading file {file_path}: {e}")
+            continue  # Skip files that can't be loaded
+
+    df = pd.DataFrame(requests_data)
+    return df
+
+def submit_model(model_name, revision, precision, params, license):
+    # Load existing evaluations
+    df_3c3h, df_tasks, _ = load_results()
+    existing_models_results = df_3c3h[['Model Name', 'Revision', 'Precision']]
+
+    # Handle 'Missing' precision
+    if precision == 'Missing':
+        precision = None
+    else:
+        precision = precision.strip().lower()
+
+    # Load pending and finished requests from the dataset repository
+    df_pending = load_requests('pending')
+    df_finished = load_requests('finished')
+
+    # Check if model is already evaluated
+    model_exists_in_results = ((existing_models_results['Model Name'] == model_name) &
+                               (existing_models_results['Revision'] == revision) &
+                               (existing_models_results['Precision'] == precision)).any()
+    if model_exists_in_results:
+        return f"**Model '{model_name}' with revision '{revision}' and precision '{precision}' has already been evaluated.**"
+
+    # Check if model is in pending requests
+    if not df_pending.empty:
+        existing_models_pending = df_pending[['model_name', 'revision', 'precision']]
+        model_exists_in_pending = ((existing_models_pending['model_name'] == model_name) &
+                                   (existing_models_pending['revision'] == revision) &
+                                   (existing_models_pending['precision'] == precision)).any()
+        if model_exists_in_pending:
+            return f"**Model '{model_name}' with revision '{revision}' and precision '{precision}' is already in the pending evaluations.**"
+
+    # Check if model is in finished requests
+    if not df_finished.empty:
+        existing_models_finished = df_finished[['model_name', 'revision', 'precision']]
+        model_exists_in_finished = ((existing_models_finished['model_name'] == model_name) &
+                                    (existing_models_finished['revision'] == revision) &
+                                    (existing_models_finished['precision'] == precision)).any()
+        if model_exists_in_finished:
+            return f"**Model '{model_name}' with revision '{revision}' and precision '{precision}' has already been evaluated.**"
+
+    # Check if model exists on HuggingFace Hub
+    api = HfApi()
+    try:
+        model_info = api.model_info(model_name)
+    except Exception as e:
+        return f"**Error: Could not find model '{model_name}' on HuggingFace Hub. Please ensure the model name is correct and the model is public.**"
+
+    # Proceed with submission
+    status = "PENDING"
+
+    # Prepare the submission data
+    submission = {
+        "model_name": model_name,
+        "license": license,
+        "revision": revision,
+        "precision": precision,
+        "status": status,
+        "params": params
+    }
+
+    # Serialize the submission to JSON
+    submission_json = json.dumps(submission, indent=2)
+
+    # Define the file path in the repository
+    org_model = model_name.split('/')
+    if len(org_model) != 2:
+        return "**Please enter the full model name including the organization or username, e.g., 'inceptionai/jais-family-30b-8k'**"
+    org, model_id = org_model
+    precision_str = precision if precision else 'Missing'
+    file_path_in_repo = f"pending/{org}/{model_id}_eval_request_{revision}_{precision_str}.json"
+
+    # Upload the submission to the dataset repository
+    try:
+        hf_api_token = os.environ.get('HF_API_TOKEN', None)
+        api.upload_file(
+            path_or_fileobj=submission_json.encode('utf-8'),
+            path_in_repo=file_path_in_repo,
+            repo_id=DATASET_REPO_ID,
+            repo_type="dataset",
+            token=hf_api_token
+        )
+    except Exception as e:
+        return f"**Error: Could not submit the model. {str(e)}**"
+
+    return f"**Model '{model_name}' has been submitted for evaluation.**"
+
+def main():
+    df_3c3h, df_tasks, task_columns = load_results()
+
+    # Extract unique Precision and License values for filters
+    precision_options_3c3h = sorted(df_3c3h['Precision'].dropna().unique().tolist())
+    precision_options_3c3h = [p for p in precision_options_3c3h if p != 'UNK']
+    precision_options_3c3h.append('Missing')
+
+    license_options_3c3h = sorted(df_3c3h['License'].dropna().unique().tolist())
+    license_options_3c3h = [l for l in license_options_3c3h if l != 'UNK']
+    license_options_3c3h.append('Missing')
+
+    precision_options_tasks = sorted(df_tasks['Precision'].dropna().unique().tolist())
+    precision_options_tasks = [p for p in precision_options_tasks if p != 'UNK']
+    precision_options_tasks.append('Missing')
+
+    license_options_tasks = sorted(df_tasks['License'].dropna().unique().tolist())
+    license_options_tasks = [l for l in license_options_tasks if l != 'UNK']
+    license_options_tasks.append('Missing')
+
+    # Get min and max model sizes for sliders, handling 'inf' values
+    min_model_size_3c3h = int(df_3c3h['Model Size Filter'].min())
+    max_model_size_3c3h = int(df_3c3h['Model Size Filter'].max())
+
+    min_model_size_tasks = int(df_tasks['Model Size Filter'].min())
+    max_model_size_tasks = int(df_tasks['Model Size Filter'].max())
+
+    # Exclude 'Model Size Filter' from column selectors
+    column_choices_3c3h = [col for col in df_3c3h.columns if col != 'Model Size Filter']
+    column_choices_tasks = [col for col in df_tasks.columns if col != 'Model Size Filter']
+
+    with gr.Blocks() as demo:
+        gr.HTML(HEADER)
+        
+        with gr.Tabs():
+            with gr.Tab("Leaderboard"):
+                with gr.Tabs():
+                    with gr.Tab("3C3H Scores"):
+                        with gr.Row():
+                            search_box_3c3h = gr.Textbox(
+                                placeholder="Search for models...", 
+                                label="Search", 
+                                interactive=True
+                            )
+                        with gr.Row():
+                            column_selector_3c3h = gr.CheckboxGroup(
+                                choices=column_choices_3c3h,
+                                value=[
+                                    'Rank', 'Model Name', '3C3H Score', 'Correctness', 'Completeness',
+                                    'Conciseness', 'Helpfulness', 'Honesty', 'Harmlessness'
+                                ],
+                                label="Select columns to display",
+                            )
+                        with gr.Row():
+                            license_filter_3c3h = gr.CheckboxGroup(
+                                choices=license_options_3c3h,
+                                value=license_options_3c3h.copy(),  # Default all selected
+                                label="Filter by License",
+                            )
+                            precision_filter_3c3h = gr.CheckboxGroup(
+                                choices=precision_options_3c3h,
+                                value=precision_options_3c3h.copy(),  # Default all selected
+                                label="Filter by Precision",
+                            )
+                        with gr.Row():
+                            model_size_min_filter_3c3h = gr.Slider(
+                                minimum=min_model_size_3c3h,
+                                maximum=max_model_size_3c3h,
+                                value=min_model_size_3c3h,
+                                step=1,
+                                label="Minimum Model Size",
+                                interactive=True
+                            )
+                            model_size_max_filter_3c3h = gr.Slider(
+                                minimum=min_model_size_3c3h,
+                                maximum=max_model_size_3c3h,
+                                value=max_model_size_3c3h,
+                                step=1,
+                                label="Maximum Model Size",
+                                interactive=True
+                            )
+                        
+                        leaderboard_3c3h = gr.Dataframe(
+                            df_3c3h[['Rank', 'Model Name', '3C3H Score', 'Correctness', 'Completeness',
+                                   'Conciseness', 'Helpfulness', 'Honesty', 'Harmlessness']],
+                            interactive=False
+                        )
+                        
+                        def filter_df_3c3h(search_query, selected_cols, precision_filters, license_filters, min_size, max_size):
+                            filtered_df = df_3c3h.copy()
+                            
+                            # Ensure min_size <= max_size
+                            if min_size > max_size:
+                                min_size, max_size = max_size, min_size
+                            
+                            # Apply search filter
+                            if search_query:
+                                filtered_df = filtered_df[filtered_df['Model Name'].str.contains(search_query, case=False, na=False)]
+                            
+                            # Apply Precision filter
+                            if precision_filters:
+                                include_missing = 'Missing' in precision_filters
+                                selected_precisions = [p for p in precision_filters if p != 'Missing']
+                                if include_missing:
+                                    filtered_df = filtered_df[
+                                        (filtered_df['Precision'].isin(selected_precisions)) |
+                                        (filtered_df['Precision'] == 'UNK') |
+                                        (filtered_df['Precision'].isna())
+                                    ]
+                                else:
+                                    filtered_df = filtered_df[filtered_df['Precision'].isin(selected_precisions)]
+                            
+                            # Apply License filter
+                            if license_filters:
+                                include_missing = 'Missing' in license_filters
+                                selected_licenses = [l for l in license_filters if l != 'Missing']
+                                if include_missing:
+                                    filtered_df = filtered_df[
+                                        (filtered_df['License'].isin(selected_licenses)) |
+                                        (filtered_df['License'] == 'UNK') |
+                                        (filtered_df['License'].isna())
+                                    ]
+                                else:
+                                    filtered_df = filtered_df[filtered_df['License'].isin(selected_licenses)]
+                            
+                            # Apply Model Size filter
+                            filtered_df = filtered_df[
+                                (filtered_df['Model Size Filter'] >= min_size) &
+                                (filtered_df['Model Size Filter'] <= max_size)
+                            ]
+                            
+                            # Remove existing 'Rank' column if present
+                            if 'Rank' in filtered_df.columns:
+                                filtered_df = filtered_df.drop(columns=['Rank'])
+                            
+                            # Recalculate Rank after filtering
+                            filtered_df = filtered_df.reset_index(drop=True)
+                            filtered_df.insert(0, 'Rank', range(1, len(filtered_df) + 1))
+                            
+                            # Ensure selected columns are present
+                            selected_cols = [col for col in selected_cols if col in filtered_df.columns]
+                            
+                            return filtered_df[selected_cols]
+                        
+                        # Bind the filter function to the appropriate events
+                        filter_inputs_3c3h = [
+                            search_box_3c3h,
+                            column_selector_3c3h,
+                            precision_filter_3c3h,
+                            license_filter_3c3h,
+                            model_size_min_filter_3c3h,
+                            model_size_max_filter_3c3h
+                        ]
+                        search_box_3c3h.submit(
+                            filter_df_3c3h,
+                            inputs=filter_inputs_3c3h,
+                            outputs=leaderboard_3c3h
+                        )
+                        
+                        # Bind change events for CheckboxGroups and sliders
+                        for component in filter_inputs_3c3h:
+                            component.change(
+                                filter_df_3c3h,
+                                inputs=filter_inputs_3c3h,
+                                outputs=leaderboard_3c3h
+                            )
+                    
+                    with gr.Tab("Tasks Scores"):
+                        gr.Markdown("""
+                                    Note: This Table is sorted based on the First Task (Question Answering)
+                                    """)
+                        
+                        with gr.Row():
+                            search_box_tasks = gr.Textbox(
+                                placeholder="Search for models...", 
+                                label="Search", 
+                                interactive=True
+                            )
+                        with gr.Row():
+                            column_selector_tasks = gr.CheckboxGroup(
+                                choices=column_choices_tasks,
+                                value=['Rank', 'Model Name'] + task_columns,
+                                label="Select columns to display",
+                            )
+                        with gr.Row():
+                            license_filter_tasks = gr.CheckboxGroup(
+                                choices=license_options_tasks,
+                                value=license_options_tasks.copy(),  # Default all selected
+                                label="Filter by License",
+                            )
+                            precision_filter_tasks = gr.CheckboxGroup(
+                                choices=precision_options_tasks,
+                                value=precision_options_tasks.copy(),  # Default all selected
+                                label="Filter by Precision",
+                            )
+                        with gr.Row():
+                            model_size_min_filter_tasks = gr.Slider(
+                                minimum=min_model_size_tasks,
+                                maximum=max_model_size_tasks,
+                                value=min_model_size_tasks,
+                                step=1,
+                                label="Minimum Model Size",
+                                interactive=True
+                            )
+                            model_size_max_filter_tasks = gr.Slider(
+                                minimum=min_model_size_tasks,
+                                maximum=max_model_size_tasks,
+                                value=max_model_size_tasks,
+                                step=1,
+                                label="Maximum Model Size",
+                                interactive=True
+                            )
+                        
+                        leaderboard_tasks = gr.Dataframe(
+                            df_tasks[['Rank', 'Model Name'] + task_columns],
+                            interactive=False
+                        )
+                        
+                        def filter_df_tasks(search_query, selected_cols, precision_filters, license_filters, min_size, max_size):
+                            filtered_df = df_tasks.copy()
+                            
+                            # Ensure min_size <= max_size
+                            if min_size > max_size:
+                                min_size, max_size = max_size, min_size
+                            
+                            # Apply search filter
+                            if search_query:
+                                filtered_df = filtered_df[filtered_df['Model Name'].str.contains(search_query, case=False, na=False)]
+                            
+                            # Apply Precision filter
+                            if precision_filters:
+                                include_missing = 'Missing' in precision_filters
+                                selected_precisions = [p for p in precision_filters if p != 'Missing']
+                                if include_missing:
+                                    filtered_df = filtered_df[
+                                        (filtered_df['Precision'].isin(selected_precisions)) |
+                                        (filtered_df['Precision'] == 'UNK') |
+                                        (filtered_df['Precision'].isna())
+                                    ]
+                                else:
+                                    filtered_df = filtered_df[filtered_df['Precision'].isin(selected_precisions)]
+                            
+                            # Apply License filter
+                            if license_filters:
+                                include_missing = 'Missing' in license_filters
+                                selected_licenses = [l for l in license_filters if l != 'Missing']
+                                if include_missing:
+                                    filtered_df = filtered_df[
+                                        (filtered_df['License'].isin(selected_licenses)) |
+                                        (filtered_df['License'] == 'UNK') |
+                                        (filtered_df['License'].isna())
+                                    ]
+                                else:
+                                    filtered_df = filtered_df[filtered_df['License'].isin(selected_licenses)]
+                            
+                            # Apply Model Size filter
+                            filtered_df = filtered_df[
+                                (filtered_df['Model Size Filter'] >= min_size) &
+                                (filtered_df['Model Size Filter'] <= max_size)
+                            ]
+                            
+                            # Remove existing 'Rank' column if present
+                            if 'Rank' in filtered_df.columns:
+                                filtered_df = filtered_df.drop(columns=['Rank'])
+                            
+                            # Sort by the first task column if it exists
+                            if task_columns:
+                                first_task = task_columns[0]
+                                filtered_df = filtered_df.sort_values(by=first_task, ascending=False)
+                            else:
+                                filtered_df = filtered_df.sort_values(by='Model Name', ascending=True)
+                            
+                            # Recalculate Rank after filtering
+                            filtered_df = filtered_df.reset_index(drop=True)
+                            filtered_df.insert(0, 'Rank', range(1, len(filtered_df) + 1))
+                            
+                            # Ensure selected columns are present
+                            selected_cols = [col for col in selected_cols if col in filtered_df.columns]
+                            
+                            return filtered_df[selected_cols]
+                        
+                        # Bind the filter function to the appropriate events
+                        filter_inputs_tasks = [
+                            search_box_tasks,
+                            column_selector_tasks,
+                            precision_filter_tasks,
+                            license_filter_tasks,
+                            model_size_min_filter_tasks,
+                            model_size_max_filter_tasks
+                        ]
+                        search_box_tasks.submit(
+                            filter_df_tasks,
+                            inputs=filter_inputs_tasks,
+                            outputs=leaderboard_tasks
+                        )
+                        
+                        # Bind change events for CheckboxGroups and sliders
+                        for component in filter_inputs_tasks:
+                            component.change(
+                                filter_df_tasks,
+                                inputs=filter_inputs_tasks,
+                                outputs=leaderboard_tasks
+                            )
+            
+            with gr.Tab("Submit Here"):
+                gr.Markdown(ABOUT_SECTION)
+                gr.Markdown("---")
+                gr.Markdown("# Submit Your Model for Evaluation")
+                with gr.Column():
+                    model_name_input = gr.Textbox(
+                        label="Model Name", 
+                        placeholder="Enter the full model name from HuggingFace Hub (e.g., inceptionai/jais-family-30b-8k)"
+                    )
+                    revision_input = gr.Textbox(
+                        label="Revision", 
+                        placeholder="main", 
+                        value="main"
+                    )
+                    precision_input = gr.Dropdown(
+                        choices=["float16", "float32", "bfloat16", "8bit", "4bit"], 
+                        label="Precision",
+                        value="float16"
+                    )
+                    params_input = gr.Textbox(
+                        label="Params", 
+                        placeholder="Enter the approximate number of parameters as Integer (e.g., 7, 13, 30, 70 ...)"
+                    )
+                    # Changed from Dropdown to Textbox with default value "Open"
+                    license_input = gr.Textbox(
+                        label="License", 
+                        placeholder="Enter the license type (Generic one is 'Open' in case no License is provided)", 
+                        value="Open"
+                    )
+                    submit_button = gr.Button("Submit Model")
+                    submission_result = gr.Markdown()
+
+                    submit_button.click(
+                        submit_model,
+                        inputs=[model_name_input, revision_input, precision_input, params_input, license_input],
+                        outputs=submission_result
+                    )
+                    
+                    # Load pending, finished, and failed requests
+                    df_pending = load_requests('pending')
+                    df_finished = load_requests('finished')
+                    df_failed = load_requests('failed')
+
+                    # Display the tables
+                    gr.Markdown("## Evaluation Status")
+                    with gr.Accordion(f"Pending Evaluations ({len(df_pending)})", open=False):
+                        if not df_pending.empty:
+                            gr.Dataframe(df_pending)
+                        else:
+                            gr.Markdown("No pending evaluations.")
+                    with gr.Accordion(f"Finished Evaluations ({len(df_finished)})", open=False):
+                        if not df_finished.empty:
+                            gr.Dataframe(df_finished)
+                        else:
+                            gr.Markdown("No finished evaluations.")
+                    with gr.Accordion(f"Failed Evaluations ({len(df_failed)})", open=False):
+                        if not df_failed.empty:
+                            gr.Dataframe(df_failed)
+                        else:
+                            gr.Markdown("No failed evaluations.")
+            with gr.Row():
+                with gr.Accordion("📙 Citation", open=False):
+                    citation_button = gr.Textbox(
+                        value=CITATION_BUTTON_TEXT,
+                        label=CITATION_BUTTON_LABEL,
+                        lines=20,
+                        elem_id="citation-button",
+                        show_copy_button=True,
+                    )
+
+    demo.launch()
+
+if __name__ == "__main__":
+    main()