Add French medical NER leaderboard frontend

requirements.txt

@@ -13,4 +13,8 @@ python-dateutil
 tqdm
 transformers
 tokenizers>=0.15.0
-sentencepiece
+sentencepiece
+
+# Additional dependencies for French medical NER
+seqeval>=1.2.2
+scikit-learn>=1.3.0

src/about.py

@@ -12,8 +12,8 @@ class Task:
 # ---------------------------------------------------
 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")
+    emea_ner = Task("emea_ner", "f1", "EMEA NER")
+    medline_ner = Task("medline_ner", "f1", "MEDLINE NER")
 
 NUM_FEWSHOT = 0 # Change with your few shot
 # ---------------------------------------------------
@@ -21,50 +21,77 @@ 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">🏥 French Medical NLP Leaderboard</h1>"""
 
 # What does your leaderboard evaluate?
 INTRODUCTION_TEXT = """
-Intro text
+This leaderboard evaluates French NLP models on biomedical Named Entity Recognition (NER) tasks.
+We focus on BERT-like models with plans to extend to other architectures.
+
+**Current Tasks:**
+- **EMEA NER**: Named Entity Recognition on French medical texts from EMEA (European Medicines Agency)
+- **MEDLINE NER**: Named Entity Recognition on French medical abstracts from MEDLINE
+
+**Entity Types:** ANAT, CHEM, DEVI, DISO, GEOG, LIVB, OBJC, PHEN, PHYS, PROC
 """
 
 # Which evaluations are you running? how can people reproduce what you have?
 LLM_BENCHMARKS_TEXT = f"""
 ## How it works
 
+We evaluate models by **fine-tuning** them on French medical NER tasks following the CamemBERT-bio methodology:
+
+**Fine-tuning Parameters:**
+- **Optimizer**: AdamW (following CamemBERT-bio paper)
+- **Learning Rate**: 5e-5 (optimal from Optuna search - unchanged)
+- **Scheduler**: Cosine with restarts (22.4% warmup ratio)
+- **Steps**: 2000 (same as paper)
+- **Batch Size**: 4 (CPU constraint)
+- **Gradient Accumulation**: 4 steps (effective batch size 16)
+- **Max Length**: 512 tokens
+- **Output**: Simple linear layer (no CRF)
+
+**Evaluation**: Uses seqeval with IOB2 scheme for entity-level **micro F1**, precision, and recall.
+
 ## Reproducibility
-To reproduce our results, here is the commands you can run:
+Results are obtained through proper fine-tuning, not zero-shot evaluation. Each model is fine-tuned independently on each task.
 
+**Datasets:**
+- EMEA: `rntc/quaero-frenchmed-ner-emea-sen`
+- MEDLINE: `rntc/quaero-frenchmed-ner-medline`
 """
 
 EVALUATION_QUEUE_TEXT = """
-## Some good practices before submitting a model
+## Before submitting a model
 
-### 1) Make sure you can load your model and tokenizer using AutoClasses:
+### 1) Ensure your model is compatible with AutoClasses:
 ```python
-from transformers import AutoConfig, AutoModel, AutoTokenizer
-config = AutoConfig.from_pretrained("your model name", revision=revision)
-model = AutoModel.from_pretrained("your model name", revision=revision)
-tokenizer = AutoTokenizer.from_pretrained("your model name", revision=revision)
+from transformers import AutoTokenizer, AutoModelForTokenClassification
+tokenizer = AutoTokenizer.from_pretrained("your_model_name")
+model = AutoModelForTokenClassification.from_pretrained("your_model_name")
 ```
-If this step fails, follow the error messages to debug your model before submitting it. It's likely your model has been improperly uploaded.
-
-Note: make sure your model is public!
-Note: if your model needs `use_remote_code=True`, we do not support this option yet but we are working on adding it, stay posted!
-
-### 2) Convert your model weights to [safetensors](https://huggingface.co/docs/safetensors/index)
-It's a new format for storing weights which is safer and faster to load and use. It will also allow us to add the number of parameters of your model to the `Extended Viewer`!
-
-### 3) Make sure your model has an open license!
-This is a leaderboard for Open LLMs, and we'd love for as many people as possible to know they can use your model 🤗
-
-### 4) Fill up your model card
-When we add extra information about models to the leaderboard, it will be automatically taken from the model card
 
-## In case of model failure
-If your model is displayed in the `FAILED` category, its execution stopped.
-Make sure you have followed the above steps first.
-If everything is done, check you can launch the EleutherAIHarness on your model locally, using the above command without modifications (you can add `--limit` to limit the number of examples per task).
+### 2) Model requirements:
+- Must be a fine-tuned model for token classification (not just a base model)
+- Should be trained on French medical NER data
+- Must be publicly available on Hugging Face Hub
+- Prefer safetensors format for faster loading
+
+### 3) Expected performance:
+- Base models without fine-tuning will get very low scores (~0.02 F1)
+- Fine-tuned models should achieve significantly higher scores
+
+### 4) Model card recommendations:
+- Specify the training dataset used
+- Include model architecture details
+- Add performance metrics if available
+- Use an open license
+
+## Troubleshooting
+If your model fails evaluation:
+1. Check that it loads properly with AutoModelForTokenClassification
+2. Verify it's trained for token classification (not just language modeling)
+3. Ensure the model is public and accessible
 """
 
 CITATION_BUTTON_LABEL = "Copy the following snippet to cite these results"

src/display/utils.py

@@ -83,6 +83,15 @@ class ModelType(Enum):
             return ModelType.IFT
         return ModelType.Unknown
 
+    @staticmethod
+    def from_config(config):
+        """Determine model type from configuration - for NER models, most will be fine-tuned"""
+        if hasattr(config, 'num_labels') and config.num_labels == 21:
+            return ModelType.FT  # Fine-tuned for NER
+        elif hasattr(config, 'num_labels') and config.num_labels == 2:
+            return ModelType.PT  # Base model
+        return ModelType.Unknown
+
 class WeightType(Enum):
     Adapter = ModelDetails("Adapter")
     Original = ModelDetails("Original")

src/envs.py

@@ -6,7 +6,7 @@ from huggingface_hub import HfApi
 # ----------------------------------
 TOKEN = os.environ.get("HF_TOKEN") # A read/write token for your org
 
-OWNER = "demo-leaderboard-backend" # Change to your org - don't forget to create a results and request dataset, with the correct format!
+OWNER = "rntc" # Change to your org - don't forget to create a results and request dataset, with the correct format!
 # ----------------------------------
 
 REPO_ID = f"{OWNER}/leaderboard"

src/submission/check_validity.py

@@ -7,7 +7,7 @@ from datetime import datetime, timedelta, timezone
 import huggingface_hub
 from huggingface_hub import ModelCard
 from huggingface_hub.hf_api import ModelInfo
-from transformers import AutoConfig
+from transformers import AutoConfig, AutoModelForTokenClassification
 from transformers.models.auto.tokenization_auto import AutoTokenizer
 
 def check_model_card(repo_id: str) -> tuple[bool, str]:
@@ -35,6 +35,27 @@ def is_model_on_hub(model_name: str, revision: str, token: str = None, trust_rem
     """Checks if the model model_name is on the hub, and whether it (and its tokenizer) can be loaded with AutoClasses."""
     try:
         config = AutoConfig.from_pretrained(model_name, revision=revision, trust_remote_code=trust_remote_code, token=token)
+        
+        # Check if model can be loaded for token classification
+        try:
+            model = AutoModelForTokenClassification.from_pretrained(
+                model_name, 
+                revision=revision, 
+                trust_remote_code=trust_remote_code, 
+                token=token
+            )
+            
+            # Check if it's suitable for our NER task (should have 21 labels)
+            if hasattr(model.config, 'num_labels') and model.config.num_labels not in [2, 21]:
+                return (
+                    False,
+                    f"has {model.config.num_labels} labels, but French medical NER requires models with 2 (base) or 21 (fine-tuned) labels",
+                    None
+                )
+            
+        except Exception as e:
+            return (False, f"cannot be loaded for token classification: {e}", None)
+        
         if test_tokenizer:
             try:
                 tk = AutoTokenizer.from_pretrained(model_name, revision=revision, trust_remote_code=trust_remote_code, token=token)
@@ -72,7 +93,19 @@ def get_model_size(model_info: ModelInfo, precision: str):
 
 def get_model_arch(model_info: ModelInfo):
     """Gets the model architecture from the configuration"""
-    return model_info.config.get("architectures", "Unknown")
+    arch = model_info.config.get("architectures", ["Unknown"])
+    if isinstance(arch, list) and len(arch) > 0:
+        arch_name = arch[0]
+        # Map common architectures to user-friendly names
+        if "Camembert" in arch_name:
+            return "CamemBERT"
+        elif "Bert" in arch_name:
+            return "BERT"
+        elif "Roberta" in arch_name:
+            return "RoBERTa"
+        else:
+            return arch_name.replace("ForTokenClassification", "")
+    return "Unknown"
 
 def already_submitted_models(requested_models_dir: str) -> set[str]:
     """Gather a list of already submitted models to avoid duplicates"""