Upload 5 files

README.md

@@ -1,14 +1,20 @@
----
-title: Leadpde
-emoji: 🏃
-colorFrom: pink
-colorTo: gray
-sdk: gradio
-sdk_version: 6.12.0
-app_file: app.py
-pinned: false
-license: mit
-short_description: test
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# Public Space
+
+Gradio leaderboard Space for The Well benchmark MVP.
+
+Responsibilities:
+
+- accept submission archives,
+- upload packages and metadata to the submissions dataset,
+- load results from the results dataset,
+- render the public leaderboard and benchmark description.
+
+Required Space secrets:
+
+- `HF_TOKEN`
+- `SUBMISSIONS_REPO`
+- `RESULTS_REPO`
+
+Recommended Space variables:
+
+- `MAX_SUBMISSION_MB`

about.py

@@ -0,0 +1,53 @@
+TITLE = "# The Well Leaderboard MVP"
+
+INTRO_TEXT = """
+Benchmark task: `turbulent_radiative_layer_2D_1step`
+
+This leaderboard evaluates one-step forecasting on The Well dataset
+`turbulent_radiative_layer_2D` using:
+
+- `n_steps_input = 4`
+- `n_steps_output = 1`
+- primary metric: `avg_vrmse`
+
+Lower scores are better.
+"""
+
+SUBMISSION_TEXT = """
+## Submission format
+
+Upload a `.zip` file containing exactly:
+
+- `submission.json`
+- `predictions.npz`
+
+Expected tensor shape in `predictions.npz`:
+
+`(N, 1, 128, 384, 4)`
+
+Field order:
+
+1. `density`
+2. `pressure`
+3. `velocity_x`
+4. `velocity_y`
+"""
+
+ABOUT_TEXT = """
+## Benchmark overview
+
+This is an MVP benchmark for a single The Well task:
+`turbulent_radiative_layer_2D_1step`.
+
+The leaderboard Space is public. The evaluator Space is private and holds
+the evaluation logic and hidden targets.
+
+Submissions are validated and then scored with VRMSE. The public ranking uses
+the average VRMSE across fields.
+
+## Notes
+
+- Lower `avg_vrmse` is better.
+- Invalid submissions are recorded with a failure message.
+- This benchmark is intended to validate protocol and infrastructure first.
+"""

app.py

@@ -0,0 +1,34 @@
+import gradio as gr
+
+from about import ABOUT_TEXT, INTRO_TEXT, SUBMISSION_TEXT, TITLE
+from utils import load_results_dataframe, submit_zip
+
+
+def refresh_leaderboard():
+    return load_results_dataframe()
+
+
+with gr.Blocks(title="The Well Leaderboard MVP") as demo:
+    gr.Markdown(TITLE)
+    gr.Markdown(INTRO_TEXT)
+
+    with gr.Tab("Leaderboard"):
+        leaderboard = gr.Dataframe(
+            value=refresh_leaderboard,
+            label="Ranked results",
+            wrap=True,
+        )
+        refresh_button = gr.Button("Refresh leaderboard")
+        refresh_button.click(fn=refresh_leaderboard, outputs=leaderboard)
+
+    with gr.Tab("Submit"):
+        gr.Markdown(SUBMISSION_TEXT)
+        zip_file = gr.File(label="Submission zip", file_count="single", file_types=[".zip"])
+        submit_button = gr.Button("Submit")
+        submission_status = gr.Markdown()
+        submit_button.click(fn=submit_zip, inputs=zip_file, outputs=submission_status)
+
+    with gr.Tab("About"):
+        gr.Markdown(ABOUT_TEXT)
+
+demo.launch()

requirements.txt

@@ -0,0 +1,3 @@
+gradio>=5.0.0
+huggingface_hub>=0.30.0
+pandas>=2.2.0

utils.py

@@ -0,0 +1,172 @@
+import hashlib
+import io
+import json
+import os
+import zipfile
+from datetime import datetime, timezone
+from typing import Any
+
+import pandas as pd
+from huggingface_hub import HfApi, hf_hub_download
+
+API = HfApi()
+
+SUBMISSIONS_REPO = os.environ.get("SUBMISSIONS_REPO", "your-org/the-well-submissions")
+RESULTS_REPO = os.environ.get("RESULTS_REPO", "your-org/the-well-results")
+HF_TOKEN = os.environ.get("HF_TOKEN")
+MAX_SUBMISSION_MB = int(os.environ.get("MAX_SUBMISSION_MB", "200"))
+
+EXPECTED_TASK = "turbulent_radiative_layer_2D_1step"
+RESULT_COLUMNS = [
+    "rank",
+    "model_name",
+    "team_name",
+    "avg_vrmse",
+    "density_vrmse",
+    "pressure_vrmse",
+    "velocity_x_vrmse",
+    "velocity_y_vrmse",
+    "submitted_at",
+    "status",
+]
+
+
+def _utc_now_iso() -> str:
+    return datetime.now(timezone.utc).replace(microsecond=0).isoformat()
+
+
+def _safe_slug(value: str) -> str:
+    cleaned = "".join(ch if ch.isalnum() or ch in "-_." else "_" for ch in value.strip())
+    return cleaned[:80] or "submission"
+
+
+def _read_submission_manifest(zip_bytes: bytes) -> dict[str, Any]:
+    with zipfile.ZipFile(io.BytesIO(zip_bytes), "r") as zf:
+        names = sorted(zf.namelist())
+        if names != ["predictions.npz", "submission.json"]:
+            raise ValueError(
+                "The zip must contain exactly two root files: submission.json and predictions.npz."
+            )
+        with zf.open("submission.json") as f:
+            manifest = json.load(f)
+    if manifest.get("task_name") != EXPECTED_TASK:
+        raise ValueError(f"task_name must be '{EXPECTED_TASK}'.")
+    if not str(manifest.get("model_name", "")).strip():
+        raise ValueError("submission.json must include a non-empty model_name.")
+    if not str(manifest.get("team_name", "")).strip():
+        raise ValueError("submission.json must include a non-empty team_name.")
+    return manifest
+
+
+def submit_zip(zip_file) -> str:
+    if zip_file is None:
+        return "Please upload a submission `.zip` file."
+
+    local_path = zip_file.name
+    if not local_path.lower().endswith(".zip"):
+        return "Invalid file type. Please upload a `.zip` file."
+
+    file_size = os.path.getsize(local_path)
+    if file_size > MAX_SUBMISSION_MB * 1024 * 1024:
+        return f"Submission too large. Limit is {MAX_SUBMISSION_MB} MB."
+
+    with open(local_path, "rb") as f:
+        zip_bytes = f.read()
+
+    try:
+        manifest = _read_submission_manifest(zip_bytes)
+    except Exception as exc:
+        return f"Submission rejected: {exc}"
+
+    submitted_at = _utc_now_iso()
+    base_name = _safe_slug(manifest["model_name"])
+    submission_id = f"{base_name}_{submitted_at}".replace(":", "-")
+    sha256 = hashlib.sha256(zip_bytes).hexdigest()
+
+    package_path = f"packages/{submission_id}.zip"
+    metadata_path = f"metadata/{submission_id}.json"
+
+    metadata = {
+        "submission_id": submission_id,
+        "task_name": manifest["task_name"],
+        "model_name": manifest["model_name"],
+        "team_name": manifest["team_name"],
+        "method_name": manifest.get("method_name", ""),
+        "submitted_at": submitted_at,
+        "package_path": package_path,
+        "sha256": sha256,
+        "status": "pending",
+    }
+
+    API.upload_file(
+        path_or_fileobj=zip_bytes,
+        path_in_repo=package_path,
+        repo_id=SUBMISSIONS_REPO,
+        repo_type="dataset",
+        token=HF_TOKEN,
+    )
+    API.upload_file(
+        path_or_fileobj=json.dumps(metadata, indent=2).encode("utf-8"),
+        path_in_repo=metadata_path,
+        repo_id=SUBMISSIONS_REPO,
+        repo_type="dataset",
+        token=HF_TOKEN,
+    )
+
+    return (
+        f"Submission received: `{submission_id}`\n\n"
+        "It was uploaded to the submissions dataset and will appear on the leaderboard "
+        "after the private evaluator processes it."
+    )
+
+
+def _download_json_records(repo_id: str, prefix: str) -> list[dict[str, Any]]:
+    files = [
+        path
+        for path in API.list_repo_files(repo_id=repo_id, repo_type="dataset", token=HF_TOKEN)
+        if path.startswith(prefix) and path.endswith(".json")
+    ]
+    records = []
+    for path in files:
+        local_path = hf_hub_download(
+            repo_id=repo_id,
+            repo_type="dataset",
+            filename=path,
+            token=HF_TOKEN,
+        )
+        with open(local_path, "r", encoding="utf-8") as f:
+            records.append(json.load(f))
+    return records
+
+
+def load_results_dataframe() -> pd.DataFrame:
+    try:
+        records = _download_json_records(RESULTS_REPO, "results/")
+    except Exception:
+        return pd.DataFrame(columns=RESULT_COLUMNS)
+
+    if not records:
+        return pd.DataFrame(columns=RESULT_COLUMNS)
+
+    df = pd.DataFrame.from_records(records)
+    if "status" in df.columns:
+        df = df[df["status"] == "succeeded"].copy()
+    if df.empty:
+        return pd.DataFrame(columns=RESULT_COLUMNS)
+
+    for column in [
+        "avg_vrmse",
+        "density_vrmse",
+        "pressure_vrmse",
+        "velocity_x_vrmse",
+        "velocity_y_vrmse",
+    ]:
+        df[column] = pd.to_numeric(df[column], errors="coerce")
+
+    df = df.sort_values("avg_vrmse", ascending=True).reset_index(drop=True)
+    df.insert(0, "rank", range(1, len(df) + 1))
+
+    for column in RESULT_COLUMNS:
+        if column not in df.columns:
+            df[column] = None
+    return df[RESULT_COLUMNS]