update utils

src/display/utils.py

@@ -1,65 +1,145 @@
-from dataclasses import dataclass, make_dataclass
-from enum import Enum
+# src/display/utils.py
 
-import pandas as pd
+from dataclasses import dataclass
+from enum import Enum
+from typing import Any, List
 
 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:] != "__"]
-
-
-# These classes are for user facing column names,
-# to avoid having to change them all around the code
-# when a modif is needed
 @dataclass
 class ColumnContent:
     name: str
-    type: str
-    displayed_by_default: bool
+    type: Any
+    label: str
+    description: str
     hidden: bool = False
+    displayed_by_default: bool = True
     never_hidden: bool = False
 
-## 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)])
+# Initialize the list of columns for the leaderboard
+COLUMNS: List[ColumnContent] = []
+
+# Essential columns
+COLUMNS.append(
+    ColumnContent(
+        name="model",
+        type=str,
+        label="Model",
+        description="Model name",
+        never_hidden=True,
+    )
+)
+COLUMNS.append(
+    ColumnContent(
+        name="average",
+        type=float,
+        label="Average Accuracy (%)",
+        description="Average accuracy across all subjects",
+    )
+)
+
+# Include per-subject accuracy columns based on your subjects
 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)])
-
-# We use make dataclass to dynamically fill the scores from Tasks
-AutoEvalColumn = make_dataclass("AutoEvalColumn", auto_eval_column_dict, frozen=True)
-
-## For the queue columns in the submission tab
+    COLUMNS.append(
+        ColumnContent(
+            name=task.value.benchmark,
+            type=float,
+            label=f"{task.value.col_name} (%)",
+            description=f"Accuracy on {task.value.col_name}",
+            displayed_by_default=False,
+        )
+    )
+
+# Additional columns
+COLUMNS.extend([
+    ColumnContent(
+        name="model_type",
+        type=str,
+        label="Model Type",
+        description="Type of the model (e.g., Transformer, RNN, etc.)",
+        displayed_by_default=False,
+    ),
+    ColumnContent(
+        name="architecture",
+        type=str,
+        label="Architecture",
+        description="Model architecture",
+        displayed_by_default=False,
+    ),
+    ColumnContent(
+        name="weight_type",
+        type=str,
+        label="Weight Type",
+        description="Type of model weights (e.g., Original, Delta, Adapter)",
+        displayed_by_default=False,
+    ),
+    ColumnContent(
+        name="precision",
+        type=str,
+        label="Precision",
+        description="Precision of the model weights (e.g., float16)",
+        displayed_by_default=False,
+    ),
+    ColumnContent(
+        name="license",
+        type=str,
+        label="License",
+        description="License of the model",
+        displayed_by_default=False,
+    ),
+    ColumnContent(
+        name="params",
+        type=float,
+        label="Parameters (B)",
+        description="Number of model parameters in billions",
+        displayed_by_default=False,
+    ),
+    ColumnContent(
+        name="likes",
+        type=int,
+        label="Likes",
+        description="Number of likes on the Hugging Face Hub",
+        displayed_by_default=False,
+    ),
+    ColumnContent(
+        name="still_on_hub",
+        type=bool,
+        label="Available on the Hub",
+        description="Whether the model is still available on the Hugging Face Hub",
+        displayed_by_default=False,
+    ),
+    ColumnContent(
+        name="revision",
+        type=str,
+        label="Model Revision",
+        description="Model revision or commit hash",
+        displayed_by_default=False,
+    ),
+])
+
+# Now we can create lists of column names for use in the application
+COLS = [col.name for col in COLUMNS]
+BENCHMARK_COLS = [col.name for col in COLUMNS if col.name not in ["model", "average", "model_type", "architecture", "weight_type", "precision", "license", "params", "likes", "still_on_hub", "revision"]]
+
+# 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)
-    precision = ColumnContent("precision", "str", True)
-    weight_type = ColumnContent("weight_type", "str", "Original")
-    status = ColumnContent("status", "str", True)
+class EvalQueueColumn:
+    model: str
+    revision: str
+    private: bool
+    precision: str
+    weight_type: str
+    status: str
+
+EVAL_COLS = ["model", "revision", "private", "precision", "weight_type", "status"]
+EVAL_TYPES = [str, str, bool, str, str, str]
 
 ## All the model information that we might need
 @dataclass
 class ModelDetails:
     name: str
     display_name: str = ""
-    symbol: str = "" # emoji
-
+    symbol: str = ""  # emoji
 
 class ModelType(Enum):
     PT = ModelDetails(name="pretrained", symbol="🟢")
@@ -72,39 +152,31 @@ class ModelType(Enum):
         return f"{self.value.symbol}{separator}{self.value.name}"
 
     @staticmethod
-    def from_str(type):
-        if "fine-tuned" in type or "🔶" in type:
+    def from_str(type_str):
+        if "fine-tuned" in type_str or "🔶" in type_str:
             return ModelType.FT
-        if "pretrained" in type or "🟢" in type:
+        if "pretrained" in type_str or "🟢" in type_str:
             return ModelType.PT
-        if "RL-tuned" in type or "🟦" in type:
+        if "RL-tuned" in type_str or "🟦" in type_str:
             return ModelType.RL
-        if "instruction-tuned" in type or "⭕" in type:
+        if "instruction-tuned" in type_str or "⭕" in type_str:
             return ModelType.IFT
         return ModelType.Unknown
 
 class WeightType(Enum):
-    Adapter = ModelDetails("Adapter")
-    Original = ModelDetails("Original")
-    Delta = ModelDetails("Delta")
+    Adapter = "Adapter"
+    Original = "Original"
+    Delta = "Delta"
 
 class Precision(Enum):
-    float16 = ModelDetails("float16")
-    bfloat16 = ModelDetails("bfloat16")
-    Unknown = ModelDetails("?")
+    float16 = "float16"
+    bfloat16 = "bfloat16"
+    Unknown = "Unknown"
 
-    def from_str(precision):
-        if precision in ["torch.float16", "float16"]:
+    @staticmethod
+    def from_str(precision_str):
+        if precision_str in ["torch.float16", "float16"]:
             return Precision.float16
-        if precision in ["torch.bfloat16", "bfloat16"]:
+        if precision_str in ["torch.bfloat16", "bfloat16"]:
             return Precision.bfloat16
         return Precision.Unknown
-
-# Column selection
-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]
-