leaderboard

app.py

@@ -14,15 +14,11 @@ from src.about import (
 )
 from src.display.css_html_js import custom_css
 from src.display.utils import (
-    BENCHMARK_COLS,
     COLS,
     EVAL_COLS,
     EVAL_TYPES,
     AutoEvalColumn,
-    ModelType,
     fields,
-    WeightType,
-    Precision
 )
 from src.envs import API, EVAL_REQUESTS_PATH, EVAL_RESULTS_PATH, QUEUE_REPO, REPO_ID, RESULTS_REPO, TOKEN
 from src.populate import get_evaluation_queue_df, get_leaderboard_df
@@ -34,14 +30,14 @@ def restart_space():
 
 ### Space initialisation
 try:
-    print(EVAL_REQUESTS_PATH)
+    # print(EVAL_REQUESTS_PATH)
     snapshot_download(
         repo_id=QUEUE_REPO, local_dir=EVAL_REQUESTS_PATH, repo_type="dataset", tqdm_class=None, etag_timeout=30, token=TOKEN
     )
 except Exception:
     restart_space()
 try:
-    print(EVAL_RESULTS_PATH)
+    # print(EVAL_RESULTS_PATH)
     snapshot_download(
         repo_id=RESULTS_REPO, local_dir=EVAL_RESULTS_PATH, repo_type="dataset", tqdm_class=None, etag_timeout=30, token=TOKEN
     )
@@ -49,7 +45,7 @@ except Exception:
     restart_space()
 
 
-LEADERBOARD_DF = get_leaderboard_df(EVAL_RESULTS_PATH, EVAL_REQUESTS_PATH, COLS, BENCHMARK_COLS)
+LEADERBOARD_DF = get_leaderboard_df(EVAL_RESULTS_PATH, EVAL_REQUESTS_PATH, COLS)
 
 (
     finished_eval_queue_df,
@@ -63,12 +59,15 @@ def init_leaderboard(dataframe):
     return Leaderboard(
         value=dataframe,
         datatype=[c.type for c in fields(AutoEvalColumn)],
-        select_columns=SelectColumns(
-            default_selection=[c.name for c in fields(AutoEvalColumn) if c.displayed_by_default],
-            cant_deselect=[c.name for c in fields(AutoEvalColumn) if c.never_hidden],
-            label="Select Columns to Display:",
-        ),
-        search_columns=[AutoEvalColumn.model.name, AutoEvalColumn.license.name],
+        # select_columns=SelectColumns(
+        #     default_selection=[c.name for c in fields(AutoEvalColumn) if c.displayed_by_default],
+        #     cant_deselect=[c.name for c in fields(AutoEvalColumn) if c.never_hidden],
+        #     label="Select Columns to Display:",
+        # ),
+        search_columns=[
+            AutoEvalColumn.team.name, 
+            AutoEvalColumn.submitter.name, 
+            ],
         hide_columns=[c.name for c in fields(AutoEvalColumn) if c.hidden],
         # filter_columns=[
         #     ColumnFilter(AutoEvalColumn.model_type.name, type="checkboxgroup", label="Model types"),
@@ -85,14 +84,14 @@ def init_leaderboard(dataframe):
         #     ),
         # ],
         # bool_checkboxgroup_label="Hide models",
-        interactive=False,
+        interactive=True,
     )
 
 
 demo = gr.Blocks(css=custom_css)
 with demo:
     gr.HTML(TITLE)
-    gr.Markdown(INTRODUCTION_TEXT, elem_classes="markdown-text")
+    # gr.Markdown(INTRODUCTION_TEXT, elem_classes="markdown-text")
 
     with gr.Tabs(elem_classes="tab-buttons") as tabs:
         with gr.TabItem("🏅 E2LMC Leaderboard", elem_id="llm-benchmark-tab-table", id=0):

src/about.py

@@ -1,31 +1,30 @@
 from dataclasses import dataclass
 from enum import Enum
 
-@dataclass
-class Task:
-    benchmark: str
-    metric: str
-    col_name: str
+# @dataclass
+# class Task:
+#     benchmark: str
+#     metric: str
+#     col_name: str
 
 
-# Select your tasks here
-# ---------------------------------------------------
-class Tasks(Enum):
-    # task_key in the json file, metric_key in the json file, name to display in the leaderboard 
-    task0 = Task("anli_r1", "acc", "ANLI")
-    task1 = Task("logiqa", "acc_norm", "LogiQA")
+# # Select your tasks here
+# # ---------------------------------------------------
+# class Tasks(Enum):
+#     # task_key in the json file, metric_key in the json file, name to display in the leaderboard 
+#     task0 = Task("anli_r1", "acc", "ANLI")
+#     task1 = Task("logiqa", "acc_norm", "LogiQA")
 
-NUM_FEWSHOT = 0 # Change with your few shot
+# NUM_FEWSHOT = 0 # Change with your few shot
 # ---------------------------------------------------
 
 
 
 # Your leaderboard name
-TITLE = """<h1 align="center" id="space-title">Demo leaderboard</h1>"""
+TITLE = """<h1 align="center" id="space-title">NeurIPS 2025 E2LM Competition: Early Training Evaluation of Language Models Leaderboard</h1>"""
 
 # What does your leaderboard evaluate?
 INTRODUCTION_TEXT = """
-Intro text
 """
 
 # Which evaluations are you running? how can people reproduce what you have?

src/display/utils.py

@@ -3,8 +3,6 @@ from enum import Enum
 
 import pandas as pd
 
-from src.about import Tasks
-
 def fields(raw_class):
     return [v for k, v in raw_class.__dict__.items() if k[:2] != "__" and k[-2:] != "__"]
 
@@ -23,22 +21,16 @@ class ColumnContent:
 ## Leaderboard columns
 auto_eval_column_dict = []
 # Init
-auto_eval_column_dict.append(["model_type_symbol", ColumnContent, ColumnContent("T", "str", True, never_hidden=True)])
-auto_eval_column_dict.append(["model", ColumnContent, ColumnContent("Model", "markdown", True, never_hidden=True)])
-#Scores
-auto_eval_column_dict.append(["average", ColumnContent, ColumnContent("Average ⬆️", "number", True)])
-for task in Tasks:
-    auto_eval_column_dict.append([task.name, ColumnContent, ColumnContent(task.value.col_name, "number", True)])
-# Model information
-auto_eval_column_dict.append(["model_type", ColumnContent, ColumnContent("Type", "str", False)])
-auto_eval_column_dict.append(["architecture", ColumnContent, ColumnContent("Architecture", "str", False)])
-auto_eval_column_dict.append(["weight_type", ColumnContent, ColumnContent("Weight type", "str", False, True)])
-auto_eval_column_dict.append(["precision", ColumnContent, ColumnContent("Precision", "str", False)])
-auto_eval_column_dict.append(["license", ColumnContent, ColumnContent("Hub License", "str", False)])
-auto_eval_column_dict.append(["params", ColumnContent, ColumnContent("#Params (B)", "number", False)])
-auto_eval_column_dict.append(["likes", ColumnContent, ColumnContent("Hub ❤️", "number", False)])
-auto_eval_column_dict.append(["still_on_hub", ColumnContent, ColumnContent("Available on the hub", "bool", False)])
-auto_eval_column_dict.append(["revision", ColumnContent, ColumnContent("Model sha", "str", False, False)])
+auto_eval_column_dict.append(["submission_hash", ColumnContent, ColumnContent("Submission Hash", "str", True, never_hidden=True)])
+auto_eval_column_dict.append(["submitter", ColumnContent, ColumnContent("Submitter", "str", True, never_hidden=True)])
+auto_eval_column_dict.append(["description", ColumnContent, ColumnContent("Description", "str", True, never_hidden=True)])
+auto_eval_column_dict.append(["team", ColumnContent, ColumnContent("Team", "str", True, never_hidden=True)])
+auto_eval_column_dict.append(["submitted_at", ColumnContent, ColumnContent("Submission Time", "str", True, never_hidden=True)])
+auto_eval_column_dict.append(["consistency_score", ColumnContent, ColumnContent("Consistency Score", "number", True, never_hidden=True)])
+auto_eval_column_dict.append(["evaluation_score", ColumnContent, ColumnContent("Evaluation Score", "number", True, never_hidden=True)])
+# auto_eval_column_dict.append(["score3", ColumnContent, ColumnContent("Score 3", "number", True, never_hidden=True)])
+auto_eval_column_dict.append(["global_score", ColumnContent, ColumnContent("Global Score", "number", True, never_hidden=True)])
+
 
 # We use make dataclass to dynamically fill the scores from Tasks
 AutoEvalColumn = make_dataclass("AutoEvalColumn", auto_eval_column_dict, frozen=True)
@@ -46,59 +38,59 @@ AutoEvalColumn = make_dataclass("AutoEvalColumn", auto_eval_column_dict, frozen=
 ## For the queue columns in the submission tab
 @dataclass(frozen=True)
 class EvalQueueColumn:  # Queue column
-    model = ColumnContent("model", "markdown", True)
-    revision = ColumnContent("revision", "str", True)
-    private = ColumnContent("private", "bool", True)
+    submission_hash = ColumnContent("submission_hash", "str", True)
+    submitter = ColumnContent("submitter", "str", True)
+    team = ColumnContent("team", "bool", True)
     precision = ColumnContent("precision", "str", True)
-    weight_type = ColumnContent("weight_type", "str", "Original")
+    submitted_at = ColumnContent("submitted_at", "str", True)
     status = ColumnContent("status", "str", True)
 
 ## All the model information that we might need
-@dataclass
-class ModelDetails:
-    name: str
-    display_name: str = ""
-    symbol: str = "" # emoji
-
-
-class ModelType(Enum):
-    PT = ModelDetails(name="pretrained", symbol="🟢")
-    FT = ModelDetails(name="fine-tuned", symbol="🔶")
-    IFT = ModelDetails(name="instruction-tuned", symbol="⭕")
-    RL = ModelDetails(name="RL-tuned", symbol="🟦")
-    Unknown = ModelDetails(name="", symbol="?")
-
-    def to_str(self, separator=" "):
-        return f"{self.value.symbol}{separator}{self.value.name}"
-
-    @staticmethod
-    def from_str(type):
-        if "fine-tuned" in type or "🔶" in type:
-            return ModelType.FT
-        if "pretrained" in type or "🟢" in type:
-            return ModelType.PT
-        if "RL-tuned" in type or "🟦" in type:
-            return ModelType.RL
-        if "instruction-tuned" in type or "⭕" in type:
-            return ModelType.IFT
-        return ModelType.Unknown
-
-class WeightType(Enum):
-    Adapter = ModelDetails("Adapter")
-    Original = ModelDetails("Original")
-    Delta = ModelDetails("Delta")
-
-class Precision(Enum):
-    float16 = ModelDetails("float16")
-    bfloat16 = ModelDetails("bfloat16")
-    Unknown = ModelDetails("?")
-
-    def from_str(precision):
-        if precision in ["torch.float16", "float16"]:
-            return Precision.float16
-        if precision in ["torch.bfloat16", "bfloat16"]:
-            return Precision.bfloat16
-        return Precision.Unknown
+# @dataclass
+# class ModelDetails:
+#     name: str
+#     display_name: str = ""
+#     symbol: str = "" # emoji
+
+
+# class ModelType(Enum):
+#     PT = ModelDetails(name="pretrained", symbol="🟢")
+#     FT = ModelDetails(name="fine-tuned", symbol="🔶")
+#     IFT = ModelDetails(name="instruction-tuned", symbol="⭕")
+#     RL = ModelDetails(name="RL-tuned", symbol="🟦")
+#     Unknown = ModelDetails(name="", symbol="?")
+
+#     def to_str(self, separator=" "):
+#         return f"{self.value.symbol}{separator}{self.value.name}"
+
+#     @staticmethod
+#     def from_str(type):
+#         if "fine-tuned" in type or "🔶" in type:
+#             return ModelType.FT
+#         if "pretrained" in type or "🟢" in type:
+#             return ModelType.PT
+#         if "RL-tuned" in type or "🟦" in type:
+#             return ModelType.RL
+#         if "instruction-tuned" in type or "⭕" in type:
+#             return ModelType.IFT
+#         return ModelType.Unknown
+
+# class WeightType(Enum):
+#     Adapter = ModelDetails("Adapter")
+#     Original = ModelDetails("Original")
+#     Delta = ModelDetails("Delta")
+
+# class Precision(Enum):
+#     float16 = ModelDetails("float16")
+#     bfloat16 = ModelDetails("bfloat16")
+#     Unknown = ModelDetails("?")
+
+#     def from_str(precision):
+#         if precision in ["torch.float16", "float16"]:
+#             return Precision.float16
+#         if precision in ["torch.bfloat16", "bfloat16"]:
+#             return Precision.bfloat16
+#         return Precision.Unknown
 
 # Column selection
 COLS = [c.name for c in fields(AutoEvalColumn) if not c.hidden]
@@ -106,5 +98,5 @@ COLS = [c.name for c in fields(AutoEvalColumn) if not c.hidden]
 EVAL_COLS = [c.name for c in fields(EvalQueueColumn)]
 EVAL_TYPES = [c.type for c in fields(EvalQueueColumn)]
 
-BENCHMARK_COLS = [t.value.col_name for t in Tasks]
+# BENCHMARK_COLS = [t.value.col_name for t in Tasks]
 

src/leaderboard/read_evals.py

@@ -8,7 +8,7 @@ import dateutil
 import numpy as np
 
 from src.display.formatting import make_clickable_model
-from src.display.utils import AutoEvalColumn, ModelType, Tasks, Precision, WeightType
+from src.display.utils import AutoEvalColumn
 from src.submission.check_validity import is_model_on_hub
 
 
@@ -16,21 +16,16 @@ from src.submission.check_validity import is_model_on_hub
 class EvalResult:
     """Represents one full evaluation. Built from a combination of the result and request file for a given run.
     """
-    eval_name: str # org_model_precision (uid)
-    full_model: str # org/model (path on hub)
-    org: str 
-    model: str
-    revision: str # commit hash, "" if main
-    results: dict
-    precision: Precision = Precision.Unknown
-    model_type: ModelType = ModelType.Unknown # Pretrained, fine tuned, ...
-    weight_type: WeightType = WeightType.Original # Original or Adapter
-    architecture: str = "Unknown" 
-    license: str = "?"
-    likes: int = 0
-    num_params: int = 0
-    date: str = "" # submission date of request file
-    still_on_hub: bool = False
+
+    submission_hash: str
+    submitter: str = "Unknown"  # Who submitted the model, if available
+    description: str = "No description provided"  # Description of the model, if available
+    team: str = "Unknown"  # Team or organization behind the model, if available
+    submitted_at : str = ""  # Date when the model was submitted, if available
+    consistency_score: float = 0.0  # Score for the first metric, if available
+    evaluation_score: float = 0.0  # Score for the second metric, if
+    # score3: float = 0.0  # Score for the third metric, if available
+    global_score: float = 0.0  # Global score, if available
 
     @classmethod
     def init_from_json_file(self, json_filepath):
@@ -38,120 +33,78 @@ class EvalResult:
         with open(json_filepath) as fp:
             data = json.load(fp)
 
-        config = data.get("config")
-
-        # Precision
-        precision = Precision.from_str(config.get("model_dtype"))
-
-        # Get model and org
-        org_and_model = config.get("model_name", config.get("model_args", None))
-        org_and_model = org_and_model.split("/", 1)
-
-        if len(org_and_model) == 1:
-            org = None
-            model = org_and_model[0]
-            result_key = f"{model}_{precision.value.name}"
-        else:
-            org = org_and_model[0]
-            model = org_and_model[1]
-            result_key = f"{org}_{model}_{precision.value.name}"
-        full_model = "/".join(org_and_model)
-
-        still_on_hub, _, model_config = is_model_on_hub(
-            full_model, config.get("model_sha", "main"), trust_remote_code=True, test_tokenizer=False
-        )
-        architecture = "?"
-        if model_config is not None:
-            architectures = getattr(model_config, "architectures", None)
-            if architectures:
-                architecture = ";".join(architectures)
-
-        # Extract results available in this file (some results are split in several files)
-        results = {}
-        for task in Tasks:
-            task = task.value
-
-            # We average all scores of a given metric (not all metrics are present in all files)
-            accs = np.array([v.get(task.metric, None) for k, v in data["results"].items() if task.benchmark == k])
-            if accs.size == 0 or any([acc is None for acc in accs]):
-                continue
-
-            mean_acc = np.mean(accs) * 100.0
-            results[task.benchmark] = mean_acc
-
-        return self(
-            eval_name=result_key,
-            full_model=full_model,
-            org=org,
-            model=model,
-            results=results,
-            precision=precision,  
-            revision= config.get("model_sha", ""),
-            still_on_hub=still_on_hub,
-            architecture=architecture
-        )
-
-    def update_with_request_file(self, requests_path):
-        """Finds the relevant request file for the current model and updates info with it"""
-        request_file = get_request_file_for_model(requests_path, self.full_model, self.precision.value.name)
-
-        try:
-            with open(request_file, "r") as f:
-                request = json.load(f)
-            self.model_type = ModelType.from_str(request.get("model_type", ""))
-            self.weight_type = WeightType[request.get("weight_type", "Original")]
-            self.license = request.get("license", "?")
-            self.likes = request.get("likes", 0)
-            self.num_params = request.get("params", 0)
-            self.date = request.get("submitted_time", "")
-        except Exception:
-            print(f"Could not find request file for {self.org}/{self.model} with precision {self.precision.value.name}")
+        for key in data.keys():
+            if isinstance(data[key], dict):
+                submission_hash = key
+                submission_details = data[key]
+                if isinstance(submission_details, dict):
+                    # Extracting details from the submission
+                    return self(
+                        submission_hash = submission_hash,
+                        submitter = submission_details.get("submitter", "Unknown"),
+                        description = submission_details.get("description", "No description provided"),
+                        team = submission_details.get("team", "Unknown"),
+                        submitted_at = submission_details.get("submitted_at", ""),
+                        consistency_score = submission_details.get("consistency_score", 0.0),
+                        evaluation_score = submission_details.get("evaluation_score", 0.0),
+                        # score3 = submission_details.get("score3", 0.0),
+                        global_score = submission_details.get("global_score", 0.0)
+                    )
+
+    # def update_with_request_file(self, requests_path):
+    #     """Finds the relevant request file for the current model and updates info with it"""
+    #     request_file = get_request_file_for_model(requests_path, self.full_model, self.precision.value.name)
+
+    #     try:
+    #         with open(request_file, "r") as f:
+    #             request = json.load(f)
+    #         self.model_type = ModelType.from_str(request.get("model_type", ""))
+    #         self.weight_type = WeightType[request.get("weight_type", "Original")]
+    #         self.license = request.get("license", "?")
+    #         self.likes = request.get("likes", 0)
+    #         self.num_params = request.get("params", 0)
+    #         self.date = request.get("submitted_time", "")
+    #     except Exception:
+    #         print(f"Could not find request file for {self.org}/{self.model} with precision {self.precision.value.name}")
 
     def to_dict(self):
         """Converts the Eval Result to a dict compatible with our dataframe display"""
-        average = sum([v for v in self.results.values() if v is not None]) / len(Tasks)
+        # average = sum([v for v in self.results.values() if v is not None]) / len(Tasks)
         data_dict = {
-            "eval_name": self.eval_name,  # not a column, just a save name,
-            AutoEvalColumn.precision.name: self.precision.value.name,
-            AutoEvalColumn.model_type.name: self.model_type.value.name,
-            AutoEvalColumn.model_type_symbol.name: self.model_type.value.symbol,
-            AutoEvalColumn.weight_type.name: self.weight_type.value.name,
-            AutoEvalColumn.architecture.name: self.architecture,
-            AutoEvalColumn.model.name: make_clickable_model(self.full_model),
-            AutoEvalColumn.revision.name: self.revision,
-            AutoEvalColumn.average.name: average,
-            AutoEvalColumn.license.name: self.license,
-            AutoEvalColumn.likes.name: self.likes,
-            AutoEvalColumn.params.name: self.num_params,
-            AutoEvalColumn.still_on_hub.name: self.still_on_hub,
+            # "eval_name": self.eval_name,  # not a column, just a save name,
+            AutoEvalColumn.submission_hash.name: self.submission_hash,
+            AutoEvalColumn.submitter.name: self.submitter,
+            AutoEvalColumn.description.name: self.description,
+            AutoEvalColumn.team.name: self.team,
+            AutoEvalColumn.submitted_at.name: self.submitted_at,
+            AutoEvalColumn.consistency_score.name: self.consistency_score,
+            AutoEvalColumn.evaluation_score.name: self.evaluation_score,
+            # AutoEvalColumn.score3.name: self.score1,
+            AutoEvalColumn.global_score.name: self.global_score,
         }
-
-        for task in Tasks:
-            data_dict[task.value.col_name] = self.results[task.value.benchmark]
-
         return data_dict
 
 
-def get_request_file_for_model(requests_path, model_name, precision):
-    """Selects the correct request file for a given model. Only keeps runs tagged as FINISHED"""
-    request_files = os.path.join(
-        requests_path,
-        f"{model_name}_eval_request_*.json",
-    )
-    request_files = glob.glob(request_files)
-
-    # Select correct request file (precision)
-    request_file = ""
-    request_files = sorted(request_files, reverse=True)
-    for tmp_request_file in request_files:
-        with open(tmp_request_file, "r") as f:
-            req_content = json.load(f)
-            if (
-                req_content["status"] in ["FINISHED"]
-                and req_content["precision"] == precision.split(".")[-1]
-            ):
-                request_file = tmp_request_file
-    return request_file
+# def get_request_file_for_model(requests_path, model_name, precision):
+#     """Selects the correct request file for a given model. Only keeps runs tagged as FINISHED"""
+#     request_files = os.path.join(
+#         requests_path,
+#         f"{model_name}_eval_request_*.json",
+#     )
+#     request_files = glob.glob(request_files)
+
+#     # Select correct request file (precision)
+#     request_file = ""
+#     request_files = sorted(request_files, reverse=True)
+#     for tmp_request_file in request_files:
+#         with open(tmp_request_file, "r") as f:
+#             req_content = json.load(f)
+#             if (
+#                 req_content["status"] in ["FINISHED"]
+#                 and req_content["precision"] == precision.split(".")[-1]
+#             ):
+#                 request_file = tmp_request_file
+#     return request_file
 
 
 def get_raw_eval_results(results_path: str, requests_path: str) -> list[EvalResult]:
@@ -159,38 +112,43 @@ def get_raw_eval_results(results_path: str, requests_path: str) -> list[EvalResu
     model_result_filepaths = []
 
     for root, _, files in os.walk(results_path):
+        # print(files)
         # We should only have json files in model results
-        if len(files) == 0 or any([not f.endswith(".json") for f in files]):
-            continue
+        # if len(files) == 0 or any([not f.endswith(".json") for f in files]):
+        #     print(files, "continue")
+        #     continue
 
         # Sort the files by date
-        try:
-            files.sort(key=lambda x: x.removesuffix(".json").removeprefix("results_")[:-7])
-        except dateutil.parser._parser.ParserError:
-            files = [files[-1]]
+        # try:
+        #     files.sort(key=lambda x: x.removesuffix(".json").removeprefix("results_")[:-7])
+        # except dateutil.parser._parser.ParserError:
+        #     files = [files[-1]]
 
         for file in files:
-            model_result_filepaths.append(os.path.join(root, file))
+            if file.endswith(".json"):
+                model_result_filepaths.append(os.path.join(root, file))
 
-    eval_results = {}
+    eval_results = []
     for model_result_filepath in model_result_filepaths:
         # Creation of result
+        # print(model_result_filepath)
         eval_result = EvalResult.init_from_json_file(model_result_filepath)
-        eval_result.update_with_request_file(requests_path)
-
+        # eval_result.update_with_request_file(requests_path)
+        # print('---------', eval_result)
         # Store results of same eval together
-        eval_name = eval_result.eval_name
-        if eval_name in eval_results.keys():
-            eval_results[eval_name].results.update({k: v for k, v in eval_result.results.items() if v is not None})
-        else:
-            eval_results[eval_name] = eval_result
+        # eval_name = eval_result.eval_name
+        # if eval_name in eval_results.keys():
+        #     eval_results[eval_name].results.update({k: v for k, v in eval_result.results.items() if v is not None})
+        # else:
+        #     eval_results[eval_name] = eval_result
+        eval_results.append(eval_result)
 
     results = []
-    for v in eval_results.values():
+    for v in eval_results:
         try:
             v.to_dict() # we test if the dict version is complete
             results.append(v)
         except KeyError:  # not all eval values present
             continue
 
-    return results
+    return eval_results

src/populate.py

@@ -8,17 +8,17 @@ from src.display.utils import AutoEvalColumn, EvalQueueColumn
 from src.leaderboard.read_evals import get_raw_eval_results
 
 
-def get_leaderboard_df(results_path: str, requests_path: str, cols: list, benchmark_cols: list) -> pd.DataFrame:
+def get_leaderboard_df(results_path: str, requests_path: str, cols: list) -> pd.DataFrame:
     """Creates a dataframe from all the individual experiment results"""
     raw_data = get_raw_eval_results(results_path, requests_path)
     all_data_json = [v.to_dict() for v in raw_data]
-
+    # print('=========', all_data_json)
     df = pd.DataFrame.from_records(all_data_json)
-    df = df.sort_values(by=[AutoEvalColumn.average.name], ascending=False)
+    df = df.sort_values(by=[AutoEvalColumn.global_score.name], ascending=False)
     df = df[cols].round(decimals=2)
 
     # filter out if any of the benchmarks have not been produced
-    df = df[has_no_nan_values(df, benchmark_cols)]
+    # df = df[has_no_nan_values(df, benchmark_cols)]
     return df