feat: OpenEEGBench submission flow (arena runs the eval)

Replace the leftover LLM-leaderboard submission with a first-class
OpenEEGBench flow. Users submit a model reference (model_cls + checkpoint
+ finetuning strategy/head/datasets); the backend validates it, enforces a
5-per-month per-user cap, and queues a request to braindecode/requests. A
worker (stub) runs oeb.benchmark() and maps results to braindecode/contents.

Backend:
- submission_config: OEB enums/defaults (single source of truth)
- submissions: pure validation, request building, monthly cap
- results_mapping: OEB DataFrame -> contents schema (balanced_accuracy)
- model_validation: EEG/OEB weights-source + license checks
- OEB-shaped submit endpoint/service; eval worker stub (run_eval_worker.py)

Frontend:
- OEB submission form (model_cls, weights source, strategies, heads, PEFT
modules, datasets, seeds, contact/visibility) with conditional fields
- rewritten submission guide (5/month, help -> OpenEEGBench issues, citation)
- queue/limit copy aligned; fixed duplicate style key in EvaluationQueues

Tests: submission validation + results mapping (16 passing).

backend/app/api/endpoints/models.py

@@ -60,11 +60,11 @@ async def submit_model(
 
         # Log submission details
         submission_info = {
-            "Model_ID": model_data.get("model_id"),
+            "Model_Class": model_data.get("model_cls"),
+            "Model_Name": model_data.get("model_name"),
             "User": user_id,
-            "Base_Model": model_data.get("base_model"),
-            "Precision": model_data.get("precision"),
-            "Model_Type": model_data.get("model_type")
+            "Strategies": model_data.get("finetuning_strategies"),
+            "Datasets": model_data.get("datasets"),
         }
         for line in LogFormatter.tree(submission_info, "Submission Details"):
             logger.info(line)

backend/app/config/benchmarks.py

@@ -22,6 +22,7 @@ class BenchmarkInfo:
     accuracy_field: str
     split: str = "test"
     config: str = "default"
+    metric: str = "balanced_accuracy"  # OEB test metric; arena uses balanced_accuracy
 
 
 EEG_BENCHMARKS: Dict[str, BenchmarkInfo] = {

backend/app/config/submission_config.py

@@ -0,0 +1,35 @@
+"""OpenEEGBench submission constants — single source of truth for the
+submission form, validators, and the eval worker. Mirrors the accepted
+values of open_eeg_bench.benchmark()."""
+
+from app.config.benchmarks import EEG_BENCHMARKS
+
+# Finetuning strategies accepted by oeb.benchmark()
+FINETUNING_STRATEGIES = [
+    "frozen", "ridge_probe", "lora", "ia3", "adalora",
+    "dora", "oft", "full_finetune", "two_stages",
+]
+# Subset requiring peft_target_modules
+PEFT_STRATEGIES = {"lora", "ia3", "adalora", "dora", "oft"}
+IA3_STRATEGY = "ia3"  # additionally requires peft_ff_modules
+
+HEADS = ["linear_head", "mlp_head", "original_head"]
+WEIGHTS_SOURCES = ["hub_repo", "checkpoint_url"]
+
+# The smaller, classification-only dataset set the arena evaluates on.
+DATASET_KEYS = list(EEG_BENCHMARKS.keys())
+# hf_id (e.g. "braindecode/bcic2a") -> accuracy field (e.g. "bcic2a_accuracy")
+DATASET_ID_TO_ACCURACY_FIELD = {
+    b.dataset_id: b.accuracy_field for b in EEG_BENCHMARKS.values()
+}
+
+# Defaults (linear probing)
+DEFAULT_STRATEGIES = ["frozen"]
+DEFAULT_HEADS = ["linear_head"]
+DEFAULT_N_SEEDS = 3
+DEFAULT_HEAD_MODULE_NAME = "final_layer"
+
+# Submission cap (per user, per calendar month)
+MONTHLY_QUOTA = 5
+
+FRAMEWORK = "open-eeg-bench"

backend/app/services/models.py

@@ -22,6 +22,7 @@ from app.config import (
 )
 from app.config.hf_config import HF_ORGANIZATION
 from app.services.hf_service import HuggingFaceService
+from app.services.submissions import validate_submission, build_request_entry, monthly_quota_exceeded
 from app.utils.model_validation import ModelValidator
 from app.services.votes import VoteService
 from app.core.cache import cache_config
@@ -322,193 +323,63 @@ class ModelService(HuggingFaceService):
             logger.info(LogFormatter.info(f"Using cached data ({cache_age:.1f}s old)"))
             return self.cached_models
 
-    async def submit_model(
-        self,
-        model_data: Dict[str, Any],
-        user_id: str
-    ) -> Dict[str, Any]:
-        logger.info(LogFormatter.section("MODEL SUBMISSION"))
-        self._log_repo_operation("write", f"{HF_ORGANIZATION}/requests", f"Submitting model {model_data['model_id']} by {user_id}")
-        stats = {
-            "Model": model_data["model_id"],
-            "User": user_id,
-            "Revision": model_data["revision"],
-            "Precision": model_data["precision"],
-            "Type": model_data["model_type"]
-        }
-        for line in LogFormatter.tree(stats, "Submission Details"):
-            logger.info(line)
-
-        # Validate required fields
-        required_fields = [
-            "model_id", "base_model", "revision", "precision", "model_type"
-        ]
-        for field in required_fields:
-            if field not in model_data:
-                raise ValueError(f"Missing required field: {field}")
-
-        # Get model info and validate it exists on HuggingFace
-        try:
-            logger.info(LogFormatter.subsection("MODEL VALIDATION"))
-
-            # Get the model info to check if it exists
-            model_info = self.hf_api.model_info(
-                model_data["model_id"],
-                revision=model_data["revision"],
-                token=self.token
-            )
-
-            if not model_info:
-                raise Exception(f"Model {model_data['model_id']} not found on HuggingFace Hub")
-
-            logger.info(LogFormatter.success("Model exists on HuggingFace Hub"))
-
-        except Exception as e:
-            logger.error(LogFormatter.error("Model validation failed", e))
-            raise
-
-        # Update model revision with commit sha
-        model_data["revision"] = model_info.sha
-
-        # Check if model already exists in the system
+    async def submit_model(self, model_data: Dict[str, Any], user_id: str) -> Dict[str, Any]:
+        logger.info(LogFormatter.section("OPENEEGBENCH SUBMISSION"))
+
+        errors = validate_submission(model_data)
+        if errors:
+            raise ValueError("; ".join(errors))
+
+        # Monthly cap: count this user's existing queue entries for the current month.
+        existing = await self._load_request_entries()
+        if monthly_quota_exceeded(existing, user_id):
+            raise ValueError("You have reached the limit of 5 submissions this month. Please try again next month.")
+
+        # Validate weights source (hub repo exists / url well-formed) and grab license.
+        kwargs = model_data
+        ok, err = await self.validator.validate_weights_source(
+            (kwargs.get("hub_repo") or "").strip(), (kwargs.get("checkpoint_url") or "").strip())
+        if not ok:
+            raise ValueError(err)
+
+        entry = build_request_entry(model_data, user_id)
+        hub_repo = entry["benchmark_kwargs"].get("hub_repo")
+        if hub_repo:
+            entry["hub_license"] = await self.validator.get_repo_license(hub_repo)
+
+        # Write request JSON to the queue dataset.
+        slug = entry["model_name"].lower().replace("/", "-").replace(" ", "-")
+        relative_path = f"{user_id}/{slug}_eval_request_{entry['visibility']}.json"
+        with tempfile.NamedTemporaryFile(mode="w", suffix=".json", delete=False) as f:
+            json.dump(entry, f, indent=2)
+            tmp = f.name
         try:
-            logger.info(LogFormatter.subsection("CHECKING EXISTING SUBMISSIONS"))
-            existing_models = await self.get_models()
-
-            # Check in all statuses (pending, evaluating, finished)
-            for status, models in existing_models.items():
-                for model in models:
-                    if model["name"] == model_data["model_id"] and model["revision"] == model_data["revision"]:
-                        error_msg = f"Model {model_data['model_id']} revision {model_data['revision']} is already in the system with status: {status}"
-                        logger.error(LogFormatter.error("Submission rejected", error_msg))
-                        raise ValueError(error_msg)
-
-            logger.info(LogFormatter.success("No existing submission found"))
-        except ValueError:
-            raise
-        except Exception as e:
-            logger.error(LogFormatter.error("Failed to check existing submissions", e))
-            raise
-
-        # Check that model on hub and valid
-        valid, error, model_config = await self.validator.is_model_on_hub(
-            model_data["model_id"],
-            model_data["revision"],
-            test_tokenizer=False
-        )
-        if not valid:
-            logger.error(LogFormatter.error("Model on hub validation failed", error))
-            raise Exception(error)
-        logger.info(LogFormatter.success("Model on hub validation passed"))
-
-        # Validate model card
-        valid, error, model_card = await self.validator.check_model_card(
-            model_data["model_id"]
-        )
-        if not valid:
-            logger.error(LogFormatter.error("Model card validation failed", error))
-            raise Exception(error)
-        logger.info(LogFormatter.success("Model card validation passed"))
-
-        # Check size limits
-        model_size, error = await self.validator.get_model_size(
-            model_info,
-            model_data["precision"],
-            model_data["base_model"],
-            revision=model_data["revision"]
-        )
-        if model_size is None:
-            logger.error(LogFormatter.error("Model size validation failed", error))
-            raise Exception(error)
-        logger.info(LogFormatter.success(f"Model size validation passed: {model_size:.1f}B"))
-
-        # Size limits for EEG models (much smaller than LLMs - limit at 10B params)
-        if model_data["precision"] in ["float16", "bfloat16"] and model_size > 10:
-            error_msg = f"Model too large for {model_data['precision']} (limit: 10B)"
-            logger.error(LogFormatter.error("Size limit exceeded", error_msg))
-            raise Exception(error_msg)
-
-        architectures = model_info.config.get("architectures", "")
-        if architectures:
-            architectures = ";".join(architectures)
-
-        # Create eval entry
-        eval_entry = {
-            "model": model_data["model_id"],
-            "base_model": model_data["base_model"],
-            "revision": model_info.sha,
-            "precision": model_data["precision"],
-            "params": model_size,
-            "architectures": architectures,
-            "status": "PENDING",
-            "submitted_time": datetime.now(timezone.utc).strftime("%Y-%m-%dT%H:%M:%SZ"),
-            "model_type": model_data["model_type"],
-            "job_id": -1,
-            "job_start_time": None,
-            "sender": user_id
-        }
-
-        logger.info(LogFormatter.subsection("EVALUATION ENTRY"))
-        for line in LogFormatter.tree(eval_entry):
-            logger.info(line)
-
-        # Upload to HF dataset
-        try:
-            logger.info(LogFormatter.subsection("UPLOADING TO HUGGINGFACE"))
-            logger.info(LogFormatter.info(f"Uploading to {HF_ORGANIZATION}/requests..."))
-
-            # Construct the path in the dataset
-            org_or_user = model_data["model_id"].split("/")[0] if "/" in model_data["model_id"] else ""
-            model_path = model_data["model_id"].split("/")[-1]
-            relative_path = f"{org_or_user}/{model_path}_eval_request_False_{model_data['precision']}.json"
-
-            # Create a temporary file with the request
-            with tempfile.NamedTemporaryFile(mode='w', suffix='.json', delete=False) as temp_file:
-                json.dump(eval_entry, temp_file, indent=2)
-                temp_file.flush()
-                temp_path = temp_file.name
-
-            # Upload file directly
             self.hf_api.upload_file(
-                path_or_fileobj=temp_path,
-                path_in_repo=relative_path,
-                repo_id=f"{HF_ORGANIZATION}/requests",
-                repo_type="dataset",
-                commit_message=f"Add {model_data['model_id']} to eval queue",
-                token=self.token
+                path_or_fileobj=tmp, path_in_repo=relative_path,
+                repo_id=QUEUE_REPO, repo_type="dataset",
+                commit_message=f"Add {entry['model_name']} to OpenEEGBench eval queue",
+                token=self.token,
             )
+        finally:
+            os.unlink(tmp)
 
-            # Clean up temp file
-            os.unlink(temp_path)
+        return {"status": "success", "message": "Submission queued for OpenEEGBench evaluation."}
 
-            logger.info(LogFormatter.success("Upload successful"))
-
-        except Exception as e:
-            logger.error(LogFormatter.error("Upload failed", e))
-            raise
-
-        # Add automatic vote
+    async def _load_request_entries(self) -> List[Dict[str, Any]]:
+        """Load all queue request JSONs (for the monthly cap). Empty on failure."""
         try:
-            logger.info(LogFormatter.subsection("AUTOMATIC VOTE"))
-            logger.info(LogFormatter.info(f"Adding upvote for {model_data['model_id']} by {user_id}"))
-            await self.vote_service.add_vote(
-                model_data["model_id"],
-                user_id,
-                "up",
-                {
-                    "precision": model_data["precision"],
-                    "revision": model_data["revision"]
-                }
-            )
-            logger.info(LogFormatter.success("Vote recorded successfully"))
-        except Exception as e:
-            logger.error(LogFormatter.error("Failed to record vote", e))
-            # Don't raise here as the main submission was successful
-
-        return {
-            "status": "success",
-            "message": "The model was submitted successfully, and the vote has been recorded"
-        }
+            with suppress_output():
+                local_dir = self.hf_api.snapshot_download(
+                    repo_id=QUEUE_REPO, repo_type="dataset", token=self.token)
+            out = []
+            for p in Path(local_dir).glob("**/*.json"):
+                try:
+                    out.append(json.loads(p.read_text()))
+                except Exception:
+                    continue
+            return out
+        except Exception:
+            return []
 
     async def get_model_status(self, model_id: str) -> Dict[str, Any]:
         """Get evaluation status of a model"""

backend/app/services/results_mapping.py

@@ -0,0 +1,71 @@
+"""Pure mapping from an OpenEEGBench results DataFrame to the
+`braindecode/contents` leaderboard schema. No network, no oeb import."""
+from __future__ import annotations
+
+from typing import Any, Dict, List
+
+from app.config.submission_config import DATASET_ID_TO_ACCURACY_FIELD
+
+AVERAGE_FIELD = "Average ⬆️"  # "Average ⬆️"
+
+
+def _submitted_date(request: Dict[str, Any]) -> str:
+    ts = str(request.get("submitted_time", ""))
+    return ts.split("T", 1)[0] if "T" in ts else ts
+
+
+def map_oeb_results_to_contents(df, request: Dict[str, Any]) -> List[Dict[str, Any]]:
+    """One contents row per finetuning strategy present in `df`."""
+    if df is None or len(df) == 0:
+        return []
+
+    kwargs = request.get("benchmark_kwargs", {})
+    hub_repo = kwargs.get("hub_repo")
+    model_cls = kwargs.get("model_cls", "")
+    arch_fallback = model_cls.split(".")[-1] if model_cls else ""
+    date = _submitted_date(request)
+
+    completed = df[(df.get("status") == "completed") & df["test_balanced_accuracy"].notna()] \
+        if "status" in df.columns else df[df["test_balanced_accuracy"].notna()]
+
+    rows: List[Dict[str, Any]] = []
+    for strategy, grp in completed.groupby("finetuning"):
+        backbone = grp["backbone"].iloc[0] if "backbone" in grp.columns else arch_fallback
+        # mean balanced_accuracy across seeds, per dataset (hf_id)
+        per_dataset = grp.groupby("dataset")["test_balanced_accuracy"].mean()
+
+        accuracies: Dict[str, float] = {}
+        for hf_id, score in per_dataset.items():
+            field = DATASET_ID_TO_ACCURACY_FIELD.get(hf_id)
+            if field is not None:
+                accuracies[field] = float(score)
+
+        avg_pct = round(sum(accuracies.values()) / len(accuracies) * 100, 2) if accuracies else 0.0
+        n_params_m = None
+        if "trainable_params" in grp.columns and grp["trainable_params"].notna().any():
+            n_params_m = round(float(grp["trainable_params"].dropna().iloc[0]) / 1e6, 2)
+
+        row: Dict[str, Any] = {
+            "fullname": request.get("model_name", ""),
+            "adapter": str(strategy),
+            "Precision": "",
+            "Model sha": None,
+            "Architecture": backbone or arch_fallback,
+            AVERAGE_FIELD: avg_pct,
+            "#Params (M)": n_params_m,
+            "Available on the hub": bool(hub_repo),
+            "Upload To Hub Date": date,
+            "Submission Date": date,
+            "Base Model": backbone or arch_fallback,
+            "Hub License": request.get("hub_license", ""),
+            "Hub ❤️": 0,
+            "model_url": request.get("model_url", ""),
+            "paper_url": request.get("paper_url", ""),
+        }
+        # Initialise every benchmark field to 0, then fill the ones we have.
+        for field in DATASET_ID_TO_ACCURACY_FIELD.values():
+            row.setdefault(field, 0)
+        row.update(accuracies)
+        rows.append(row)
+
+    return rows

backend/app/services/submissions.py

@@ -0,0 +1,129 @@
+"""Pure helpers to validate and build OpenEEGBench eval submissions."""
+from __future__ import annotations
+
+import re
+from datetime import datetime, timezone
+from typing import Any, Dict, List
+
+from app.config.submission_config import (
+    FINETUNING_STRATEGIES, PEFT_STRATEGIES, IA3_STRATEGY, HEADS,
+    DATASET_KEYS, DEFAULT_STRATEGIES, DEFAULT_HEADS, DEFAULT_N_SEEDS,
+    DEFAULT_HEAD_MODULE_NAME, MONTHLY_QUOTA, FRAMEWORK,
+)
+
+_DOTTED_RE = re.compile(r"^[A-Za-z_]\w*(\.[A-Za-z_]\w*)+$")
+_EMAIL_RE = re.compile(r"^[^@\s]+@[^@\s]+\.[^@\s]+$")
+
+
+def _as_list(value) -> list:
+    if value is None:
+        return []
+    return value if isinstance(value, list) else [value]
+
+
+def _str(payload, key) -> str:
+    return (payload.get(key) or "").strip()
+
+
+def validate_submission(payload: Dict[str, Any]) -> List[str]:
+    """Return human-readable validation errors (empty list == valid)."""
+    errors: List[str] = []
+
+    model_cls = _str(payload, "model_cls")
+    if not model_cls:
+        errors.append("model_cls is required (dotted path, e.g. braindecode.models.BIOT).")
+    elif not _DOTTED_RE.match(model_cls):
+        errors.append(f"model_cls '{model_cls}' is not a valid dotted import path.")
+
+    if not _str(payload, "model_name"):
+        errors.append("model_name is required.")
+    if not _str(payload, "organization"):
+        errors.append("organization is required.")
+
+    hub_repo = _str(payload, "hub_repo")
+    checkpoint_url = _str(payload, "checkpoint_url")
+    if not hub_repo and not checkpoint_url:
+        errors.append("Provide a weights source: either hub_repo or checkpoint_url.")
+    if hub_repo and checkpoint_url:
+        errors.append("Provide only one weights source (hub_repo or checkpoint_url).")
+
+    strategies = _as_list(payload.get("finetuning_strategies")) or DEFAULT_STRATEGIES
+    bad = [s for s in strategies if s not in FINETUNING_STRATEGIES]
+    if bad:
+        errors.append(f"Unknown finetuning strategies: {bad}. Valid: {FINETUNING_STRATEGIES}.")
+
+    heads = _as_list(payload.get("heads")) or DEFAULT_HEADS
+    bad = [h for h in heads if h not in HEADS]
+    if bad:
+        errors.append(f"Unknown heads: {bad}. Valid: {HEADS}.")
+
+    datasets = _as_list(payload.get("datasets")) or DATASET_KEYS
+    bad = [d for d in datasets if d not in DATASET_KEYS]
+    if bad:
+        errors.append(f"Unknown datasets: {bad}. Valid: {DATASET_KEYS}.")
+
+    if any(s in PEFT_STRATEGIES for s in strategies) and not _as_list(payload.get("peft_target_modules")):
+        errors.append("peft_target_modules is required when a PEFT strategy (lora/ia3/adalora/dora/oft) is selected.")
+    if IA3_STRATEGY in strategies and not _as_list(payload.get("peft_ff_modules")):
+        errors.append("peft_ff_modules is required when the ia3 strategy is selected.")
+
+    n_seeds = payload.get("n_seeds", DEFAULT_N_SEEDS)
+    if not isinstance(n_seeds, int) or isinstance(n_seeds, bool) or n_seeds < 1:
+        errors.append("n_seeds must be an integer >= 1.")
+
+    email = _str(payload, "contact_email")
+    if email and not _EMAIL_RE.match(email):
+        errors.append("contact_email is not a valid email address.")
+
+    if payload.get("visibility", "Public") not in ("Public", "Private"):
+        errors.append("visibility must be 'Public' or 'Private'.")
+
+    return errors
+
+
+def build_request_entry(payload: Dict[str, Any], submitter: str, now: datetime | None = None) -> Dict[str, Any]:
+    now = now or datetime.now(timezone.utc)
+    strategies = _as_list(payload.get("finetuning_strategies")) or DEFAULT_STRATEGIES
+    heads = _as_list(payload.get("heads")) or DEFAULT_HEADS
+    datasets = _as_list(payload.get("datasets")) or DATASET_KEYS
+    return {
+        "schema_version": 1,
+        "framework": FRAMEWORK,
+        "model_name": _str(payload, "model_name"),
+        "organization": _str(payload, "organization"),
+        "submitter": submitter,
+        "contact_email": _str(payload, "contact_email"),
+        "model_url": _str(payload, "model_url"),
+        "paper_url": _str(payload, "paper_url"),
+        "additional_info": _str(payload, "additional_info"),
+        "visibility": payload.get("visibility", "Public"),
+        "benchmark_kwargs": {
+            "model_cls": _str(payload, "model_cls"),
+            "hub_repo": _str(payload, "hub_repo") or None,
+            "checkpoint_url": _str(payload, "checkpoint_url") or None,
+            "model_kwargs": payload.get("model_kwargs") or {},
+            "head_module_name": payload.get("head_module_name") or DEFAULT_HEAD_MODULE_NAME,
+            "peft_target_modules": _as_list(payload.get("peft_target_modules")),
+            "peft_ff_modules": _as_list(payload.get("peft_ff_modules")),
+            "finetuning_strategies": strategies,
+            "heads": heads,
+            "datasets": datasets,
+            "n_seeds": int(payload.get("n_seeds", DEFAULT_N_SEEDS)),
+        },
+        "status": "PENDING",
+        "submitted_time": now.strftime("%Y-%m-%dT%H:%M:%SZ"),
+        "job_id": -1,
+    }
+
+
+def count_user_submissions_this_month(entries, submitter: str, now: datetime | None = None) -> int:
+    now = now or datetime.now(timezone.utc)
+    month = now.strftime("%Y-%m")
+    return sum(
+        1 for e in entries
+        if e.get("submitter") == submitter and str(e.get("submitted_time", "")).startswith(month)
+    )
+
+
+def monthly_quota_exceeded(entries, submitter: str, now: datetime | None = None) -> bool:
+    return count_user_submissions_this_month(entries, submitter, now) >= MONTHLY_QUOTA

backend/app/utils/model_validation.py

@@ -166,3 +166,31 @@ class ModelValidator:
             if "You are trying to access a gated repo." in str(e):
                 return True, "The model is gated and requires special access permissions.", None
             return False, f"The model was not found or is misconfigured on the Hub. Error: {e.args[0]}", None
+
+    async def validate_weights_source(self, hub_repo: str, checkpoint_url: str):
+        """Validate the OEB weights source. Returns (ok, error)."""
+        if hub_repo:
+            try:
+                await asyncio.to_thread(self.api.repo_info, repo_id=hub_repo, token=self.token)
+                return True, ""
+            except Exception as e:
+                return False, f"hub_repo '{hub_repo}' was not found on the Hub: {e}"
+        if checkpoint_url:
+            if not str(checkpoint_url).startswith(("http://", "https://")):
+                return False, "checkpoint_url must be an http(s) URL."
+            return True, ""
+        return False, "No weights source provided."
+
+    async def get_repo_license(self, hub_repo: str):
+        """Best-effort license tag for a hub repo (empty string if unknown)."""
+        if not hub_repo:
+            return ""
+        try:
+            info = await asyncio.to_thread(self.api.repo_info, repo_id=hub_repo, token=self.token)
+            tags = getattr(info, "tags", None) or []
+            for t in tags:
+                if isinstance(t, str) and t.startswith("license:"):
+                    return t.split("license:", 1)[1]
+            return ""
+        except Exception:
+            return ""

backend/scripts/run_eval_worker.py

@@ -0,0 +1,69 @@
+"""OpenEEGBench eval worker (stub).
+
+Polls the requests queue for PENDING submissions, runs oeb.benchmark(), maps
+results to the contents schema, and writes them back. The GPU run is guarded:
+without --run it only previews. open_eeg_bench is imported lazily so this file
+imports without the heavy dependency installed.
+
+Usage:
+    python -m scripts.run_eval_worker --dry-run
+    python -m scripts.run_eval_worker --run --device cuda
+"""
+import argparse
+import json
+import logging
+import tempfile
+from pathlib import Path
+
+from app.config.base import HF_TOKEN
+from app.config.hf_config import API as hf_api, QUEUE_REPO, AGGREGATED_REPO
+from app.services.results_mapping import map_oeb_results_to_contents
+
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+
+def load_pending():
+    local_dir = hf_api.snapshot_download(repo_id=QUEUE_REPO, repo_type="dataset", token=HF_TOKEN)
+    pending = []
+    for p in Path(local_dir).glob("**/*.json"):
+        try:
+            entry = json.loads(p.read_text())
+        except Exception:
+            continue
+        if entry.get("status") == "PENDING" and entry.get("framework") == "open-eeg-bench":
+            pending.append((p, entry))
+    return pending
+
+
+def run_one(entry, device):
+    import open_eeg_bench as oeb  # lazy heavy import
+    df = oeb.benchmark(device=device, **entry["benchmark_kwargs"])
+    return map_oeb_results_to_contents(df, entry)
+
+
+def main():
+    ap = argparse.ArgumentParser()
+    ap.add_argument("--dry-run", action="store_true", help="List pending submissions only.")
+    ap.add_argument("--run", action="store_true", help="Actually run oeb.benchmark (needs GPU + open-eeg-bench).")
+    ap.add_argument("--device", default="cpu")
+    args = ap.parse_args()
+
+    pending = load_pending()
+    logger.info("Found %d pending OpenEEGBench submissions.", len(pending))
+    for path, entry in pending:
+        logger.info("PENDING: %s (%s)", entry.get("model_name"), entry["benchmark_kwargs"].get("model_cls"))
+        if args.dry_run or not args.run:
+            continue
+        try:
+            rows = run_one(entry, args.device)
+            logger.info("Mapped %d leaderboard row(s) for %s.", len(rows), entry.get("model_name"))
+            # NOTE: appending to AGGREGATED_REPO (contents) is intentionally left for the
+            # production worker; print the rows here so the contract is observable.
+            print(json.dumps(rows, indent=2, default=str))
+        except Exception as e:
+            logger.error("Run failed for %s: %s", entry.get("model_name"), e)
+
+
+if __name__ == "__main__":
+    main()

backend/tests/test_results_mapping.py

@@ -0,0 +1,55 @@
+import pandas as pd
+from app.services.results_mapping import map_oeb_results_to_contents
+
+def _request():
+    return {
+        "model_name": "BIOT-frozen",
+        "organization": "braindecode",
+        "model_url": "https://huggingface.co/braindecode/biot",
+        "paper_url": "",
+        "submitted_time": "2026-06-15T12:00:00Z",
+        "benchmark_kwargs": {"hub_repo": "braindecode/biot", "model_cls": "braindecode.models.BIOT"},
+    }
+
+def _df():
+    # two datasets x one strategy x two seeds, all completed
+    return pd.DataFrame([
+        {"backbone": "BIOT", "dataset": "braindecode/bcic2a", "finetuning": "frozen",
+         "head": "linear_head", "seed": 0, "status": "completed",
+         "test_balanced_accuracy": 0.40, "trainable_params": 3_190_000},
+        {"backbone": "BIOT", "dataset": "braindecode/bcic2a", "finetuning": "frozen",
+         "head": "linear_head", "seed": 1, "status": "completed",
+         "test_balanced_accuracy": 0.60, "trainable_params": 3_190_000},
+        {"backbone": "BIOT", "dataset": "braindecode/physionet", "finetuning": "frozen",
+         "head": "linear_head", "seed": 0, "status": "completed",
+         "test_balanced_accuracy": 0.50, "trainable_params": 3_190_000},
+    ])
+
+def test_one_row_per_strategy():
+    rows = map_oeb_results_to_contents(_df(), _request())
+    assert len(rows) == 1
+    row = rows[0]
+    assert row["fullname"] == "BIOT-frozen"
+    assert row["adapter"] == "frozen"
+    assert row["Architecture"] == "BIOT"
+    # mean over seeds: bcic2a = (0.40+0.60)/2 = 0.50 (fraction)
+    assert abs(row["bcic2a_accuracy"] - 0.50) < 1e-9
+    assert abs(row["physionet_accuracy"] - 0.50) < 1e-9
+    # Average over available datasets * 100 = 50.0
+    assert abs(row["Average ⬆️"] - 50.0) < 1e-9
+    assert abs(row["#Params (M)"] - 3.19) < 1e-6
+    assert row["Available on the hub"] is True
+
+def test_failed_rows_ignored():
+    df = _df()
+    df.loc[len(df)] = {"backbone": "BIOT", "dataset": "braindecode/tuab", "finetuning": "frozen",
+                       "head": "linear_head", "seed": 0, "status": "failed",
+                       "exception": "boom", "test_balanced_accuracy": None, "trainable_params": None}
+    rows = map_oeb_results_to_contents(df, _request())
+    assert rows[0].get("tuab_accuracy", 0) == 0  # failed dataset not scored
+
+def test_multiple_strategies_multiple_rows():
+    df = _df()
+    extra = df.copy(); extra["finetuning"] = "lora"
+    rows = map_oeb_results_to_contents(pd.concat([df, extra], ignore_index=True), _request())
+    assert {r["adapter"] for r in rows} == {"frozen", "lora"}

backend/tests/test_submissions.py

@@ -0,0 +1,92 @@
+from datetime import datetime, timezone
+
+from app.services.submissions import (
+    validate_submission,
+    build_request_entry,
+    count_user_submissions_this_month,
+    monthly_quota_exceeded,
+)
+
+def _valid_payload(**overrides):
+    p = {
+        "model_cls": "braindecode.models.BIOT",
+        "model_name": "BIOT-frozen",
+        "organization": "braindecode",
+        "hub_repo": "braindecode/biot-weights",
+        "finetuning_strategies": ["frozen"],
+        "heads": ["linear_head"],
+        "datasets": ["bcic2a", "physionet"],
+        "n_seeds": 3,
+        "visibility": "Public",
+    }
+    p.update(overrides)
+    return p
+
+def test_valid_payload_has_no_errors():
+    assert validate_submission(_valid_payload()) == []
+
+def test_model_cls_required():
+    errs = validate_submission(_valid_payload(model_cls=""))
+    assert any("model_cls" in e for e in errs)
+
+def test_model_cls_must_be_dotted_path():
+    errs = validate_submission(_valid_payload(model_cls="notdotted"))
+    assert any("dotted import path" in e for e in errs)
+
+def test_weights_source_required():
+    errs = validate_submission(_valid_payload(hub_repo="", checkpoint_url=""))
+    assert any("weights source" in e for e in errs)
+
+def test_only_one_weights_source():
+    errs = validate_submission(_valid_payload(checkpoint_url="https://x/w.pth"))
+    assert any("only one weights source" in e for e in errs)
+
+def test_peft_strategy_requires_target_modules():
+    errs = validate_submission(_valid_payload(finetuning_strategies=["lora"]))
+    assert any("peft_target_modules" in e for e in errs)
+
+def test_ia3_requires_ff_modules():
+    errs = validate_submission(_valid_payload(
+        finetuning_strategies=["ia3"], peft_target_modules=["to_q"]))
+    assert any("peft_ff_modules" in e for e in errs)
+
+def test_unknown_strategy_rejected():
+    errs = validate_submission(_valid_payload(finetuning_strategies=["magic"]))
+    assert any("finetuning strategies" in e for e in errs)
+
+def test_unknown_dataset_rejected():
+    errs = validate_submission(_valid_payload(datasets=["not_a_dataset"]))
+    assert any("datasets" in e for e in errs)
+
+def test_bad_email_rejected():
+    errs = validate_submission(_valid_payload(contact_email="nope"))
+    assert any("email" in e for e in errs)
+
+def test_n_seeds_must_be_positive_int():
+    errs = validate_submission(_valid_payload(n_seeds=0))
+    assert any("n_seeds" in e for e in errs)
+
+def test_build_request_entry_shape():
+    now = datetime(2026, 6, 15, 12, 0, 0, tzinfo=timezone.utc)
+    entry = build_request_entry(_valid_payload(), "alice", now=now)
+    assert entry["framework"] == "open-eeg-bench"
+    assert entry["status"] == "PENDING"
+    assert entry["submitter"] == "alice"
+    assert entry["submitted_time"] == "2026-06-15T12:00:00Z"
+    assert entry["benchmark_kwargs"]["model_cls"] == "braindecode.models.BIOT"
+    assert entry["benchmark_kwargs"]["hub_repo"] == "braindecode/biot-weights"
+    assert entry["benchmark_kwargs"]["checkpoint_url"] is None
+    assert entry["benchmark_kwargs"]["finetuning_strategies"] == ["frozen"]
+
+def test_monthly_count_and_quota():
+    entries = [
+        {"submitter": "alice", "submitted_time": "2026-06-01T00:00:00Z"},
+        {"submitter": "alice", "submitted_time": "2026-06-09T00:00:00Z"},
+        {"submitter": "bob", "submitted_time": "2026-06-09T00:00:00Z"},
+        {"submitter": "alice", "submitted_time": "2026-05-30T00:00:00Z"},
+    ]
+    now = datetime(2026, 6, 15, tzinfo=timezone.utc)
+    assert count_user_submissions_this_month(entries, "alice", now=now) == 2
+    assert monthly_quota_exceeded(entries, "alice", now=now) is False
+    five = entries + [{"submitter": "alice", "submitted_time": "2026-06-1%dT00:00:00Z" % d} for d in range(3, 6)]
+    assert monthly_quota_exceeded(five, "alice", now=now) is True

frontend/src/pages/AddModelPage/components/EvaluationQueues/EvaluationQueues.js

@@ -67,13 +67,13 @@ const columns = [
   {
     id: "wait_time",
     label: "Submitted",
-    width: "12%",
+    width: "13%",
     align: "center",
   },
   {
-    id: "precision",
-    label: "Precision",
-    width: "13%",
+    id: "adapter",
+    label: "Strategy",
+    width: "12%",
     align: "center",
   },
   {
@@ -196,14 +196,16 @@ const ModelTable = ({ models, emptyMessage, status }) => {
                 padding: 0,
                 position: "relative",
                 width: "100%",
-                height: `${rowVirtualizer.getTotalSize()}px`,
               }}
               colSpan={columns.length}
             >
               <>
                 {rowVirtualizer.getVirtualItems().map((virtualRow) => {
                   const model = models[virtualRow.index];
-                  const waitTime = formatWaitTime(model.wait_time);
+                  const modelName = model.model_name || model.name;
+                  const waitTime = model.wait_time
+                    ? formatWaitTime(model.wait_time)
+                    : "";
 
                   return (
                     <TableRow
@@ -234,7 +236,7 @@ const ModelTable = ({ models, emptyMessage, status }) => {
                         }}
                       >
                         <Link
-                          href={`https://huggingface.co/${model.name}`}
+                          href={`https://huggingface.co/${modelName}`}
                           target="_blank"
                           rel="noopener noreferrer"
                           sx={{
@@ -251,7 +253,7 @@ const ModelTable = ({ models, emptyMessage, status }) => {
                             },
                           }}
                         >
-                          {model.name}
+                          {modelName}
                           <OpenInNewIcon />
                         </Link>
                       </TableCell>
@@ -311,7 +313,7 @@ const ModelTable = ({ models, emptyMessage, status }) => {
                         }}
                       >
                         <Typography variant="body2" color="text.secondary">
-                          {model.precision}
+                          {model.adapter || "—"}
                         </Typography>
                       </TableCell>
                       <TableCell
@@ -327,7 +329,7 @@ const ModelTable = ({ models, emptyMessage, status }) => {
                           justifyContent: "center",
                         }}
                       >
-                        {model.revision.substring(0, 7)}
+                        {model.revision ? model.revision.substring(0, 7) : "—"}
                       </TableCell>
                       <TableCell
                         align={columns[5].align}

frontend/src/pages/AddModelPage/components/ModelSubmissionForm/ModelSubmissionForm.js

@@ -6,6 +6,10 @@ import {
   TextField,
   Button,
   FormControl,
+  FormLabel,
+  RadioGroup,
+  FormControlLabel,
+  Radio,
   InputLabel,
   Select,
   MenuItem,
@@ -18,98 +22,201 @@ import RocketLaunchIcon from "@mui/icons-material/RocketLaunch";
 import CheckCircleOutlineIcon from "@mui/icons-material/CheckCircleOutline";
 import { alpha } from "@mui/material/styles";
 import InfoIconWithTooltip from "../../../../components/shared/InfoIconWithTooltip";
-import { MODEL_TYPES } from "../../../../pages/LeaderboardPage/components/Leaderboard/constants/modelTypes";
-import { SUBMISSION_PRECISIONS } from "../../../../pages/LeaderboardPage/components/Leaderboard/constants/defaults";
+import {
+  FINETUNING_STRATEGIES,
+  HEADS,
+  PEFT_STRATEGIES,
+  OEB_DATASETS,
+} from "../../../../pages/LeaderboardPage/components/Leaderboard/constants/modelTypes";
 import AuthContainer from "../../../../components/shared/AuthContainer";
 
 const HELP_TEXTS = {
+  modelClass: (
+    <Box sx={{ p: 1 }}>
+      <Typography variant="subtitle2" sx={{ fontWeight: 600, mb: 0.5 }}>
+        Model Class (dotted import path)
+      </Typography>
+      <Typography variant="body2" sx={{ opacity: 0.9, lineHeight: 1.4 }}>
+        Fully-qualified import path to the model class evaluated by
+        OpenEEGBench. The class must accept (batch, n_chans, n_times) and
+        return (batch, n_outputs). Example: braindecode.models.BIOT
+      </Typography>
+    </Box>
+  ),
   modelName: (
     <Box sx={{ p: 1 }}>
       <Typography variant="subtitle2" sx={{ fontWeight: 600, mb: 0.5 }}>
-        Model Name on Hugging Face Hub
+        Model Name
+      </Typography>
+      <Typography variant="body2" sx={{ opacity: 0.9, lineHeight: 1.4 }}>
+        A human-readable name for your submission. This is how your model will
+        appear on the leaderboard.
+      </Typography>
+    </Box>
+  ),
+  weightsSource: (
+    <Box sx={{ p: 1 }}>
+      <Typography variant="subtitle2" sx={{ fontWeight: 600, mb: 0.5 }}>
+        Weights Source
+      </Typography>
+      <Typography variant="body2" sx={{ opacity: 0.9, lineHeight: 1.4 }}>
+        Provide exactly one source for the pre-trained weights: a public
+        Hugging Face Hub repository (with a license tag) or a direct
+        http(s) URL to a checkpoint.
+      </Typography>
+    </Box>
+  ),
+  headModuleName: (
+    <Box sx={{ p: 1 }}>
+      <Typography variant="subtitle2" sx={{ fontWeight: 600, mb: 0.5 }}>
+        Head Module Name
+      </Typography>
+      <Typography variant="body2" sx={{ opacity: 0.9, lineHeight: 1.4 }}>
+        Name of the model's classification head module. OpenEEGBench replaces
+        this module to attach evaluation heads. Default: final_layer
+      </Typography>
+    </Box>
+  ),
+  finetuningStrategies: (
+    <Box sx={{ p: 1 }}>
+      <Typography variant="subtitle2" sx={{ fontWeight: 600, mb: 0.5 }}>
+        Fine-tuning Strategies
+      </Typography>
+      <Typography variant="body2" sx={{ opacity: 0.9, lineHeight: 1.4 }}>
+        Frozen: linear probing (encoder frozen). LoRA / IA3 / AdaLoRA / DoRA /
+        OFT: parameter-efficient fine-tuning. Full fine-tune: all parameters
+        updated. Two stages: probe then fine-tune. Select one or more.
+      </Typography>
+    </Box>
+  ),
+  heads: (
+    <Box sx={{ p: 1 }}>
+      <Typography variant="subtitle2" sx={{ fontWeight: 600, mb: 0.5 }}>
+        Evaluation Heads
+      </Typography>
+      <Typography variant="body2" sx={{ opacity: 0.9, lineHeight: 1.4 }}>
+        Linear head: single linear layer. MLP head: small multi-layer
+        perceptron. Original head: keep the model's own head. Select one or
+        more.
+      </Typography>
+    </Box>
+  ),
+  peftTargetModules: (
+    <Box sx={{ p: 1 }}>
+      <Typography variant="subtitle2" sx={{ fontWeight: 600, mb: 0.5 }}>
+        PEFT Target Modules
+      </Typography>
+      <Typography variant="body2" sx={{ opacity: 0.9, lineHeight: 1.4 }}>
+        Comma-separated module names to which the PEFT adapter is applied
+        (e.g. to_q, to_v). Required when a PEFT strategy (LoRA, IA3, AdaLoRA,
+        DoRA, OFT) is selected.
+      </Typography>
+    </Box>
+  ),
+  peftFfModules: (
+    <Box sx={{ p: 1 }}>
+      <Typography variant="subtitle2" sx={{ fontWeight: 600, mb: 0.5 }}>
+        PEFT Feed-Forward Modules
       </Typography>
       <Typography variant="body2" sx={{ opacity: 0.9, lineHeight: 1.4 }}>
-        Your model must be public and loadable with AutoClasses without
-        trust_remote_code. The model should be in Safetensors format for better
-        safety and loading performance. Example: braindecode/EEGNetv4
+        Comma-separated feed-forward module names scaled by IA3. Required when
+        the IA3 strategy is selected.
       </Typography>
     </Box>
   ),
-  revision: (
+  datasets: (
     <Box sx={{ p: 1 }}>
       <Typography variant="subtitle2" sx={{ fontWeight: 600, mb: 0.5 }}>
-        Model Revision
+        Datasets
       </Typography>
       <Typography variant="body2" sx={{ opacity: 0.9, lineHeight: 1.4 }}>
-        Git branch, tag or commit hash. The evaluation will be strictly tied to
-        this specific commit to ensure consistency. Make sure this version is
-        stable and contains all necessary files.
+        The downstream datasets to evaluate on. Leave empty to run all 10
+        datasets in the OpenEEGBench classification suite.
       </Typography>
     </Box>
   ),
-  modelType: (
+  nSeeds: (
     <Box sx={{ p: 1 }}>
       <Typography variant="subtitle2" sx={{ fontWeight: 600, mb: 0.5 }}>
-        Adapter / Fine-tuning Method
+        Number of Seeds
       </Typography>
       <Typography variant="body2" sx={{ opacity: 0.9, lineHeight: 1.4 }}>
-        LoRA: Low-Rank Adaptation (~98% param reduction){" "}
-        IA3: Scaling vectors only (~99.5% reduction){" "}
-        AdaLoRA: Adaptive rank allocation{" "}
-        DoRA: Weight-decomposed adaptation{" "}
-        OFT: Orthogonal fine-tuning{" "}
-        Probe: Linear probing (head only){" "}
-        Full Fine-tune: All parameters updated
+        How many random seeds to average over per dataset. More seeds give a
+        more stable estimate but take longer. Default: 3
       </Typography>
     </Box>
   ),
-  baseModel: (
+  contactEmail: (
     <Box sx={{ p: 1 }}>
       <Typography variant="subtitle2" sx={{ fontWeight: 600, mb: 0.5 }}>
-        Base Model Reference
+        Contact Email
       </Typography>
       <Typography variant="body2" sx={{ opacity: 0.9, lineHeight: 1.4 }}>
-        Required for delta weights or adapters. This information is used to
-        identify the original model and calculate the total parameter count by
-        combining base model and adapter/delta parameters.
+        Optional. Stored privately and used only to reach you about your
+        submission. It is never shown on the public leaderboard.
       </Typography>
     </Box>
   ),
-  precision: (
+  visibility: (
     <Box sx={{ p: 1 }}>
       <Typography variant="subtitle2" sx={{ fontWeight: 600, mb: 0.5 }}>
-        Model Precision
+        Visibility
       </Typography>
       <Typography variant="body2" sx={{ opacity: 0.9, lineHeight: 1.4 }}>
-        Size limits vary by precision: FP16/BF16: up to 500M parameters.
-        8-bit: up to 1B parameters. 4-bit: up to 2B parameters.
-        Choose carefully as incorrect precision can cause evaluation errors.
+        Public submissions appear on the leaderboard. Private submissions are
+        evaluated but kept out of the public table.
       </Typography>
     </Box>
   ),
 };
 
-// Convert MODEL_TYPES to format expected by Select component
-const modelTypeOptions = Object.entries(MODEL_TYPES).map(
-  ([value, { label }]) => ({
-    value,
-    label,
-  })
-);
+const VISIBILITY_OPTIONS = ["Public", "Private"];
+
+const INITIAL_FORM_DATA = {
+  modelClass: "", // dotted import path
+  modelName: "",
+  organization: "",
+  weightsSource: "hub_repo", // "hub_repo" | "checkpoint_url"
+  hubRepo: "",
+  checkpointUrl: "",
+  headModuleName: "final_layer",
+  finetuningStrategies: ["frozen"],
+  heads: ["linear_head"],
+  peftTargetModules: "", // comma-separated -> array on submit
+  peftFfModules: "", // comma-separated -> array on submit
+  datasets: [], // empty = all
+  nSeeds: 3,
+  modelUrl: "",
+  paperUrl: "",
+  contactEmail: "",
+  additionalInfo: "",
+  visibility: "Public",
+};
+
+const toList = (s) =>
+  s
+    .split(",")
+    .map((x) => x.trim())
+    .filter(Boolean);
+
+const strategyLabel = (value) =>
+  FINETUNING_STRATEGIES.find((s) => s.value === value)?.label || value;
+
+const headLabel = (value) =>
+  HEADS.find((h) => h.value === value)?.label || value;
 
 function ModelSubmissionForm({ user, isAuthenticated }) {
-  const [formData, setFormData] = useState({
-    modelName: "",
-    revision: "main",
-    modelType: "lora",
-    precision: "float16",
-    baseModel: "",
-  });
+  const [formData, setFormData] = useState(INITIAL_FORM_DATA);
   const [error, setError] = useState(null);
   const [submitting, setSubmitting] = useState(false);
   const [success, setSuccess] = useState(false);
   const [submittedData, setSubmittedData] = useState(null);
 
+  const showPeftTargetModules = formData.finetuningStrategies.some((s) =>
+    PEFT_STRATEGIES.includes(s)
+  );
+  const showPeftFfModules = formData.finetuningStrategies.includes("ia3");
+
   const handleChange = (event) => {
     const { name, value, checked } = event.target;
     setFormData((prev) => ({
@@ -124,19 +231,37 @@ function ModelSubmissionForm({ user, isAuthenticated }) {
     setSubmitting(true);
 
     try {
+      const body = {
+        user_id: user.username,
+        model_cls: formData.modelClass,
+        model_name: formData.modelName,
+        organization: formData.organization,
+        hub_repo:
+          formData.weightsSource === "hub_repo" ? formData.hubRepo : "",
+        checkpoint_url:
+          formData.weightsSource === "checkpoint_url"
+            ? formData.checkpointUrl
+            : "",
+        head_module_name: formData.headModuleName,
+        finetuning_strategies: formData.finetuningStrategies,
+        heads: formData.heads,
+        peft_target_modules: toList(formData.peftTargetModules),
+        peft_ff_modules: toList(formData.peftFfModules),
+        datasets: formData.datasets,
+        n_seeds: Number(formData.nSeeds),
+        model_url: formData.modelUrl,
+        paper_url: formData.paperUrl,
+        contact_email: formData.contactEmail,
+        additional_info: formData.additionalInfo,
+        visibility: formData.visibility,
+      };
+
       const response = await fetch("/api/models/submit", {
         method: "POST",
         headers: {
           "Content-Type": "application/json",
         },
-        body: JSON.stringify({
-          model_id: formData.modelName,
-          revision: formData.revision,
-          model_type: formData.modelType,
-          precision: formData.precision,
-          base_model: formData.baseModel,
-          user_id: user.username,
-        }),
+        body: JSON.stringify(body),
       });
 
       if (!response.ok) {
@@ -206,10 +331,10 @@ function ModelSubmissionForm({ user, isAuthenticated }) {
                   color="text.secondary"
                   sx={{ width: 120 }}
                 >
-                  Type:
+                  Model class:
                 </Typography>
-                <Typography variant="body2">
-                  {submittedData.modelType}
+                <Typography variant="body2" sx={{ fontFamily: "monospace" }}>
+                  {submittedData.modelClass}
                 </Typography>
               </Stack>
               <Stack direction="row" spacing={2}>
@@ -218,10 +343,12 @@ function ModelSubmissionForm({ user, isAuthenticated }) {
                   color="text.secondary"
                   sx={{ width: 120 }}
                 >
-                  Revision:
+                  Strategies:
                 </Typography>
-                <Typography variant="body2" sx={{ fontFamily: "monospace" }}>
-                  {submittedData.revision}
+                <Typography variant="body2">
+                  {submittedData.finetuningStrategies
+                    .map(strategyLabel)
+                    .join(", ")}
                 </Typography>
               </Stack>
               <Stack direction="row" spacing={2}>
@@ -230,32 +357,18 @@ function ModelSubmissionForm({ user, isAuthenticated }) {
                   color="text.secondary"
                   sx={{ width: 120 }}
                 >
-                  Precision:
+                  Visibility:
                 </Typography>
                 <Typography variant="body2">
-                  {submittedData.precision}
+                  {submittedData.visibility}
                 </Typography>
               </Stack>
-              {submittedData.baseModel && (
-                <Stack direction="row" spacing={2}>
-                  <Typography
-                    variant="body2"
-                    color="text.secondary"
-                    sx={{ width: 120 }}
-                  >
-                    Base model:
-                  </Typography>
-                  <Typography variant="body2">
-                    {submittedData.baseModel}
-                  </Typography>
-                </Stack>
-              )}
             </Stack>
           </Paper>
 
           <Typography variant="body2" color="text.secondary">
-            An automatic upvote has been added to your model to help with
-            prioritization.
+            A worker will run oeb.benchmark() and post the official scores to
+            the leaderboard.
           </Typography>
 
           <Stack direction="row" spacing={2}>
@@ -265,13 +378,7 @@ function ModelSubmissionForm({ user, isAuthenticated }) {
               onClick={() => {
                 setSuccess(false);
                 setSubmittedData(null);
-                setFormData({
-                  modelName: "",
-                  revision: "main",
-                  modelType: "lora",
-                  precision: "float16",
-                  baseModel: "",
-                });
+                setFormData(INITIAL_FORM_DATA);
               }}
             >
               Submit another model
@@ -334,20 +441,38 @@ function ModelSubmissionForm({ user, isAuthenticated }) {
               <Grid item xs={12}>
                 <Stack direction="row" spacing={1} alignItems="center">
                   <Typography variant="h6">Model Information</Typography>
-                  <InfoIconWithTooltip tooltip={HELP_TEXTS.modelName} />
+                  <InfoIconWithTooltip tooltip={HELP_TEXTS.modelClass} />
                 </Stack>
               </Grid>
 
-              <Grid item xs={12} sm={8}>
+              <Grid item xs={12}>
+                <TextField
+                  required
+                  fullWidth
+                  name="modelClass"
+                  label="Model Class"
+                  placeholder="braindecode.models.BIOT"
+                  value={formData.modelClass}
+                  onChange={handleChange}
+                  helperText="e.g. braindecode.models.BIOT"
+                  InputProps={{
+                    endAdornment: (
+                      <InfoIconWithTooltip tooltip={HELP_TEXTS.modelClass} />
+                    ),
+                  }}
+                />
+              </Grid>
+
+              <Grid item xs={12} sm={6}>
                 <TextField
                   required
                   fullWidth
                   name="modelName"
                   label="Model Name"
-                  placeholder="organization/model-name"
+                  placeholder="BIOT-frozen"
                   value={formData.modelName}
                   onChange={handleChange}
-                  helperText="Example: braindecode/EEGNetv4"
+                  helperText="Display name on the leaderboard"
                   InputProps={{
                     endAdornment: (
                       <InfoIconWithTooltip tooltip={HELP_TEXTS.modelName} />
@@ -356,47 +481,126 @@ function ModelSubmissionForm({ user, isAuthenticated }) {
                 />
               </Grid>
 
-              <Grid item xs={12} sm={4}>
+              <Grid item xs={12} sm={6}>
+                <TextField
+                  required
+                  fullWidth
+                  name="organization"
+                  label="Organization"
+                  placeholder="braindecode"
+                  value={formData.organization}
+                  onChange={handleChange}
+                  helperText="Author or organization name"
+                />
+              </Grid>
+
+              {/* Weights Source */}
+              <Grid item xs={12}>
+                <Stack direction="row" spacing={1} alignItems="center">
+                  <Typography variant="h6">Weights Source</Typography>
+                  <InfoIconWithTooltip tooltip={HELP_TEXTS.weightsSource} />
+                </Stack>
+              </Grid>
+
+              <Grid item xs={12}>
+                <FormControl>
+                  <FormLabel id="weights-source-label">
+                    Provide one weights source
+                  </FormLabel>
+                  <RadioGroup
+                    row
+                    aria-labelledby="weights-source-label"
+                    name="weightsSource"
+                    value={formData.weightsSource}
+                    onChange={handleChange}
+                  >
+                    <FormControlLabel
+                      value="hub_repo"
+                      control={<Radio />}
+                      label="Hugging Face Hub repo"
+                    />
+                    <FormControlLabel
+                      value="checkpoint_url"
+                      control={<Radio />}
+                      label="Checkpoint URL"
+                    />
+                  </RadioGroup>
+                </FormControl>
+              </Grid>
+
+              {formData.weightsSource === "hub_repo" ? (
+                <Grid item xs={12}>
+                  <TextField
+                    fullWidth
+                    name="hubRepo"
+                    label="Hub Repository"
+                    placeholder="organization/model-weights"
+                    value={formData.hubRepo}
+                    onChange={handleChange}
+                    helperText="Public HF Hub repo containing the weights (with a license tag)"
+                  />
+                </Grid>
+              ) : (
+                <Grid item xs={12}>
+                  <TextField
+                    fullWidth
+                    name="checkpointUrl"
+                    label="Checkpoint URL"
+                    placeholder="https://example.com/weights.pth"
+                    value={formData.checkpointUrl}
+                    onChange={handleChange}
+                    helperText="Direct http(s) URL to a checkpoint file"
+                  />
+                </Grid>
+              )}
+
+              <Grid item xs={12}>
                 <TextField
                   fullWidth
-                  name="revision"
-                  label="Revision commit"
-                  value={formData.revision}
+                  name="headModuleName"
+                  label="Head Module Name"
+                  value={formData.headModuleName}
                   onChange={handleChange}
-                  helperText="Default: main"
+                  helperText="Default: final_layer"
                   InputProps={{
                     endAdornment: (
-                      <InfoIconWithTooltip tooltip={HELP_TEXTS.revision} />
+                      <InfoIconWithTooltip
+                        tooltip={HELP_TEXTS.headModuleName}
+                      />
                     ),
                   }}
                 />
               </Grid>
 
-              {/* Model Configuration */}
+              {/* Evaluation Configuration */}
               <Grid item xs={12}>
                 <Stack direction="row" spacing={1} alignItems="center">
-                  <Typography variant="h6">Model Configuration</Typography>
+                  <Typography variant="h6">Evaluation Configuration</Typography>
                 </Stack>
               </Grid>
 
               <Grid item xs={12} sm={6}>
                 <FormControl fullWidth>
-                  <InputLabel>Model Type</InputLabel>
+                  <InputLabel>Fine-tuning Strategies</InputLabel>
                   <Select
-                    name="modelType"
-                    value={formData.modelType}
+                    multiple
+                    name="finetuningStrategies"
+                    value={formData.finetuningStrategies}
                     onChange={handleChange}
-                    label="Model Type"
+                    label="Fine-tuning Strategies"
+                    renderValue={(selected) =>
+                      selected.map(strategyLabel).join(", ")
+                    }
                     endAdornment={
                       <InfoIconWithTooltip
-                        tooltip={HELP_TEXTS.modelType}
+                        tooltip={HELP_TEXTS.finetuningStrategies}
                         sx={{ mr: 2 }}
                       />
                     }
                   >
-                    {modelTypeOptions.map((type) => (
-                      <MenuItem key={type.value} value={type.value}>
-                        {type.label}
+                    {FINETUNING_STRATEGIES.map((strategy) => (
+                      <MenuItem key={strategy.value} value={strategy.value}>
+                        {strategy.label}
                       </MenuItem>
                     ))}
                   </Select>
@@ -405,44 +609,205 @@ function ModelSubmissionForm({ user, isAuthenticated }) {
 
               <Grid item xs={12} sm={6}>
                 <FormControl fullWidth>
-                  <InputLabel>Precision</InputLabel>
+                  <InputLabel>Heads</InputLabel>
                   <Select
-                    name="precision"
-                    value={formData.precision}
+                    multiple
+                    name="heads"
+                    value={formData.heads}
                     onChange={handleChange}
-                    label="Precision"
+                    label="Heads"
+                    renderValue={(selected) =>
+                      selected.map(headLabel).join(", ")
+                    }
                     endAdornment={
                       <InfoIconWithTooltip
-                        tooltip={HELP_TEXTS.precision}
+                        tooltip={HELP_TEXTS.heads}
                         sx={{ mr: 2 }}
                       />
                     }
                   >
-                    {SUBMISSION_PRECISIONS.map((option) => (
-                      <MenuItem key={option.value} value={option.value}>
-                        {option.label}
+                    {HEADS.map((head) => (
+                      <MenuItem key={head.value} value={head.value}>
+                        {head.label}
                       </MenuItem>
                     ))}
                   </Select>
                 </FormControl>
               </Grid>
 
+              {showPeftTargetModules && (
+                <Grid item xs={12} sm={showPeftFfModules ? 6 : 12}>
+                  <TextField
+                    fullWidth
+                    name="peftTargetModules"
+                    label="PEFT Target Modules"
+                    placeholder="to_q, to_v"
+                    value={formData.peftTargetModules}
+                    onChange={handleChange}
+                    helperText="comma-separated module names"
+                    InputProps={{
+                      endAdornment: (
+                        <InfoIconWithTooltip
+                          tooltip={HELP_TEXTS.peftTargetModules}
+                        />
+                      ),
+                    }}
+                  />
+                </Grid>
+              )}
+
+              {showPeftFfModules && (
+                <Grid item xs={12} sm={6}>
+                  <TextField
+                    fullWidth
+                    name="peftFfModules"
+                    label="PEFT Feed-Forward Modules"
+                    placeholder="to_ff"
+                    value={formData.peftFfModules}
+                    onChange={handleChange}
+                    helperText="comma-separated module names (IA3 only)"
+                    InputProps={{
+                      endAdornment: (
+                        <InfoIconWithTooltip
+                          tooltip={HELP_TEXTS.peftFfModules}
+                        />
+                      ),
+                    }}
+                  />
+                </Grid>
+              )}
+
+              <Grid item xs={12} sm={8}>
+                <FormControl fullWidth>
+                  <InputLabel>Datasets</InputLabel>
+                  <Select
+                    multiple
+                    name="datasets"
+                    value={formData.datasets}
+                    onChange={handleChange}
+                    label="Datasets"
+                    renderValue={(selected) =>
+                      selected.length ? selected.join(", ") : "All 10 datasets"
+                    }
+                    endAdornment={
+                      <InfoIconWithTooltip
+                        tooltip={HELP_TEXTS.datasets}
+                        sx={{ mr: 2 }}
+                      />
+                    }
+                  >
+                    {OEB_DATASETS.map((dataset) => (
+                      <MenuItem key={dataset} value={dataset}>
+                        {dataset}
+                      </MenuItem>
+                    ))}
+                  </Select>
+                </FormControl>
+              </Grid>
+
+              <Grid item xs={12} sm={4}>
+                <TextField
+                  fullWidth
+                  type="number"
+                  name="nSeeds"
+                  label="Number of Seeds"
+                  value={formData.nSeeds}
+                  onChange={handleChange}
+                  helperText="Default: 3"
+                  inputProps={{ min: 1 }}
+                  InputProps={{
+                    endAdornment: (
+                      <InfoIconWithTooltip tooltip={HELP_TEXTS.nSeeds} />
+                    ),
+                  }}
+                />
+              </Grid>
+
+              {/* Additional Information */}
               <Grid item xs={12}>
+                <Stack direction="row" spacing={1} alignItems="center">
+                  <Typography variant="h6">Additional Information</Typography>
+                </Stack>
+              </Grid>
+
+              <Grid item xs={12} sm={6}>
+                <TextField
+                  fullWidth
+                  name="modelUrl"
+                  label="Model URL"
+                  placeholder="https://huggingface.co/organization/model"
+                  value={formData.modelUrl}
+                  onChange={handleChange}
+                  helperText="Optional. Link to the model card or repo."
+                />
+              </Grid>
+
+              <Grid item xs={12} sm={6}>
+                <TextField
+                  fullWidth
+                  name="paperUrl"
+                  label="Paper URL"
+                  placeholder="https://arxiv.org/abs/..."
+                  value={formData.paperUrl}
+                  onChange={handleChange}
+                  helperText="Optional. Link to the related paper."
+                />
+              </Grid>
+
+              <Grid item xs={12} sm={6}>
                 <TextField
                   fullWidth
-                  name="baseModel"
-                  label="Base Model"
-                  value={formData.baseModel}
+                  name="contactEmail"
+                  label="Contact Email"
+                  placeholder="you@example.com"
+                  value={formData.contactEmail}
                   onChange={handleChange}
-                  helperText="Optional. Required for adapter / delta submissions."
+                  helperText="Optional. Stored privately."
                   InputProps={{
                     endAdornment: (
-                      <InfoIconWithTooltip tooltip={HELP_TEXTS.baseModel} />
+                      <InfoIconWithTooltip tooltip={HELP_TEXTS.contactEmail} />
                     ),
                   }}
                 />
               </Grid>
 
+              <Grid item xs={12} sm={6}>
+                <FormControl fullWidth>
+                  <InputLabel>Visibility</InputLabel>
+                  <Select
+                    name="visibility"
+                    value={formData.visibility}
+                    onChange={handleChange}
+                    label="Visibility"
+                    endAdornment={
+                      <InfoIconWithTooltip
+                        tooltip={HELP_TEXTS.visibility}
+                        sx={{ mr: 2 }}
+                      />
+                    }
+                  >
+                    {VISIBILITY_OPTIONS.map((option) => (
+                      <MenuItem key={option} value={option}>
+                        {option}
+                      </MenuItem>
+                    ))}
+                  </Select>
+                </FormControl>
+              </Grid>
+
+              <Grid item xs={12}>
+                <TextField
+                  fullWidth
+                  multiline
+                  minRows={2}
+                  name="additionalInfo"
+                  label="Additional Info"
+                  value={formData.additionalInfo}
+                  onChange={handleChange}
+                  helperText="Optional. Anything else we should know."
+                />
+              </Grid>
+
               {/* Submit Button */}
               <Grid item xs={12}>
                 <Box

frontend/src/pages/AddModelPage/components/SubmissionGuide/SubmissionGuide.js

@@ -50,32 +50,36 @@ const StepNumber = ({ number }) => (
   </Box>
 );
 
+const CITATION = `@software{open_eeg_bench,
+  title     = {Open EEG Bench: Benchmarking parameter-efficient fine-tuning of EEG foundation models},
+  author    = {Guetschel, Pierre and Aristimunha, Bruno and Truong, Dung and Kokate, Kuntal and Moreau, Thomas and Tangermann, Michael and Delorme, Arnaud},
+  year      = {2026},
+  url       = {https://github.com/braindecode/OpenEEGBench},
+  doi       = {10.5281/zenodo.19698863}
+}
+
+@inproceedings{guetschel2026openeegbench,
+  title        = {Toward {OpenEEG-Bench}: A Live Community-Driven Benchmark for {EEG} Foundation Models},
+  author       = {Guetschel, Pierre and Aristimunha, Bruno and Truong, Dung and Kokate, Kuntal and Tangermann, Michael and Delorme, Arnaud},
+  booktitle    = {Proceedings of the 34th European Signal Processing Conference (EUSIPCO 2026)},
+  year         = {2026},
+  address      = {Bruges, Belgium},
+  month        = aug,
+  pages        = {1--5},
+  organization = {EURASIP}
+}`;
+
 const TUTORIAL_STEPS = [
   {
-    title: "Model Information",
-    content: (
-      <Stack spacing={2}>
-        <Typography variant="body2" color="text.secondary">
-          Your model should be <strong>public</strong> on the Hub and follow the{" "}
-          <strong>username/model-id</strong> format (e.g.
-          braindecode/labram-lora-bcic2a). Specify the <strong>revision</strong>{" "}
-          (commit hash or branch) and <strong>adapter method</strong> used
-          for fine-tuning.
-        </Typography>
-        <DocLink href="https://huggingface.co/docs/hub/models-uploading">
-          Model uploading guide
-        </DocLink>
-      </Stack>
-    ),
-  },
-  {
-    title: "Technical Details",
+    title: "Install & implement the model contract",
     content: (
       <Stack spacing={2}>
         <Typography variant="body2" color="text.secondary">
-          Make sure your model can be <strong>loaded locally</strong> before
-          submitting. The arena evaluates EEG foundation models with PEFT
-          adapters:
+          Install the benchmark with{" "}
+          <strong>pip install open-eeg-bench</strong>. Your model must accept
+          input of shape <strong>(batch, n_chans, n_times)</strong> and return{" "}
+          <strong>(batch, n_outputs)</strong>, exposing a named classification
+          head module (default <strong>final_layer</strong>).
         </Typography>
         <Box
           sx={{
@@ -94,72 +98,76 @@ const TUTORIAL_STEPS = [
           }}
         >
           <pre>
-            {`from braindecode.models import LaBraM
-from peft import get_peft_model, LoraConfig
-
-# Load the foundation model
-model = LaBraM(n_chans=22, n_outputs=4, n_times=1000)
+            {`import open_eeg_bench as oeb
 
-# Apply a PEFT adapter (e.g., LoRA)
-peft_config = LoraConfig(
-    r=16, lora_alpha=32,
-    target_modules=["qkv"],
-    lora_dropout=0.1,
+# Your model: (batch, n_chans, n_times) -> (batch, n_outputs)
+results = oeb.benchmark(
+    model_cls="my_package.MyModel",
+    checkpoint_url="https://my-weights.pth",
+    head_module_name="final_layer",
 )
-model = get_peft_model(model, peft_config)
-print(model.print_trainable_parameters())`}
+print(results)  # pd.DataFrame`}
           </pre>
         </Box>
-        <DocLink href="https://braindecode.org/stable/api.html">
-          Braindecode documentation
+        <DocLink href="https://github.com/braindecode/OpenEEGBench">
+          OpenEEGBench repository
         </DocLink>
       </Stack>
     ),
   },
   {
-    title: "License Requirements",
+    title: "Publish your weights",
     content: (
       <Stack spacing={2}>
         <Typography variant="body2" color="text.secondary">
-          A <strong>license tag</strong> is required.{" "}
-          <strong>Open licenses</strong> (Apache, MIT, etc) are strongly
-          recommended.
+          Push your checkpoint to a <strong>public HuggingFace Hub repo</strong>{" "}
+          (with a <strong>license tag</strong>) or host it at a direct{" "}
+          <strong>checkpoint URL</strong>. The arena loads the weights to run
+          the evaluation.
         </Typography>
-        <DocLink href="https://huggingface.co/docs/hub/repositories-licenses">
-          About model licenses
+        <DocLink href="https://huggingface.co/docs/hub/models-uploading">
+          Model uploading guide
         </DocLink>
       </Stack>
     ),
   },
   {
-    title: "Model Card Requirements",
+    title: "Sign in & fill the form",
     content: (
       <Stack spacing={2}>
         <Typography variant="body2" color="text.secondary">
-          Your model card must include: <strong>foundation model</strong> (e.g.
-          LaBraM, EEGPT, BIOT), <strong>adapter method</strong> (LoRA, IA3, etc.),{" "}
-          <strong>training details</strong>,{" "}
-          <strong>dataset information</strong> (EEG paradigm, number of channels,
-          sampling rate), and <strong>performance metrics</strong>.
+          Provide your <strong>model class import path</strong>, the{" "}
+          <strong>weights source</strong>, a{" "}
+          <strong>fine-tuning strategy</strong> and{" "}
+          <strong>classification head</strong>, the{" "}
+          <strong>datasets</strong> (default: all 10), and the number of{" "}
+          <strong>seeds</strong>.
+        </Typography>
+      </Stack>
+    ),
+  },
+  {
+    title: "Submit & wait",
+    content: (
+      <Stack spacing={2}>
+        <Typography variant="body2" color="text.secondary">
+          The arena queues your model and a worker runs{" "}
+          <strong>oeb.benchmark()</strong> to post official scores. Limit:{" "}
+          <strong>5 submissions per month</strong>.
         </Typography>
-        <DocLink href="https://huggingface.co/docs/hub/model-cards">
-          Model cards guide
-        </DocLink>
       </Stack>
     ),
   },
   {
-    title: "Final Checklist",
+    title: "Privacy & help",
     content: (
       <Stack spacing={2}>
         <Typography variant="body2" color="text.secondary">
-          Ensure your model is <strong>public</strong>, uses{" "}
-          <strong>safetensors</strong> format, has a{" "}
-          <strong>license tag</strong>, and <strong>loads correctly</strong>{" "}
-          with braindecode + PEFT.
+          Your <strong>contact email</strong> is stored privately. For help or
+          to request removal of a submission, open an issue.
         </Typography>
-        <DocLink href="https://huggingface.co/docs/peft">
-          HuggingFace PEFT documentation
+        <DocLink href="https://github.com/braindecode/OpenEEGBench/issues">
+          OpenEEGBench issues
         </DocLink>
       </Stack>
     ),
@@ -276,6 +284,52 @@ function SubmissionGuide() {
                 )}
               </Box>
             ))}
+            <Box
+              sx={{
+                mt: 4,
+                pt: 4,
+                px: 4,
+                borderTop: "1px solid",
+                borderColor: (theme) =>
+                  theme.palette.mode === "dark" ? "grey.800" : "grey.100",
+              }}
+            >
+              <Stack spacing={2}>
+                <Typography
+                  variant="subtitle1"
+                  sx={{
+                    fontWeight: 600,
+                    color: "text.primary",
+                    letterSpacing: "-0.01em",
+                  }}
+                >
+                  Citation
+                </Typography>
+                <Typography variant="body2" color="text.secondary">
+                  If you use OpenEEGBench in your research, please cite it.
+                </Typography>
+                <Box
+                  sx={{
+                    p: 2,
+                    bgcolor: (theme) =>
+                      theme.palette.mode === "dark" ? "grey.50" : "grey.900",
+                    borderRadius: 1,
+                    overflowX: "auto",
+                    "& pre": {
+                      m: 0,
+                      p: 0,
+                      fontFamily: "monospace",
+                      fontSize: "0.8125rem",
+                      whiteSpace: "pre",
+                      color: (theme) =>
+                        theme.palette.mode === "dark" ? "grey.900" : "grey.50",
+                    },
+                  }}
+                >
+                  <pre>{CITATION}</pre>
+                </Box>
+              </Stack>
+            </Box>
           </Stack>
         </Box>
       </Collapse>

frontend/src/pages/AddModelPage/components/SubmissionLimitChecker/SubmissionLimitChecker.js

@@ -1,7 +1,7 @@
 import React, { useState, useEffect } from "react";
 import { Alert, Box, CircularProgress } from "@mui/material";
 
-const MAX_SUBMISSIONS_PER_WEEK = 10;
+const MAX_SUBMISSIONS_PER_MONTH = 5;
 
 function SubmissionLimitChecker({ user, children }) {
   const [loading, setLoading] = useState(true);
@@ -17,7 +17,7 @@ function SubmissionLimitChecker({ user, children }) {
 
       try {
         const response = await fetch(
-          `/api/models/organization/${user.username}/submissions?days=7`
+          `/api/models/organization/${user.username}/submissions?days=30`
         );
         if (!response.ok) {
           throw new Error("Failed to fetch submission data");
@@ -25,7 +25,7 @@ function SubmissionLimitChecker({ user, children }) {
 
         const submissions = await response.json();
         console.log(`Recent submissions for ${user.username}:`, submissions);
-        setReachedLimit(submissions.length >= MAX_SUBMISSIONS_PER_WEEK);
+        setReachedLimit(submissions.length >= MAX_SUBMISSIONS_PER_MONTH);
         setError(false);
       } catch (error) {
         console.error("Error checking submission limit:", error);
@@ -74,7 +74,8 @@ function SubmissionLimitChecker({ user, children }) {
         }}
       >
         For fairness reasons, you cannot submit more than{" "}
-        {MAX_SUBMISSIONS_PER_WEEK} models per week. Please try again later.
+        {MAX_SUBMISSIONS_PER_MONTH} submissions per month. Please try again next
+        month.
       </Alert>
     );
   }

frontend/src/pages/LeaderboardPage/components/Leaderboard/constants/modelTypes.js

@@ -88,3 +88,27 @@ export const getModelTypeOrder = (type) => {
   );
   return matchedType ? matchedType[1].order : Infinity;
 };
+
+// OpenEEGBench submission options — fine-tuning strategies, heads, and the
+// classification-only dataset set accepted by oeb.benchmark().
+export const FINETUNING_STRATEGIES = [
+  { value: "frozen", label: "Frozen (linear probing)" },
+  { value: "ridge_probe", label: "Ridge probe" },
+  { value: "lora", label: "LoRA" },
+  { value: "ia3", label: "IA3" },
+  { value: "adalora", label: "AdaLoRA" },
+  { value: "dora", label: "DoRA" },
+  { value: "oft", label: "OFT" },
+  { value: "full_finetune", label: "Full fine-tune" },
+  { value: "two_stages", label: "Two stages" },
+];
+export const HEADS = [
+  { value: "linear_head", label: "Linear head" },
+  { value: "mlp_head", label: "MLP head" },
+  { value: "original_head", label: "Original head" },
+];
+export const PEFT_STRATEGIES = ["lora", "ia3", "adalora", "dora", "oft"];
+export const OEB_DATASETS = [
+  "bcic2a", "physionet", "bcic2020_3", "isruc_sleep", "tuab",
+  "tuev", "mdd_mumtaz2016", "arithmetic_zyma2019", "faced", "seed_v",
+];