Add 12/09/2025 results

requirements.txt

@@ -0,0 +1,2 @@
+pandas==2.3.0
+gradio==4.44.1

.gitignore

@@ -0,0 +1 @@
+__pycache__/

README.md

@@ -1,12 +1,13 @@
 ---
 title: ImageNet-1k Leaderboard
-emoji: 🐠
+emoji: 🏆
 colorFrom: blue
 colorTo: red
 sdk: gradio
 sdk_version: 5.45.0
 app_file: app.py
 pinned: false
+tags:
+- leaderboard
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

app.py

@@ -0,0 +1,296 @@
+import gradio as gr
+import pandas as pd
+import json
+import os
+from constants import BANNER, INTRODUCTION_TEXT, CITATION_TEXT, METRICS_TAB_TEXT, DIR_OUTPUT_REQUESTS, LEADERBOARD_CSS
+from init import is_model_on_hub, upload_file, load_all_info_from_dataset_hub
+from utils_display import AutoEvalColumn, fields, make_clickable_model, make_clickable_paper, styled_error, styled_message, get_imagenet_columns
+import numpy as np
+from datetime import datetime, timezone
+
+def get_last_updated_date(file_path):
+    """Get the last modification date of a file and format it nicely"""
+    try:
+        timestamp = os.path.getmtime(file_path)
+        dt = datetime.fromtimestamp(timestamp)
+        # Format as "Month DDth YYYY"
+        day = dt.day
+        if 4 <= day <= 20 or 24 <= day <= 30:
+            suffix = "th"
+        else:
+            suffix = ["st", "nd", "rd"][day % 10 - 1] if day % 10 in [1, 2, 3] else "th"
+        
+        return dt.strftime(f"%b {day}{suffix} %Y")
+    except OSError:
+        return "Unknown"
+
+def load_models_list(json_path):
+    """Load models list with paper and year information"""
+    with open(json_path, 'r') as f:
+        models_list = json.load(f)
+    
+    # Create a dictionary for quick lookup
+    models_dict = {}
+    for model in models_list:
+        models_dict[model['path']] = {
+            'paper': model['paper'],
+            'year': model['year'],
+            'license': model['license']
+        }
+    return models_dict
+
+def read_jsonl_to_dataframe(jsonl_path, models_dict):
+    """Read JSONL file and convert to pandas DataFrame with proper unit conversions and model info"""
+    data = []
+    with open(jsonl_path, 'r') as f:
+        for line in f:
+            if line.strip():  # Skip empty lines
+                record = json.loads(line.strip())
+                
+                # Convert units to match expected column names
+                if 'parameters' in record:
+                    record['parameters_millions'] = record['parameters'] / 1_000_000
+                    
+                if 'flops' in record:
+                    record['flops_giga'] = record['flops'] / 1_000_000_000
+                    
+                if 'model_size' in record:
+                    record['model_size_mb'] = record['model_size'] / (1024 * 1024)
+                    
+                # Add paper and year information if model exists in models list
+                model_name = record.get('model', '')
+                if model_name in models_dict:
+                    record['paper'] = models_dict[model_name]['paper']
+                    record['year'] = str(models_dict[model_name]['year'])
+                    # Use license from models_dict if available, otherwise keep existing
+                    if 'license' not in record:
+                        record['license'] = models_dict[model_name]['license']
+                else:
+                    # Set default values for models not in the list
+                    record['paper'] = "N/A"
+                    record['year'] = "N/A"
+
+                data.append(record)
+    return pd.DataFrame(data)
+
+# Column names mapping for ImageNet-1k leaderboard
+column_names = {
+    "model": "Model",
+    "top1_accuracy": "Top-1 Accuracy ⬆️",
+    "top5_accuracy": "Top-5 Accuracy ⬆️",
+    "parameters_millions": "Parameters (M)",
+    "flops_giga": "FLOPs (G)",
+    "model_size_mb": "Model Size (MB)",
+    "paper": "Paper",
+    "year": "Year",
+    "license": "License"
+}
+
+eval_queue_repo, requested_models, jsonl_results, _ = load_all_info_from_dataset_hub()
+
+if not jsonl_results.exists():
+    raise Exception(f"JSONL file {jsonl_results} does not exist locally")
+
+# Load models list with paper and year information
+models_dict = load_models_list("/data3/salah/ImageNet-1k_leaderboard/models_list.json")
+
+# Get jsonl with data and parse columns
+original_df = read_jsonl_to_dataframe(jsonl_results, models_dict)
+
+# Get last updated date from the jsonl file
+LAST_UPDATED = get_last_updated_date(jsonl_results)
+
+# Formats the columns
+def formatter(x):
+    if type(x) is str:
+        x = x
+    elif x == -1 or pd.isna(x):
+        x = "NA"
+    else: 
+        x = round(x, 2)
+    return x
+
+# Select only the columns we want to display in the final table
+display_columns = ['model', 'top1_accuracy', 'top5_accuracy', 'parameters_millions', 
+                  'flops_giga', 'model_size_mb', 'year','paper']
+
+# Filter dataframe to only include display columns that exist
+available_columns = [col for col in display_columns if col in original_df.columns]
+filtered_df = original_df[available_columns].copy()
+
+# Format the columns
+for col in filtered_df.columns:
+    if col == "model":
+        filtered_df[col] = filtered_df[col].apply(lambda x: make_clickable_model(x))
+    elif col == "paper":
+        filtered_df[col] = filtered_df[col].apply(lambda x: make_clickable_paper(x))
+    else:
+        filtered_df[col] = filtered_df[col].apply(formatter) # For numerical values
+
+# Rename columns for display
+filtered_df.rename(columns=column_names, inplace=True)
+filtered_df.sort_values(by='Top-1 Accuracy ⬆️', ascending=False, inplace=True)
+
+# Update original_df to be the filtered version
+original_df = filtered_df
+
+# Get column definitions for ImageNet-1k
+imagenet_columns = get_imagenet_columns()
+COLS = [c.name for c in imagenet_columns]
+TYPES = [c.type for c in imagenet_columns]
+
+# ImageNet-1k specific functions (no multilingual functionality needed)
+
+
+def request_model(model_text, chb_imagenet):
+    """Request evaluation of a model on ImageNet-1k dataset"""
+    
+    # Determine the selected checkboxes
+    dataset_selection = []
+    if chb_imagenet:
+        dataset_selection.append("ImageNet-1k validation set")
+
+    if len(dataset_selection) == 0:
+        return styled_error("You need to select at least one dataset")
+        
+    base_model_on_hub, error_msg = is_model_on_hub(model_text)
+
+    if not base_model_on_hub:
+        return styled_error(f"Base model '{model_text}' {error_msg}")
+    
+    # Construct the output dictionary
+    current_time = datetime.now(timezone.utc).strftime("%Y-%m-%dT%H:%M:%SZ")
+    required_datasets = ', '.join(dataset_selection)
+    eval_entry = {
+        "date": current_time,
+        "model": model_text,
+        "datasets_selected": required_datasets,
+        "evaluation_type": "ImageNet-1k_classification"
+    }
+    
+    # Prepare file path 
+    DIR_OUTPUT_REQUESTS.mkdir(parents=True, exist_ok=True)
+    
+    fn_datasets = '@ '.join(dataset_selection)
+    filename = model_text.replace("/","@") + "@@" + fn_datasets 
+    if filename in requested_models:
+        return styled_error(f"A request for this model '{model_text}' and dataset(s) was already made.")
+    try:
+        filename_ext = filename + ".txt"
+        out_filepath = DIR_OUTPUT_REQUESTS / filename_ext
+
+        # Write the results to a text file
+        with open(out_filepath, "w") as f:
+            f.write(json.dumps(eval_entry))
+            
+        upload_file(filename, out_filepath)
+        
+        # Include file in the list of uploaded files
+        requested_models.append(filename)
+        
+        # Remove the local file
+        out_filepath.unlink()
+
+        return styled_message("🤗 Your request has been submitted and will be evaluated soon!")
+    except Exception as e:
+        return styled_error(f"Error submitting request!")
+
+def filter_main_table(show_proprietary=True):
+    filtered_df = original_df.copy()
+    
+    # Filter proprietary models if needed
+    if not show_proprietary and "License" in filtered_df.columns:
+        # Keep only models with "Open" license
+        filtered_df = filtered_df[filtered_df["License"] == "Open"]
+        
+    return filtered_df
+
+with gr.Blocks(css=LEADERBOARD_CSS) as demo:
+    gr.HTML(BANNER, elem_id="banner")
+    gr.Markdown(INTRODUCTION_TEXT, elem_classes="markdown-text")
+
+    with gr.Tabs(elem_classes="tab-buttons") as tabs:
+        with gr.TabItem("🏅 Leaderboard", elem_id="imagenet-benchmark-tab-table", id=0):
+            leaderboard_table = gr.components.Dataframe(
+                value=original_df,
+                datatype=TYPES,
+                elem_id="leaderboard-table",
+                interactive=False,
+                visible=True,
+            )
+            with gr.Row():
+                show_proprietary_checkbox = gr.Checkbox(
+                    label="Show proprietary models",
+                    value=True,
+                    elem_id="show-proprietary-checkbox"
+                )
+            
+            # Connect checkbox to the filtering function
+            show_proprietary_checkbox.change(
+                filter_main_table,
+                inputs=[show_proprietary_checkbox],
+                outputs=leaderboard_table
+            )
+
+        with gr.TabItem("📈 Metrics", elem_id="imagenet-metrics-tab", id=1):
+            gr.Markdown(METRICS_TAB_TEXT, elem_classes="markdown-text")
+
+        with gr.TabItem("✉️✨ Request a model here!", elem_id="imagenet-request-tab", id=2):
+            with gr.Column():
+                gr.Markdown("# ✉️✨ Request evaluation for a new model here!", elem_classes="markdown-text")
+            with gr.Column():
+                gr.Markdown("Select a dataset:", elem_classes="markdown-text")
+                with gr.Column():
+                    model_name_textbox = gr.Textbox(label="Model name (user_name/model_name)")
+                    chb_imagenet = gr.Checkbox(label="ImageNet-1k validation set", value=True, interactive=True)
+                with gr.Column():
+                    mdw_submission_result = gr.Markdown()
+                    btn_submitt = gr.Button(value="🚀 Request Evaluation")
+                    btn_submitt.click(request_model, 
+                                      [model_name_textbox, chb_imagenet], 
+                                      mdw_submission_result)
+        
+        # add an about section
+        with gr.TabItem("🤗 About", elem_id="imagenet-about-tab", id=3):
+            gr.Markdown("## About", elem_classes="markdown-text")
+            gr.Markdown("""
+            ### ImageNet-1k Leaderboard
+            
+            This leaderboard tracks the performance of computer vision models on the ImageNet-1k dataset, 
+            which is one of the most widely used benchmarks for image classification.
+            
+            #### Dataset Information
+            - **Training images**: 1.2 million
+            - **Validation images**: 50,000  
+            - **Classes**: 1,000 object categories
+            - **Image resolution**: Variable (typically 224×224 or 384×384)
+            
+            #### Hardware Configuration
+            - **GPU**: NVIDIA L4
+            - All results are tested on the same hardware configuration to ensure fair comparison
+            
+            #### Evaluation Metrics
+            - **Top-1 Accuracy**: Percentage of images where the top prediction is correct
+            - **Top-5 Accuracy**: Percentage of images where the correct class is in top 5 predictions
+            - **Parameters**: Number of trainable parameters in millions
+            - **FLOPs**: Floating point operations in billions
+            - **Model Size**: Size of the model file in MB
+            
+            #### Contributing
+            To add your model to the leaderboard, use the "Request a model here!" tab. 
+            Your model will be evaluated on the ImageNet-1k validation set using NVIDIA L4 GPU and added to the leaderboard.
+            """, elem_classes="markdown-text")
+
+    gr.Markdown(f"Last updated on **{LAST_UPDATED}**", elem_classes="markdown-text")
+    
+    with gr.Row():
+        with gr.Accordion("📙 Citation", open=False):
+            gr.Textbox(
+                value=CITATION_TEXT, lines=7,
+                label="Copy the BibTeX snippet to cite this source",
+                elem_id="citation-button",
+                show_copy_button=True,
+            )
+
+if __name__ == "__main__":
+    demo.launch()

constants.py

@@ -0,0 +1,125 @@
+# Constants for ImageNet-1k Leaderboard
+
+BANNER = """
+<div style="text-align: center; margin-bottom: 20px;">
+    <h1>🏆 ImageNet-1k Leaderboard</h1>
+    <p style="font-size: 18px; color: #666;">Compare computer vision models on ImageNet-1k classification</p>
+</div>
+"""
+
+INTRODUCTION_TEXT = """
+# ImageNet-1k Leaderboard
+
+Welcome to the ImageNet-1k Leaderboard! This leaderboard tracks the performance of various computer vision models on the ImageNet-1k dataset, which contains 1.2 million training images across 1000 classes.
+
+## Key Metrics
+
+- **Top-1 Accuracy**: Percentage of images where the model's top prediction is correct
+- **Top-5 Accuracy**: Percentage of images where the correct class is among the top 5 predictions
+- **Parameters**: Number of trainable parameters in the model
+- **FLOPs**: Floating point operations required for inference
+- **Inference Time**: Average time per image (if available)
+
+## Dataset
+
+ImageNet-1k is a subset of the ImageNet dataset containing:
+- **Training set**: 1.2M images
+- **Validation set**: 50K images  
+- **Classes**: 1000 object categories
+- **Image size**: Variable (typically resized to 224x224 or 384x384)
+
+## Hardware Configuration
+
+All results are tested on **NVIDIA L4 GPU** to ensure consistent and fair comparison across models.
+
+The leaderboard is sorted by Top-1 Accuracy (descending) as the primary metric.
+"""
+
+CITATION_TEXT = """@article{imagenet,
+  title={ImageNet: A large-scale hierarchical image database},
+  author={Deng, Jia and Dong, Wei and Socher, Richard and Li, Li-Jia and Li, Kai and Fei-Fei, Li},
+  journal={2009 IEEE conference on computer vision and pattern recognition},
+  pages={248--255},
+  year={2009},
+  organization={IEEE}
+}"""
+
+METRICS_TAB_TEXT = """
+# Evaluation Metrics
+
+## Hardware Configuration
+All models are evaluated on **NVIDIA L4 GPU** to ensure consistent and fair comparison across different architectures.
+
+## Top-1 Accuracy
+The percentage of test images for which the model's highest confidence prediction matches the ground truth label.
+
+## Top-5 Accuracy  
+The percentage of test images for which the ground truth label appears in the model's top 5 highest confidence predictions.
+
+## Parameters
+The total number of trainable parameters in the model. This gives an indication of model complexity and size.
+
+## FLOPs (Floating Point Operations)
+The number of floating point operations required for a single forward pass through the model. This is a measure of computational complexity.
+
+## Inference Time
+The average time required to process a single image on NVIDIA L4 GPU. This metric helps compare the computational efficiency of different models.
+
+## Model Size
+The size of the model file in MB or GB, indicating storage requirements.
+"""
+
+# Directory for storing evaluation requests
+from pathlib import Path
+DIR_OUTPUT_REQUESTS = Path("evaluation_requests")
+
+# CSS styling for the leaderboard
+LEADERBOARD_CSS = """
+.leaderboard-table {
+    font-family: 'Segoe UI', Tahoma, Geneva, Verdana, sans-serif;
+}
+
+.leaderboard-table th {
+    background-color: #f8f9fa;
+    font-weight: bold;
+    text-align: center;
+    padding: 12px;
+    border: 1px solid #dee2e6;
+}
+
+.leaderboard-table td {
+    text-align: center;
+    padding: 8px 12px;
+    border: 1px solid #dee2e6;
+}
+
+.leaderboard-table tr:nth-child(even) {
+    background-color: #f8f9fa;
+}
+
+.leaderboard-table tr:hover {
+    background-color: #e9ecef;
+}
+
+.markdown-text {
+    font-family: 'Segoe UI', Tahoma, Geneva, Verdana, sans-serif;
+    line-height: 1.6;
+}
+
+.tab-buttons {
+    margin-bottom: 20px;
+}
+
+#banner {
+    text-align: center;
+    margin-bottom: 30px;
+    padding: 20px;
+    background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
+    color: white;
+    border-radius: 10px;
+}
+
+#show-proprietary-checkbox {
+    margin-top: 10px;
+}
+"""

evaluation.py

@@ -0,0 +1,241 @@
+import torch
+import argparse
+import json
+import time
+import os
+from fvcore.nn import FlopCountAnalysis, parameter_count_table
+from torch.utils.data import DataLoader
+from datasets import load_dataset
+from transformers import AutoModelForImageClassification, AutoImageProcessor
+from tqdm import tqdm
+
+
+def benchmark_inference(model, processor, device, runs=20, warmup=5):
+    dummy_image = torch.randn(1, 3, processor.size['height'], processor.size['width'], device=device)
+    model.eval()
+    
+    # Warmup
+    for _ in range(warmup):
+        _ = model(dummy_image)
+    
+    torch.cuda.synchronize()
+    start = time.time()
+    
+    for _ in range(runs):
+        _ = model(dummy_image)
+    
+    torch.cuda.synchronize()
+    elapsed = (time.time() - start) * 1000
+    
+    avg_latency = elapsed / runs
+    throughput = 1000.0 / avg_latency
+    
+    return avg_latency, throughput
+
+
+def load_dataloader(args):
+    dataset = load_dataset(args.data_path, split="validation")
+    def collate_fn(batch):
+        images = [item['image'].convert('RGB') for item in batch]
+        labels = [item['label'] for item in batch]
+        labels = torch.tensor(labels)
+        return {
+            'image': images,
+            'label': labels
+        }
+    return DataLoader(dataset, batch_size=args.batch_size, shuffle=False, num_workers=4, collate_fn=collate_fn)
+
+
+def evaluate_model(args, dataloader, model_info):
+    """Evaluate a model on ImageNet-1k validation set"""
+    device = torch.device(args.device if torch.cuda.is_available() else "cpu")
+    
+    model = AutoModelForImageClassification.from_pretrained(
+        model_info["path"], 
+        torch_dtype=torch.float32  # Use float32 for consistency
+    )
+    
+    processor = AutoImageProcessor.from_pretrained(model_info["path"])
+    print(dir(processor))
+    print(processor.size)
+    model.to(device)
+    model.eval()
+    
+    # Initialize metrics
+    correct_top1 = 0
+    correct_top5 = 0
+    total_samples = 0
+    
+    with torch.no_grad():
+        for batch_idx, batch in enumerate(tqdm(dataloader, desc="Evaluating")):
+            images = batch['image']
+            labels = batch['label']
+
+            inputs = processor(images, return_tensors="pt")
+            
+            inputs = {k: v.to(device) for k, v in inputs.items()}
+            labels = labels.to(device)
+            
+
+            outputs = model(**inputs)
+            torch.cuda.synchronize()
+            
+            logits = outputs.logits
+            predictions = torch.softmax(logits, dim=-1)
+            
+            _, predicted_classes = torch.topk(predictions, 5, dim=1)
+            
+            correct_top1 += (predicted_classes[:, 0] == labels).sum().item()
+            
+            for i in range(5):
+                correct_top5 += (predicted_classes[:, i] == labels).sum().item()
+            
+            total_samples += labels.size(0)
+            
+    top1_accuracy = (correct_top1 / total_samples) * 100
+    top5_accuracy = (correct_top5 / total_samples) * 100
+    avg_inference_time, throughput = benchmark_inference(model, processor, device)
+
+
+    sample_inputs = processor(images[:1], return_tensors="pt")
+    sample_inputs = {k: v.to(device) for k, v in sample_inputs.items()}
+
+    # Calculate model parameters
+    total_params = sum(p.numel() for p in model.parameters())
+    parameters_millions = total_params
+    
+    # Calculate model size
+    model_size = sum(p.numel() * p.element_size() for p in model.parameters())
+
+    sample_tensor = sample_inputs['pixel_values']
+    flops = FlopCountAnalysis(model, sample_tensor).total()
+    
+    metrics = {
+        "model": model_info["path"],
+        "top1_accuracy": top1_accuracy,
+        "top5_accuracy": top5_accuracy,
+        "parameters": total_params,
+        "flops": flops,
+        "inference_time": avg_inference_time,
+        "model_size": model_size,
+        "license": model_info["license"]
+    }
+    
+    return metrics
+        
+
+
+
+def load_models_list(json_path):
+    """Load models list from JSON file"""
+    with open(json_path, 'r') as f:
+        models = json.load(f)
+    return models
+
+
+def load_existing_results(output_path):
+    """Load existing results from JSONL file and return set of evaluated model paths"""
+    evaluated_models = set()
+    results = []
+    
+    if os.path.exists(output_path):
+        try:
+            with open(output_path, 'r') as f:
+                for line in f:
+                    if line.strip():  # Skip empty lines
+                        result = json.loads(line.strip())
+                        evaluated_models.add(result['model'])
+                        results.append(result)
+            print(f"Found {len(evaluated_models)} existing results in {output_path}")
+        except (json.JSONDecodeError, KeyError) as e:
+            print(f"Warning: Error reading existing results from {output_path}: {e}")
+            print("Starting fresh evaluation...")
+    
+    return evaluated_models, results
+
+
+def save_result_to_jsonl(result, output_path):
+    """Append a single evaluation result to JSONL file"""
+    with open(output_path, 'a') as jsonlfile:
+        jsonlfile.write(json.dumps(result) + '\n')
+    
+    print(f"Result saved to {output_path}")
+
+
+def save_results_to_jsonl(results, output_path):
+    """Save evaluation results to JSONL file (overwrites existing file)"""
+    if not results:
+        print("No results to save.")
+        return
+    
+    with open(output_path, 'w') as jsonlfile:
+        for result in results:
+            jsonlfile.write(json.dumps(result) + '\n')
+    
+    print(f"Results saved to {output_path}")
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser(
+                    prog='ImageNet-1k Evaluation',
+                    description='Evaluate models on ImageNet-1k validation set',
+                    epilog='Results will be saved to JSONL file')
+    parser.add_argument('--data-path', default="ILSVRC/imagenet-1k", 
+                       help='Path to ImageNet-1k dataset')
+    parser.add_argument('--device', default="cuda", 
+                       help='Device to use for evaluation (cuda/cpu)')
+    parser.add_argument('--batch-size', type=int, default=128, 
+                       help='Batch size for evaluation')
+    parser.add_argument('--models-list', default="models_list.json", 
+                       help='Path to JSON file containing models list')
+    parser.add_argument('--output-path', default="imagenet_results.jsonl", 
+                       help='Path to save evaluation results')
+    args = parser.parse_args()
+
+    # Override data path with absolute path
+    args.device = "cuda:6"
+    args.data_path = "/data3/salah/datasets/imagenet-1k"
+
+    # Load models list
+    models_list = load_models_list(args.models_list)
+
+    # Load existing results to avoid re-evaluating models
+    evaluated_models, existing_results = load_existing_results(args.output_path)
+    
+    # Filter out models that have already been evaluated
+    models_to_evaluate = [model for model in models_list if model['path'] not in evaluated_models]
+    
+    if len(models_to_evaluate) < len(models_list):
+        skipped_count = len(models_list) - len(models_to_evaluate)
+        print(f"Skipping {skipped_count} models that have already been evaluated")
+    
+    if not models_to_evaluate:
+        print("All models have already been evaluated!")
+        results = existing_results
+    else:
+        # Load dataset only if we have models to evaluate
+        print("Loading dataset...")
+        dataloader = load_dataloader(args)
+        print(f"Dataset loaded with {len(dataloader)} batches")
+        
+        # Evaluate remaining models
+        results = existing_results.copy()  # Start with existing results
+        for i, model_info in enumerate(models_to_evaluate):
+            print(f"\n{'='*50}")
+            print(f"Evaluating model {i+1}/{len(models_to_evaluate)}: {model_info['path']}")
+            print(f"{'='*50}")
+            
+            metrics = evaluate_model(args, dataloader, model_info)
+            results.append(metrics)
+            
+            # Save result immediately after each model evaluation
+            save_result_to_jsonl(metrics, args.output_path)
+
+    print(f"\nEvaluation complete! Results saved to {args.output_path}")
+    
+    # Print summary
+    print("\nSummary:")
+    for result in results:
+        if result['top1_accuracy'] != -1:
+            print(f"  {result['model']}: {result['top1_accuracy']:.2f}% Top-1, {result['top5_accuracy']:.2f}% Top-5")
+        else:
+            print(f"  {result['model']}: Failed to evaluate")

imagenet_results.jsonl

@@ -0,0 +1,19 @@
+{"model": "microsoft/resnet-18", "top1_accuracy": 69.6, "top5_accuracy": 89.098, "parameters": 11689512, "flops": 1819065856, "inference_time": 2.6572346687316895, "model_size": 46758048, "license": "Open"}
+{"model": "microsoft/resnet-26", "top1_accuracy": 75.27199999999999, "top5_accuracy": 92.596, "parameters": 15995176, "flops": 2357058560, "inference_time": 3.2204389572143555, "model_size": 63980704, "license": "Open"}
+{"model": "microsoft/resnet-34", "top1_accuracy": 75.14999999999999, "top5_accuracy": 92.186, "parameters": 21797672, "flops": 3671262720, "inference_time": 3.9008617401123047, "model_size": 87190688, "license": "Open"}
+{"model": "microsoft/resnet-50", "top1_accuracy": 80.128, "top5_accuracy": 94.502, "parameters": 25557032, "flops": 4111512576, "inference_time": 5.436229705810547, "model_size": 102228128, "license": "Open"}
+{"model": "microsoft/resnet-101", "top1_accuracy": 81.914, "top5_accuracy": 95.692, "parameters": 44549160, "flops": 7833969664, "inference_time": 10.08899211883545, "model_size": 178196640, "license": "Open"}
+{"model": "microsoft/resnet-152", "top1_accuracy": 82.5, "top5_accuracy": 96.076, "parameters": 60192808, "flops": 11558835200, "inference_time": 14.954924583435059, "model_size": 240771232, "license": "Open"}
+{"model": "facebook/convnext-base-224-22k-1k", "top1_accuracy": 85.82, "top5_accuracy": 97.858, "parameters": 88591464, "flops": 15378066432, "inference_time": 8.328402042388916, "model_size": 354365856, "license": "Open"}
+{"model": "facebook/convnext-base-224", "top1_accuracy": 83.842, "top5_accuracy": 96.746, "parameters": 88591464, "flops": 15378066432, "inference_time": 8.364510536193848, "model_size": 354365856, "license": "Open"}
+{"model": "facebook/convnext-base-384-22k-1k", "top1_accuracy": 86.816, "top5_accuracy": 98.25, "parameters": 88591464, "flops": 45190689792, "inference_time": 8.065569400787354, "model_size": 354365856, "license": "Open"}
+{"model": "facebook/convnext-base-384", "top1_accuracy": 85.098, "top5_accuracy": 97.344, "parameters": 88591464, "flops": 45190689792, "inference_time": 12.745106220245361, "model_size": 354365856, "license": "Open"}
+{"model": "facebook/convnext-large-224-22k-1k", "top1_accuracy": 86.614, "top5_accuracy": 98.042, "parameters": 197767336, "flops": 34396439040, "inference_time": 13.010406494140625, "model_size": 791069344, "license": "Open"}
+{"model": "facebook/convnext-large-224", "top1_accuracy": 84.312, "top5_accuracy": 96.89999999999999, "parameters": 197767336, "flops": 34396439040, "inference_time": 13.037407398223877, "model_size": 791069344, "license": "Open"}
+{"model": "facebook/convnext-large-384-22k-1k", "top1_accuracy": 87.456, "top5_accuracy": 98.372, "parameters": 197767336, "flops": 101080419840, "inference_time": 13.244283199310303, "model_size": 791069344, "license": "Open"}
+{"model": "facebook/convnext-large-384", "top1_accuracy": 85.5, "top5_accuracy": 97.592, "parameters": 197767336, "flops": 101080419840, "inference_time": 12.705540657043457, "model_size": 791069344, "license": "Open"}
+{"model": "facebook/convnext-small-224", "top1_accuracy": 83.166, "top5_accuracy": 96.42399999999999, "parameters": 50223688, "flops": 8701214976, "inference_time": 10.579216480255127, "model_size": 200894752, "license": "Open"}
+{"model": "facebook/convnext-tiny-224", "top1_accuracy": 82.062, "top5_accuracy": 95.86200000000001, "parameters": 28589128, "flops": 4466260224, "inference_time": 4.517614841461182, "model_size": 114356512, "license": "Open"}
+{"model": "facebook/convnext-xlarge-224-22k-1k", "top1_accuracy": 86.98599999999999, "top5_accuracy": 98.202, "parameters": 350196968, "flops": 60967704576, "inference_time": 22.357892990112305, "model_size": 1400787872, "license": "Open"}
+{"model": "facebook/convnext-xlarge-384-22k-1k", "top1_accuracy": 87.764, "top5_accuracy": 98.55199999999999, "parameters": 350196968, "flops": 179166406656, "inference_time": 22.17559814453125, "model_size": 1400787872, "license": "Open"}
+{"model": "facebook/deit-base-distilled-patch16-224", "top1_accuracy": 83.39800000000001, "top5_accuracy": 96.43599999999999, "parameters": 87338192, "flops": 16953211392, "inference_time": 5.678451061248779, "model_size": 349352768, "license": "Open"}

init.py

@@ -0,0 +1,47 @@
+import requests
+from pathlib import Path
+import pandas as pd
+from typing import Tuple, List
+
+# Mock data for demonstration - in a real implementation, this would load from a dataset hub
+def is_model_on_hub(model_name: str) -> Tuple[bool, str]:
+    """
+    Check if a model exists on Hugging Face Hub.
+    Returns (is_on_hub, error_message)
+    """
+    try:
+        # For demo purposes, we'll accept any model name that contains a slash
+        if "/" not in model_name:
+            return False, "Model name must be in format 'username/model_name'"
+        
+        # In a real implementation, you would check the Hugging Face API
+        # response = requests.get(f"https://huggingface.co/api/models/{model_name}")
+        # return response.status_code == 200, ""
+        
+        return True, ""
+    except Exception as e:
+        return False, f"Error checking model: {str(e)}"
+
+def upload_file(filename: str, filepath: Path) -> None:
+    """
+    Upload a file to the dataset hub.
+    In a real implementation, this would upload to Hugging Face Hub.
+    """
+    # For demo purposes, we'll just print the upload
+    print(f"Uploading {filename} from {filepath}")
+    # In a real implementation, you would use the Hugging Face Hub API
+    pass
+
+def load_all_info_from_dataset_hub() -> Tuple[Path, List[str], Path, None]:
+    """
+    Load evaluation queue, requested models, and results from dataset hub.
+    Returns (eval_queue_repo, requested_models, jsonl_results, multilingual_jsonl_path)
+    """
+    # Create mock data for demonstration
+    eval_queue_repo = Path("evaluation_queue")
+    requested_models = []
+    
+    # Create a sample JSONL with ImageNet-1k results
+    jsonl_results = Path("imagenet_results.jsonl")
+    
+    return eval_queue_repo, requested_models, jsonl_results, None

models_list.json

@@ -0,0 +1,177 @@
+[
+    {"path": "microsoft/resnet-18", "paper": "https://arxiv.org/abs/1512.03385", "license": "Open", "year": 2015},
+    {"path": "microsoft/resnet-26", "paper": "https://arxiv.org/abs/1512.03385", "license": "Open", "year": 2015},
+    {"path": "microsoft/resnet-34", "paper": "https://arxiv.org/abs/1512.03385", "license": "Open", "year": 2015},
+    {"path": "microsoft/resnet-50", "paper": "https://arxiv.org/abs/1512.03385", "license": "Open", "year": 2015},
+    {"path": "microsoft/resnet-101", "paper": "https://arxiv.org/abs/1512.03385", "license": "Open", "year": 2015},
+    {"path": "microsoft/resnet-152", "paper": "https://arxiv.org/abs/1512.03385", "license": "Open", "year": 2015},
+
+    {"path": "facebook/convnext-base-224-22k-1k", "paper": "https://arxiv.org/abs/2201.09792", "license": "Open", "year": 2022},
+    {"path": "facebook/convnext-base-224", "paper": "https://arxiv.org/abs/2201.09792", "license": "Open", "year": 2022},
+    {"path": "facebook/convnext-base-384-22k-1k", "paper": "https://arxiv.org/abs/2201.09792", "license": "Open", "year": 2022},
+    {"path": "facebook/convnext-base-384", "paper": "https://arxiv.org/abs/2201.09792", "license": "Open", "year": 2022},
+    {"path": "facebook/convnext-large-224-22k-1k", "paper": "https://arxiv.org/abs/2201.09792", "license": "Open", "year": 2022},
+    {"path": "facebook/convnext-large-224", "paper": "https://arxiv.org/abs/2201.09792", "license": "Open", "year": 2022},
+    {"path": "facebook/convnext-large-384-22k-1k", "paper": "https://arxiv.org/abs/2201.09792", "license": "Open", "year": 2022},
+    {"path": "facebook/convnext-large-384", "paper": "https://arxiv.org/abs/2201.09792", "license": "Open", "year": 2022},
+    {"path": "facebook/convnext-small-224", "paper": "https://arxiv.org/abs/2201.09792", "license": "Open", "year": 2022},
+    {"path": "facebook/convnext-tiny-224", "paper": "https://arxiv.org/abs/2201.09792", "license": "Open", "year": 2022},
+    {"path": "facebook/convnext-xlarge-224-22k-1k", "paper": "https://arxiv.org/abs/2201.09792", "license": "Open", "year": 2022},
+    {"path": "facebook/convnext-xlarge-384-22k-1k", "paper": "https://arxiv.org/abs/2201.09792", "license": "Open", "year": 2022},
+
+    {"path": "facebook/deit-base-distilled-patch16-224", "paper": "https://arxiv.org/abs/2012.12877", "license": "Open", "year": 2020},
+    {"path": "facebook/deit-base-distilled-patch16-384", "paper": "https://arxiv.org/abs/2012.12877", "license": "Open", "year": 2020},
+    {"path": "facebook/deit-base-patch16-224", "paper": "https://arxiv.org/abs/2012.12877", "license": "Open", "year": 2020},
+    {"path": "facebook/deit-base-patch16-384", "paper": "https://arxiv.org/abs/2012.12877", "license": "Open", "year": 2020},
+    {"path": "facebook/deit-small-distilled-patch16-224", "paper": "https://arxiv.org/abs/2012.12877", "license": "Open", "year": 2020},
+    {"path": "facebook/deit-small-patch16-224", "paper": "https://arxiv.org/abs/2012.12877", "license": "Open", "year": 2020},
+    {"path": "facebook/deit-tiny-distilled-patch16-224", "paper": "https://arxiv.org/abs/2012.12877", "license": "Open", "year": 2020},
+    {"path": "facebook/deit-tiny-patch16-224", "paper": "https://arxiv.org/abs/2012.12877", "license": "Open", "year": 2020},
+
+    {"path": "facebook/regnet-x-002", "paper": "https://arxiv.org/abs/2003.13678", "license": "Open", "year": 2020},
+    {"path": "facebook/regnet-x-004", "paper": "https://arxiv.org/abs/2003.13678", "license": "Open", "year": 2020},
+    {"path": "facebook/regnet-x-006", "paper": "https://arxiv.org/abs/2003.13678", "license": "Open", "year": 2020},
+    {"path": "facebook/regnet-x-008", "paper": "https://arxiv.org/abs/2003.13678", "license": "Open", "year": 2020},
+    {"path": "facebook/regnet-x-016", "paper": "https://arxiv.org/abs/2003.13678", "license": "Open", "year": 2020},
+    {"path": "facebook/regnet-x-032", "paper": "https://arxiv.org/abs/2003.13678", "license": "Open", "year": 2020},
+    {"path": "facebook/regnet-x-040", "paper": "https://arxiv.org/abs/2003.13678", "license": "Open", "year": 2020},
+    {"path": "facebook/regnet-x-064", "paper": "https://arxiv.org/abs/2003.13678", "license": "Open", "year": 2020},
+    {"path": "facebook/regnet-x-080", "paper": "https://arxiv.org/abs/2003.13678", "license": "Open", "year": 2020},
+    {"path": "facebook/regnet-x-120", "paper": "https://arxiv.org/abs/2003.13678", "license": "Open", "year": 2020},
+    {"path": "facebook/regnet-x-160", "paper": "https://arxiv.org/abs/2003.13678", "license": "Open", "year": 2020},
+    {"path": "facebook/regnet-x-320", "paper": "https://arxiv.org/abs/2003.13678", "license": "Open", "year": 2020},
+    {"path": "facebook/regnet-y-002", "paper": "https://arxiv.org/abs/2003.13678", "license": "Open", "year": 2020},
+    {"path": "facebook/regnet-y-004", "paper": "https://arxiv.org/abs/2003.13678", "license": "Open", "year": 2020},
+    {"path": "facebook/regnet-y-006", "paper": "https://arxiv.org/abs/2003.13678", "license": "Open", "year": 2020},
+    {"path": "facebook/regnet-y-008", "paper": "https://arxiv.org/abs/2003.13678", "license": "Open", "year": 2020},
+    {"path": "facebook/regnet-y-016", "paper": "https://arxiv.org/abs/2003.13678", "license": "Open", "year": 2020},
+    {"path": "facebook/regnet-y-032", "paper": "https://arxiv.org/abs/2003.13678", "license": "Open", "year": 2020},
+    {"path": "facebook/regnet-y-040", "paper": "https://arxiv.org/abs/2003.13678", "license": "Open", "year": 2020},
+    {"path": "facebook/regnet-y-064", "paper": "https://arxiv.org/abs/2003.13678", "license": "Open", "year": 2020},
+    {"path": "facebook/regnet-y-080", "paper": "https://arxiv.org/abs/2003.13678", "license": "Open", "year": 2020},
+    {"path": "facebook/regnet-y-120", "paper": "https://arxiv.org/abs/2003.13678", "license": "Open", "year": 2020},
+    {"path": "facebook/regnet-y-160", "paper": "https://arxiv.org/abs/2003.13678", "license": "Open", "year": 2020},
+    {"path": "facebook/regnet-y-320", "paper": "https://arxiv.org/abs/2003.13678", "license": "Open", "year": 2020},
+    {"path": "facebook/regnet-y-320-seer-in1k", "paper": "https://arxiv.org/abs/2003.13678", "license": "Open", "year": 2020},
+    {"path": "facebook/regnet-y-640-seer-in1k", "paper": "https://arxiv.org/abs/2003.13678", "license": "Open", "year": 2020},
+    {"path": "facebook/regnet-y-1280-seer-in1k", "paper": "https://arxiv.org/abs/2003.13678", "license": "Open", "year": 2020},
+    {"path": "facebook/regnet-y-10b-seer-in1k", "paper": "https://arxiv.org/abs/2003.13678", "license": "Open", "year": 2020},
+
+    {"path": "facebook/data2vec-vision-base", "paper": "https://arxiv.org/abs/2202.03555", "license": "Open", "year": 2022},
+    {"path": "facebook/data2vec-vision-large", "paper": "https://arxiv.org/abs/2202.03555", "license": "Open", "year": 2022},
+    {"path": "facebook/data2vec-vision-large-ft1k", "paper": "https://arxiv.org/abs/2202.03555", "license": "Open", "year": 2022},
+    {"path": "facebook/data2vec-vision-base-ft1k", "paper": "https://arxiv.org/abs/2202.03555", "license": "Open", "year": 2022},
+
+    {"path": "facebook/levit-128", "paper": "https://arxiv.org/abs/2104.01136", "license": "Open", "year": 2021},
+    {"path": "facebook/levit-128S", "paper": "https://arxiv.org/abs/2104.01136", "license": "Open", "year": 2021},
+    {"path": "facebook/levit-192", "paper": "https://arxiv.org/abs/2104.01136", "license": "Open", "year": 2021},
+    {"path": "facebook/levit-256", "paper": "https://arxiv.org/abs/2104.01136", "license": "Open", "year": 2021},
+    {"path": "facebook/levit-384", "paper": "https://arxiv.org/abs/2104.01136", "license": "Open", "year": 2021},
+
+    {"path": "facebook/convnextv2-atto-1k-224", "paper": "https://arxiv.org/abs/2301.00808", "license": "Open", "year": 2023},
+    {"path": "facebook/convnextv2-femto-1k-224", "paper": "https://arxiv.org/abs/2301.00808", "license": "Open", "year": 2023},
+    {"path": "facebook/convnextv2-pico-1k-224", "paper": "https://arxiv.org/abs/2301.00808", "license": "Open", "year": 2023},
+    {"path": "facebook/convnextv2-nano-1k-224", "paper": "https://arxiv.org/abs/2301.00808", "license": "Open", "year": 2023},
+    {"path": "facebook/convnextv2-tiny-1k-224", "paper": "https://arxiv.org/abs/2301.00808", "license": "Open", "year": 2023},
+    {"path": "facebook/convnextv2-base-1k-224", "paper": "https://arxiv.org/abs/2301.00808", "license": "Open", "year": 2023},
+    {"path": "facebook/convnextv2-large-1k-224", "paper": "https://arxiv.org/abs/2301.00808", "license": "Open", "year": 2023},
+    {"path": "facebook/convnextv2-huge-1k-224", "paper": "https://arxiv.org/abs/2301.00808", "license": "Open", "year": 2023},
+    {"path": "facebook/convnextv2-nano-22k-224", "paper": "https://arxiv.org/abs/2301.00808", "license": "Open", "year": 2023},
+    {"path": "facebook/convnextv2-nano-22k-384", "paper": "https://arxiv.org/abs/2301.00808", "license": "Open", "year": 2023},
+    {"path": "facebook/convnextv2-tiny-22k-224", "paper": "https://arxiv.org/abs/2301.00808", "license": "Open", "year": 2023},
+    {"path": "facebook/convnextv2-tiny-22k-384", "paper": "https://arxiv.org/abs/2301.00808", "license": "Open", "year": 2023},
+    {"path": "facebook/convnextv2-base-22k-224", "paper": "https://arxiv.org/abs/2301.00808", "license": "Open", "year": 2023},
+    {"path": "facebook/convnextv2-base-22k-384", "paper": "https://arxiv.org/abs/2301.00808", "license": "Open", "year": 2023},
+    {"path": "facebook/convnextv2-large-22k-224", "paper": "https://arxiv.org/abs/2301.00808", "license": "Open", "year": 2023},
+    {"path": "facebook/convnextv2-large-22k-384", "paper": "https://arxiv.org/abs/2301.00808", "license": "Open", "year": 2023},
+    {"path": "facebook/convnextv2-huge-22k-384", "paper": "https://arxiv.org/abs/2301.00808", "license": "Open", "year": 2023},
+    {"path": "facebook/convnextv2-huge-22k-512", "paper": "https://arxiv.org/abs/2301.00808", "license": "Open", "year": 2023},
+
+    {"path": "facebook/dinov2-small-imagenet1k-1-layer", "paper": "https://arxiv.org/abs/2304.07193", "license": "Open", "year": 2023},
+    {"path": "facebook/dinov2-base-imagenet1k-1-layer", "paper": "https://arxiv.org/abs/2304.07193", "license": "Open", "year": 2023},
+    {"path": "facebook/dinov2-large-imagenet1k-1-layer", "paper": "https://arxiv.org/abs/2304.07193", "license": "Open", "year": 2023},
+    {"path": "facebook/dinov2-giant-imagenet1k-1-layer", "paper": "https://arxiv.org/abs/2304.07193", "license": "Open", "year": 2023},
+    {"path": "facebook/dinov2-with-registers-small-imagenet1k-1-layer", "paper": "https://arxiv.org/abs/2304.07193", "license": "Open", "year": 2023},
+    {"path": "facebook/dinov2-with-registers-base-imagenet1k-1-layer", "paper": "https://arxiv.org/abs/2304.07193", "license": "Open", "year": 2023},
+    {"path": "facebook/dinov2-with-registers-large-imagenet1k-1-layer", "paper": "https://arxiv.org/abs/2304.07193", "license": "Open", "year": 2023},
+    {"path": "facebook/dinov2-with-registers-giant-imagenet1k-1-layer", "paper": "https://arxiv.org/abs/2304.07193", "license": "Open", "year": 2023},
+
+    {"path": "facebook/hiera-tiny-224-in1k-hf", "paper": "https://arxiv.org/abs/2306.00989", "license": "Open", "year": 2023},
+    {"path": "facebook/hiera-small-224-in1k-hf", "paper": "https://arxiv.org/abs/2306.00989", "license": "Open", "year": 2023},
+    {"path": "facebook/hiera-base-224-in1k-hf", "paper": "https://arxiv.org/abs/2306.00989", "license": "Open", "year": 2023},
+    {"path": "facebook/hiera-base-plus-224-in1k-hf", "paper": "https://arxiv.org/abs/2306.00989", "license": "Open", "year": 2023},
+    {"path": "facebook/hiera-large-224-in1k-hf", "paper": "https://arxiv.org/abs/2306.00989", "license": "Open", "year": 2023},
+    {"path": "facebook/hiera-huge-224-in1k-hf", "paper": "https://arxiv.org/abs/2306.00989", "license": "Open", "year": 2023},
+    {"path": "facebook/hiera_small_224.mae_in1k_ft_in1k", "paper": "https://arxiv.org/abs/2306.00989", "license": "Open", "year": 2023},
+    {"path": "facebook/hiera_base_224.mae_in1k_ft_in1k", "paper": "https://arxiv.org/abs/2306.00989", "license": "Open", "year": 2023},
+
+    {"path": "facebook/superblock-vit-b-16", "paper": "https://arxiv.org/abs/2305.15798", "license": "Open", "year": 2023},
+
+    {"path": "google/vit-base-patch16-224", "paper": "https://arxiv.org/abs/2010.11929", "license": "Apache-2.0", "year": 2020},
+    {"path": "google/vit-large-patch16-384", "paper": "https://arxiv.org/abs/2010.11929", "license": "Apache-2.0", "year": 2020},
+    {"path": "google/vit-base-patch16-384", "paper": "https://arxiv.org/abs/2010.11929", "license": "Apache-2.0", "year": 2020},
+    {"path": "google/vit-base-patch32-384", "paper": "https://arxiv.org/abs/2010.11929", "license": "Apache-2.0", "year": 2020},
+    {"path": "google/vit-large-patch16-224", "paper": "https://arxiv.org/abs/2010.11929", "license": "Apache-2.0", "year": 2020},
+    {"path": "google/vit-large-patch32-384", "paper": "https://arxiv.org/abs/2010.11929", "license": "Apache-2.0", "year": 2020},
+    {"path": "google/vit-hybrid-base-bit-384", "paper": "https://arxiv.org/abs/2010.11929", "license": "Apache-2.0", "year": 2020},
+
+    {"path": "google/cxr-foundation", "paper": "https://arxiv.org/abs/2311.18775", "license": "Apache-2.0", "year": 2023},
+    {"path": "google/derm-foundation", "paper": "https://arxiv.org/abs/2311.18775", "license": "Apache-2.0", "year": 2023},
+
+    {"path": "google/mobilenet_v2_1.4_224", "paper": "https://arxiv.org/abs/1801.04381", "license": "Apache-2.0", "year": 2018},
+    {"path": "google/mobilenet_v2_1.0_224", "paper": "https://arxiv.org/abs/1801.04381", "license": "Apache-2.0", "year": 2018},
+    {"path": "google/mobilenet_v2_0.75_160", "paper": "https://arxiv.org/abs/1801.04381", "license": "Apache-2.0", "year": 2018},
+    {"path": "google/mobilenet_v2_0.35_96", "paper": "https://arxiv.org/abs/1801.04381", "license": "Apache-2.0", "year": 2018},
+
+    {"path": "google/mobilenet_v1_1.0_224", "paper": "https://arxiv.org/abs/1704.04861", "license": "Apache-2.0", "year": 2017},
+    {"path": "google/mobilenet_v1_0.75_192", "paper": "https://arxiv.org/abs/1704.04861", "license": "Apache-2.0", "year": 2017},
+
+    {"path": "google/bit-50", "paper": "https://arxiv.org/abs/1912.11370", "license": "Apache-2.0", "year": 2019},
+
+    {"path": "google/efficientnet-b0", "paper": "https://arxiv.org/abs/1905.11946", "license": "Apache-2.0", "year": 2019},
+    {"path": "google/efficientnet-b1", "paper": "https://arxiv.org/abs/1905.11946", "license": "Apache-2.0", "year": 2019},
+    {"path": "google/efficientnet-b2", "paper": "https://arxiv.org/abs/1905.11946", "license": "Apache-2.0", "year": 2019},
+    {"path": "google/efficientnet-b3", "paper": "https://arxiv.org/abs/1905.11946", "license": "Apache-2.0", "year": 2019},
+    {"path": "google/efficientnet-b4", "paper": "https://arxiv.org/abs/1905.11946", "license": "Apache-2.0", "year": 2019},
+    {"path": "google/efficientnet-b5", "paper": "https://arxiv.org/abs/1905.11946", "license": "Apache-2.0", "year": 2019},
+    {"path": "google/efficientnet-b6", "paper": "https://arxiv.org/abs/1905.11946", "license": "Apache-2.0", "year": 2019},
+    {"path": "google/efficientnet-b7", "paper": "https://arxiv.org/abs/1905.11946", "license": "Apache-2.0", "year": 2019},
+
+
+    {"path": "qualcomm/MobileNet-v3-Small", "paper": "https://arxiv.org/abs/1905.02244", "license": "Open", "year": 2019},
+    {"path": "qualcomm/Swin-Base", "paper": "https://arxiv.org/abs/2103.14030", "license": "Open", "year": 2021},
+    {"path": "qualcomm/DenseNet-121", "paper": "https://arxiv.org/abs/1608.06993", "license": "Open", "year": 2016},
+    {"path": "qualcomm/Inception-v3", "paper": "https://arxiv.org/abs/1512.00567", "license": "Open", "year": 2015},
+    {"path": "qualcomm/WideResNet50", "paper": "https://arxiv.org/abs/1605.07146", "license": "Open", "year": 2016},
+    {"path": "qualcomm/RegNet", "paper": "https://arxiv.org/abs/2003.13678", "license": "Open", "year": 2020},
+    {"path": "qualcomm/ResNet18", "paper": "https://arxiv.org/abs/1512.03385", "license": "Open", "year": 2015},
+    {"path": "qualcomm/MobileNet-v2", "paper": "https://arxiv.org/abs/1801.04381", "license": "Open", "year": 2018},
+    {"path": "qualcomm/ConvNext-Tiny", "paper": "https://arxiv.org/abs/2201.03545", "license": "Open", "year": 2022},
+    {"path": "qualcomm/ResNet101", "paper": "https://arxiv.org/abs/1512.03385", "license": "Open", "year": 2015},
+    {"path": "qualcomm/OpenAI-Clip", "paper": "https://arxiv.org/abs/2103.00020", "license": "Open", "year": 2021},
+    {"path": "qualcomm/Swin-Tiny", "paper": "https://arxiv.org/abs/2103.14030", "license": "Open", "year": 2021},
+    {"path": "qualcomm/ResNeXt101", "paper": "https://arxiv.org/abs/1611.05431", "license": "Open", "year": 2016},
+    {"path": "qualcomm/EfficientNet-B0", "paper": "https://arxiv.org/abs/1905.11946", "license": "Open", "year": 2019},
+    {"path": "qualcomm/GoogLeNet", "paper": "https://arxiv.org/abs/1409.4842", "license": "Open", "year": 2014},
+    {"path": "qualcomm/MNASNet05", "paper": "https://arxiv.org/abs/1807.11626", "license": "Open", "year": 2018},
+    {"path": "qualcomm/Shufflenet-v2", "paper": "https://arxiv.org/abs/1807.11164", "license": "Open", "year": 2018},
+    {"path": "qualcomm/MobileNet-v3-Large", "paper": "https://arxiv.org/abs/1905.02244", "license": "Open", "year": 2019},
+    {"path": "qualcomm/Swin-Small", "paper": "https://arxiv.org/abs/2103.14030", "license": "Open", "year": 2021},
+    {"path": "qualcomm/ResNet50", "paper": "https://arxiv.org/abs/1512.03385", "license": "Open", "year": 2015},
+    {"path": "qualcomm/ResNeXt50", "paper": "https://arxiv.org/abs/1611.05431", "license": "Open", "year": 2016},
+    {"path": "qualcomm/VIT", "paper": "https://arxiv.org/abs/2010.11929", "license": "Open", "year": 2020},
+    {"path": "qualcomm/EfficientViT-l2-cls", "paper": "https://arxiv.org/abs/2205.14756", "license": "Open", "year": 2022},
+    {"path": "qualcomm/EfficientNet-B4", "paper": "https://arxiv.org/abs/1905.11946", "license": "Open", "year": 2019},
+    {"path": "qualcomm/EfficientViT-b2-cls", "paper": "https://arxiv.org/abs/2205.14756", "license": "Open", "year": 2022},
+    {"path": "qualcomm/EfficientNet-V2-s", "paper": "https://arxiv.org/abs/2104.00298", "license": "Open", "year": 2021},
+    {"path": "qualcomm/ConvNext-Base", "paper": "https://arxiv.org/abs/2201.03545", "license": "Open", "year": 2022},
+    {"path": "qualcomm/Beit", "paper": "https://arxiv.org/abs/2106.08254", "license": "Open", "year": 2021},
+    {"path": "qualcomm/LeViT", "paper": "https://arxiv.org/abs/2104.01136", "license": "Open", "year": 2021},
+    {"path": "qualcomm/NASNet", "paper": "https://arxiv.org/abs/1707.07012", "license": "Open", "year": 2017},
+    {"path": "qualcomm/DLA-102-X", "paper": "https://arxiv.org/abs/1707.06484", "license": "Open", "year": 2017},
+    {"path": "qualcomm/Mobile-VIT", "paper": "https://arxiv.org/abs/2110.02178", "license": "Open", "year": 2021},
+    {"path": "qualcomm/SqueezeNet-1.1", "paper": "https://arxiv.org/abs/1602.07360", "license": "Open", "year": 2016},
+    {"path": "qualcomm/EfficientFormer", "paper": "https://arxiv.org/abs/2206.01191", "license": "Open", "year": 2022},
+
+    {"path": "Intel/vit-base-patch16-224-int8-static-inc", "paper": "https://arxiv.org/abs/2010.11929", "license": "Apache-2.0", "year": 2020}
+]

utils_display.py

@@ -0,0 +1,56 @@
+from dataclasses import dataclass
+from typing import List, Any
+import gradio as gr
+
+@dataclass
+class AutoEvalColumn:
+    """Column definition for the main leaderboard table"""
+    name: str
+    type: str
+
+def make_clickable_model(model_name: str) -> str:
+    """
+    Convert model name to clickable link format for Gradio.
+    """
+    if not model_name or model_name == "N/A":
+        return model_name
+    
+    # Create clickable link to Hugging Face model page
+    huggingface_url = f"https://huggingface.co/{model_name}"
+    return f"[{model_name}]({huggingface_url})"
+
+def make_clickable_paper(paper_url: str) -> str:
+    """
+    Convert paper URL to clickable link format for Gradio.
+    """
+    if paper_url == "N/A" or not paper_url:
+        return "N/A"
+    # Use markdown format for better Gradio compatibility
+    return f'[📄 Paper]({paper_url})'
+
+def styled_error(message: str) -> str:
+    """Return a styled error message"""
+    return f'<div style="color: red; background-color: #ffe6e6; padding: 10px; border-radius: 5px; border: 1px solid #ffcccc;">❌ {message}</div>'
+
+def styled_message(message: str) -> str:
+    """Return a styled success message"""
+    return f'<div style="color: green; background-color: #e6ffe6; padding: 10px; border-radius: 5px; border: 1px solid #ccffcc;">✅ {message}</div>'
+
+# Define the fields for the main leaderboard
+fields = lambda cls: [getattr(cls, field.name) for field in cls.__dataclass_fields__.values()]
+
+# Column definitions for ImageNet-1k leaderboard
+def get_imagenet_columns() -> List[AutoEvalColumn]:
+    """Get column definitions for ImageNet-1k leaderboard"""
+    return [
+        AutoEvalColumn("Model", "markdown"),
+        AutoEvalColumn("Top-1 Accuracy ⬆️", "number"),
+        AutoEvalColumn("Top-5 Accuracy ⬆️", "number"),
+        AutoEvalColumn("Parameters (M)", "number"),
+        AutoEvalColumn("FLOPs (G)", "number"),
+        AutoEvalColumn("Inference Time (ms)", "number"),
+        AutoEvalColumn("Model Size (MB)", "number"),
+        AutoEvalColumn("Paper", "markdown"),
+        AutoEvalColumn("Year", "number"),
+        AutoEvalColumn("License", "str")
+    ]