Upload 33 files

app.py

@@ -1065,6 +1065,12 @@ def startup() -> None:
             TRAINER.note("anciens jobs planifiés : " + (", ".join(done) if done else "aucun à suspendre"))
         except Exception as exc:  # noqa: BLE001
             TRAINER.note(f"anciens jobs planifiés illisibles : {exc}")
+    if os.environ.get("UNIQUE_VESUVIUS_AUTORUN", "0") == "1":
+        try:
+            supervisor = getattr(VESUVIUS, "supervisor", None)
+            if supervisor is not None:supervisor.start()
+        except Exception as exc:
+            TRAINER.note("Vesuvius différé : " + type(exc).__name__ + ": " + str(exc)[:200])
     AUTONOMY.start()
     resumed = False
     try:
@@ -1084,7 +1090,11 @@ async def lifespan(_app: FastAPI):
     """Le thread d'arrière-plan (mise à jour, jobs, entraînement automatique) suit la durée de vie du serveur."""
     async with DISCOVERY.serving():
         threading.Thread(target=startup, name="unique-startup", daemon=True).start()
-        yield
+        try:
+            yield
+        finally:
+            supervisor = getattr(VESUVIUS, "supervisor", None)
+            if supervisor is not None:supervisor.stop()
 
 
 def sync_sky() -> dict:

config/vesuvius-model-references.json

@@ -0,0 +1,28 @@
+{
+  "checked_date": "2026-11-13",
+  "runtime_adapter": "tiny_hybrid_3d_2d_v1_experimental_only",
+  "references": [
+    {
+      "id": "scrollprize/ink_9um",
+      "url": "https://huggingface.co/scrollprize/ink_9um",
+      "license_declared": "MIT",
+      "representation": "isotropic surface volume around 9 micrometres",
+      "architecture": "local 3D stem plus 2D U-Net",
+      "official_code": "https://github.com/ScrollPrize/villa",
+      "integration_status": "not_loaded_by_local_experimental_adapter",
+      "requirements": "Use upstream normalization, depth windows, architecture, patch size, checkpoints and training-region manifest; do not reuse local halo=3 blindly."
+    },
+    {
+      "id": "scrollprize/ink_canonical_2um",
+      "url": "https://huggingface.co/scrollprize/ink_canonical_2um",
+      "license_declared": "MIT",
+      "representation": "CT around 2 micrometres",
+      "architecture": "3D ResNet-152 with 3D decoder",
+      "checkpoint_bytes_observed": 1549556213,
+      "official_code": "https://github.com/ScrollPrize/villa/tree/main/ink-detection/optimized_inference",
+      "integration_status": "not_loaded_by_local_experimental_adapter",
+      "requirements": "Pin upstream code and weight hash, validate coordinate registration and safe conversion, measure A10G memory and held-out quality before activating."
+    }
+  ],
+  "dataset_license_note": "Underlying CT data and derived annotations may have CC BY-NC 4.0 terms. The MIT code license does not relicense them."
+}

config/vesuvius_calibrations.json

@@ -0,0 +1,11 @@
+{
+  "schema": 1,
+  "volumes": {
+    "s3://vesuvius-challenge-open-data/PHercParis4/volumes/20260411134726-2.400um-0.2m-78keV-masked.zarr": {
+      "base_voxel_um": 2.4,
+      "reference": "https://github.com/ScrollPrize/villa/blob/main/scrollprize.org/docs/07_tutorial5.md",
+      "checked_date": "2026-11-13",
+      "competition_eligibility": "not_asserted"
+    }
+  }
+}

docs/COMPETITION_ENGINE.md

@@ -0,0 +1,124 @@
+# UNIQUE / Vesuvius 4.15 — moteur de recherche contrôlé
+
+## Résultat livré et limites
+
+Cette version renforce le moteur 4.14, dont l'application a été relue sur TARGET_SPACE avant modification. Le code original du laboratoire est distribué sous MIT (`src/LICENSE`). Les scans, annotations et poids tiers conservent leurs licences propres. Le code n'utilise aucune API payante ; l'hébergement de la carte GPU reste celui du Space.
+
+Ce n'est pas une méthode déjà validée pour gagner le concours : aucun score d'encre réel, gain A10G, déchiffrement ou résultat papyrologique n'est revendiqué. Le petit modèle local reste expérimental. Les poids officiels ne sont pas compatibles par simple renommage ; les deux références vérifiées sont décrites dans `config/vesuvius-model-references.json`. Un adaptateur officiel doit respecter ses couches, sa normalisation, sa représentation et son champ réceptif, puis être validé avant activation. L'export reste `submission_ready=false`.
+
+## Architecture et patrons
+
+| Besoin | Patron et code | Contrat |
+|---|---|---|
+| VRAM | acteur GPU préemptible, `CudaBudget`, `adaptive.py` | marge de 1 Gio puis 65 % de la mémoire libre restante ; mesure du pic réel |
+| Inférence | tuilage avec halo et recadrage des zones valides | rayon 3 validé pour le modèle local uniquement ; aucune moyenne de bords faux |
+| Manque mémoire | réduction du batch puis subdivision des tuiles | arrêt au minimum ou au circuit breaker ; aucun retry infini |
+| Reprise | manifeste de tuiles + sortie memmap ; checkpoints modèle/AdamW safetensors | sorties écrites avant progression validée ; identité des entrées vérifiée |
+| Streaming | ROI S3 bornée, cache exact, calibration NGFF | lecture anonyme ; aucun changement d'axes ou d'unités silencieux |
+| Surface | normales physiques et volumes conditionnés, `surface_volume.py` | contextes hors CT masqués et halo de validité érodé |
+| Géométrie | triangles structurés, contrôles UV, `spatial.py` | pas d'interpolation à travers les trous du masque |
+| Qualité | splits spatiaux immuables, seuil sur calibration, contrôles | les scores sur le test ne pilotent pas l'optimisation |
+| Boucle autonome | DAG durable mono-superviseur, backoff, quarantaine | pas de modification des annotations ni des seuils d'acceptation après échec |
+
+```mermaid
+flowchart TD
+  S["ROI CT et surfaces annotées"] --> C["Calibration et provenance"]
+  C --> T["Entraînement checkpointé"]
+  C --> V["Régions tenues à part"]
+  T --> I["Inférence adaptative"]
+  V --> I
+  I --> Q["Contrôles scientifiques"]
+  Q -->|réussite| E["Export de recherche"]
+  Q -->|échec| R["Quarantaine documentée"]
+  I -->|OOM ou préemption| P["Reprise bornée"]
+  P --> I
+```
+
+Le serveur garde l'interface et l'arbitrage. Les calculs restent dans des sous-processus à durée bornée. Aucun fichier `agents/`, `engine/` ou `mouh/service.py` n'est remplacé. Le bootstrap ne charge ni poids ni scan. La supervision n'est activée qu'à la demande ou avec son interrupteur explicite.
+
+## GPU, débit et reprise
+
+`predict` accepte désormais CPU ou CUDA. Sur CUDA, les données des tuiles sont placées en mémoire épinglée et copiées sans blocage ; l'inférence utilise bf16 lorsque supporté et retourne des sorties float32. La taille initiale reste prudente. Un OOM pendant une inférence réduit d'abord le batch, puis découpe les rectangles. Une réservation insuffisante pour le modèle lui-même ne se corrige pas en mentant sur la taille des images : elle finit en échec documenté.
+
+Les blocs conservent trois voxels de contexte XY pour ce petit réseau (deux convolutions 3D puis une convolution 2D). Le noyau central est recopié exactement ; les vrais bords du volume gardent le padding du modèle. Ce halo ne peut pas être réutilisé aveuglément avec un ResNet ou U-Net officiel. Les volumes de surface gardent toute leur profondeur ; on ne moyenne pas des blocs Z indépendants qui changeraient le sens du modèle.
+
+Chaque tuile écrite est flushée avant mise à jour du manifeste. Le nom du manifeste dérive de l'empreinte source, des poids et des paramètres. Une reprise après arrêt brutal retrouve automatiquement ce manifeste. Les microcycles enregistrent modèle, moments AdamW, compteur global et seed ; la boucle reprend seulement les étapes restantes. La reprise CPU est testée bit à bit. Cela ne démontre pas une identité bit à bit entre GPU ou versions différentes.
+
+Les mesures comprennent secondes, pixels effectivement traités, tuiles validées, retries OOM et pics CUDA. Le budget est une estimation initiale, pas un profileur magique. Le benchmark CPU joint est une observation synthétique ponctuelle, pas un gain A10G garanti. La saturation matérielle et les tailles optimales doivent être mesurées sur la carte du Space. Le découpage, les snapshots et le démarrage des workers ont aussi un coût ; une petite ROI peut être plus rapide sans subdivision.
+
+## Fidélité et géométrie
+
+La calibration lit axes, unités et transformations NGFF. Un ordre autre que z,y,x, une transformation inconnue ou un pas incompatible est refusé. Certains volumes publics n'indiquent que des facteurs de pyramide, sans unités : le volume Paris 4 d'exemple est alors rapproché d'une entrée documentée du catalogue local de calibrations. Sans preuve de calibration, l'état reste `verified=false` et le verrou automatique de validation refuse d'approuver le résultat.
+
+Ce rapprochement documentaire ne remplace pas une calibration instrumentale. Les alias de volumes doivent être consolidés avant une campagne : les verrous de recouvrement identifient actuellement les scans par URI canonique, pas par une connaissance universelle de tous leurs miroirs.
+
+Les charts sont calculés en unités physiques, les XYZ originaux restent en double précision. Les deux triangles de chaque quad sont vérifiés : dégénérescences, orientations et bords UV croisés. Le rendu parcourt les triangles structurés valides ; il ne construit plus une enveloppe convexe qui remplirait les trous. Le rapport limite la distorsion relative maximale à 5 %. Une surface intrinsèquement non développable peut donc être refusée plutôt que déformée arbitrairement.
+
+Les grilles de sortie respectent le rapport d'aspect et déclarent séparément les pas X et Y. L'archive conserve XYZ/UV originaux en NPZ, le rendu brut, les TIFF de coordonnées, le masque et la méthode d'interpolation. La conversion TIFXYZ float32 mesure son erreur de quantification et refuse une erreur supérieure à 0,1 µm. Cela apporte une perte bornée et traçable ; « zéro perte » ne serait pas une promesse honnête pour une interpolation et un changement de précision.
+
+## Volumes de surface et vérité terrain
+
+La détection d'encre ne doit pas être évaluée comme une projection arbitraire d'un cube CT. L'action `surface` échantillonne 17 couches autour du mesh le long de ses normales, en tenant compte du pas physique. Les points hors ROI sont invalidés ; les pixels influencés par du contexte absent sont exclus de la loss et des métriques.
+
+Les rôles `train`, `calibration`, `validation`, `test` et `negative` sont persistés. Les régions de rôles différents ne se recouvrent pas. Les empreintes des annotations et entrées sont figées lors du lancement des tâches ; un artefact modifié est refusé. Une surface estimée par simple gradient n'est pas une surface fournie/annotée et ne franchit pas le verrou de qualité.
+
+Les métriques sont précision, rappel, Dice, IoU, taux de faux positifs, Brier, ECE et F1 de contour à un pixel. La fonction `surface_metrics` calcule aussi Chamfer symétrique, Hausdorff maximal et percentile 95 en µm contre une surface de référence fournie dans le même repère ; sans cette référence, aucune précision de segmentation 3D n’est revendiquée. Les cas sans positifs ne gagnent pas artificiellement un Dice de 1. Le seuil est choisi sur calibration seulement ; une calibration sans point satisfaisant la précision minimale s'abstient. Un rapport de validation doit porter sur les mêmes poids que la calibration et le contrôle négatif.
+
+Le stress test utilise trois niveaux de bruit gaussien simulé sur l'intensité normalisée, avec seed fixé. Il ne prétend pas modéliser la physique du scanner. Les seuils par défaut du verrou sont précision ≥0,95, Dice ≥0,60 et faux positifs ≤0,01, avec contrôles négatifs et sous bruit réussis. Ce sont des choix de recherche configurables dans le code, pas des critères officiels du concours.
+
+Même un verrou réussi conserve `legibility_certified=false` et `competition_eligibility_certified=false`. La lisibilité lettre par lettre et la validation des organisateurs ne se déduisent pas de Dice, surtout lorsqu'il est calculé sur des pseudo-labels.
+
+## Supervision continue, configuration
+
+Après upload et redémarrage, ouvrir `/gradio/` puis **Laboratoire Vesuvius 3D → Validation et supervision**. La clé d'administration protège le démarrage et l'arrêt. Le superviseur fonctionne tant que le processus du Space est en ligne ; il ne garantit pas l'uptime de l'hébergeur et aucun essai de 24 heures n'a été fait ici.
+
+Le plan JSON est sous `/data/chunks/vesuvius/competition-plan.json`. Il contient au plus 256 tâches avec `name`, `action` et `payload`. Une valeur `@nom` référence le champ `path` d'un résultat antérieur. Le DAG est validé, les cycles et références inconnues refusés. Les tâches sont identifiées par empreinte ; un plan déjà traité ne relance pas tout. Un seul superviseur écrit cette file ; ce n'est pas une file distribuée multi-réplicas. L'état est gardé en mémoire et écrit lors des transitions, pour éviter de relire des centaines d'objets du stockage à chaque seconde.
+
+Pour construire le plan supervisé complet à partir de vos vrais fichiers :
+
+```bash
+python -m src.plan --regions /data/chunks/vesuvius/regions.json --device cuda --steps 8
+```
+
+`regions.json` doit fournir quatre entrées `train`, `calibration`, `validation`, `negative`. Chacune contient : `roi` avec `uri`, `level`, `origin`, `shape`, `voxel_um` ; `surface_xyz`, chemin absolu d'une surface .npy H×W×3 sous `/data/meshes/vesuvius/` ; `labels`, annotations binaires .npy H×W sous `/data/chunks/vesuvius/`. Les régions doivent être disjointes, les labels négatifs nuls et documentés comme absence d'encre. Le programme ne crée pas de fausse vérité terrain pour rendre l'exemple exécutable.
+
+Ce constructeur produit 19 tâches : chargements, charts, volumes de surface, microcycle supervisé, prédictions disjointes, calibration, validation et export conditionné par la validation. Les poids du plan sont ceux du modèle local expérimental ; il faut de vraies données annotées pour les entraîner. Les sources pré-entraînées officielles ci-dessous nécessitent leur adaptateur validé propre.
+
+Activer ensuite la file dans l'onglet. Pour la reprise automatique au redémarrage, définir la variable du Space :
+
+```text
+UNIQUE_VESUVIUS_AUTORUN=1
+```
+
+La valeur par défaut est 0. Arrêter la supervision avant de changer de plan. Les nouvelles tâches sont prises en compte au prochain démarrage de la supervision ; les entrées déjà réussies restent dédupliquées. Après épuisement du plan, le superviseur reste en attente sans fabriquer de nouvelles régions, scans ou entraînements.
+
+## Auto-correction encadrée
+
+- Réseau : backoff de 30 secondes jusqu'à 15 minutes, cinq tentatives au plus.
+- Préemption : reprise du checkpoint de tuile ou de l'optimiseur, avec étapes restantes.
+- OOM d'inférence : batch puis blocs plus petits ; OOM du modèle ou d'entraînement : revue opérateur plutôt qu'une modification silencieuse du problème.
+- Géométrie : un second calcul local jusqu'à 60 itérations, sans relâcher la tolérance. Un second échec est mis en quarantaine.
+- Calibration/qualité : abstention et quarantaine, puis blocage des dépendances aval. Aucun export automatique d'un mauvais candidat, aucune retouche de labels ou de critères pour le faire passer.
+
+Les rapports de jobs, checkpoint, splits et décisions restent sur `/data`. La publication des jeux de données et runs requise pour certains prix n'est pas réalisée automatiquement. Aucun message, submission, push de poids ou upload de données n'est envoyé par la boucle.
+
+## Conditions pour réellement viser un prix
+
+1. Choisir le prix et un volume réellement éligible dans les règles actuelles.
+2. Constituer des surfaces et annotations fiables, avec un découpage spatial versionné et un test final verrouillé.
+3. Intégrer et mesurer un baseline officiel adapté au pas et à la représentation ; vérifier son manifeste d'entraînement pour éviter la fuite de données.
+4. Mesurer Dice, précision, faux positifs, stabilité, coût par surface et erreur géométrique sur de vraies données tenues à part. Comparer les variantes avec le même protocole.
+5. Valider les colonnes complètes dans VC3D, puis obtenir une lecture indépendante. Un patch en 2048 pixels n'est pas une colonne entière ni une nouvelle résolution CT.
+
+Cette version réalise l'infrastructure de contrôle et de mesure. Elle ne fournit pas les annotations scientifiques manquantes, ne charge pas par erreur un gros checkpoint officiel dans le petit réseau et ne garantit pas une victoire.
+
+## Sources vérifiées le 13 novembre 2026
+
+- https://scrollprize.org/prizes
+- https://scrollprize.org/from_ash_to_text
+- https://huggingface.co/scrollprize/ink_9um
+- https://huggingface.co/scrollprize/ink_canonical_2um
+- https://github.com/ScrollPrize/villa/tree/main/ink-detection/optimized_inference
+- https://huggingface.co/buckets/scrollprize/datasets/tree/ink_9um
+
+Le code MIT des modèles ne relicense pas les scans et annotations, dont les termes CC BY-NC 4.0 doivent être respectés. La fenêtre 64 reste une borne de ce moteur local, pas une règle universelle du concours.

docs/VALIDATION_COMPETITION_4.15.0.json

@@ -0,0 +1,86 @@
+{
+  "release": "4.15.0",
+  "date": "2026-11-13",
+  "tests": {
+    "laboratory_and_competition": {
+      "tests": 52,
+      "errors": 0,
+      "failures": 0,
+      "skipped": 0
+    },
+    "unique_regression": {
+      "tests": 109,
+      "errors": 0,
+      "failures": 0,
+      "skipped": 0
+    }
+  },
+  "regression_accounting": "109 UNIQUE + 22 original Lab + 30 new competition cases = 161",
+  "live_s3": {
+    "ok": true,
+    "geometry": {
+      "verified": true,
+      "source": "curated_catalogue_plus_NGFF",
+      "scale_zyx_um": [
+        2.4,
+        2.4,
+        2.4
+      ],
+      "translation_zyx_um": [
+        0.0,
+        0.0,
+        0.0
+      ],
+      "axes": "zyx",
+      "calibration_reference": "https://github.com/ScrollPrize/villa/blob/main/scrollprize.org/docs/07_tutorial5.md"
+    },
+    "shape": [
+      8,
+      8,
+      8
+    ],
+    "minimum": 33.0,
+    "maximum": 134.0,
+    "seconds": 7.000806077000107
+  },
+  "cpu_microbenchmark": {
+    "data": "synthetic_not_CT_validation",
+    "device": "cpu",
+    "shape": [
+      17,
+      64,
+      64
+    ],
+    "full_forward_seconds": 0.12432532000002539,
+    "tiled_forward_and_checkpoint_seconds": 0.044506014000035066,
+    "max_absolute_difference": 2.9802322387695312e-08,
+    "gpu_benchmark_performed": false,
+    "speedup_claimed": false
+  },
+  "proved_in_tests": [
+    "Halo tiled inference matches full CPU inference within 1e-6",
+    "AdamW/model checkpoint restart reproduces uninterrupted CPU weights exactly",
+    "OOM subdivision and hard tile restart tested without GPU using controlled failures",
+    "Surface-conditioned sampling, metric geometry and hole masks tested",
+    "Persistent DAG abstains and quarantines rather than exporting failed scientific results",
+    "Gradio tab and isolated ASGI configuration remain operational"
+  ],
+  "not_proved": [
+    "A10G performance, CUDA OOM behavior and bf16 numerical quality",
+    "24-hour uptime or real bucket mount persistence after reboot",
+    "Scientific accuracy on real annotated ink/segmentation data",
+    "Official pretrained-model adapter integration, VC3D full roundtrip, full-column assembly or prize eligibility"
+  ],
+  "model": "tiny_hybrid_3d_2d_v1 remains experimental; official models referenced, not falsely loaded",
+  "code_license": "MIT for original laboratory add-on only",
+  "dependencies": {
+    "torch": "2.6.0+cpu",
+    "numpy": "2.5.4",
+    "scipy": "1.18.1",
+    "zarr": "2.18.7",
+    "s3fs": "2025.12.0",
+    "tifffile": "2026.11.8",
+    "gradio": "5.50.0",
+    "safetensors": "0.8.0"
+  }
+}

mouh/learning/manifest.json

@@ -1,5 +1,5 @@
 {
-  "version": "v4.14.0",
+  "version": "v4.15.0",
   "files": {
     "Dockerfile": "f68259170ec47222",
     "README.md": "ed433a59c0e4fb6d",
@@ -8,7 +8,7 @@
     "agents/contract.py": "925f5ac350a90ea0",
     "agents/core.py": "24e49461b79764ba",
     "agents/mission.py": "9b760c2378774b7b",
-    "app.py": "bad902c73a24d67d",
+    "app.py": "311b8e107fb63bd2",
     "config.json": "e75d8b151c4de3d1",
     "engine/__init__.py": "9ed43b8c6346ad0e",
     "engine/exam.py": "b9d7eeac20ff9a12",
@@ -86,7 +86,7 @@
     "requirements-dev.txt": "9a03d0d2ca94a0d2",
     "requirements.txt": "f6e0d34c6f292b9a",
     "unique_ext/README.md": "0f0be41551e6bacb",
-    "unique_ext/__init__.py": "179aa19888358397",
+    "unique_ext/__init__.py": "6f3eef0b6cca349d",
     "unique_ext/backends/__init__.py": "e3b0c44298fc1c14",
     "unique_ext/backends/hf.py": "506d29e81c127e1e",
     "unique_ext/contracts.py": "4ce5632e921dfcdc",
@@ -140,16 +140,28 @@
     "agents/discovery_capabilities.py": "41a76670ed0553c1",
     "config/spaces_curated.json": "9a9f54dceab9cfbf",
     "src/__init__.py": "ef77ad4265bda616",
-    "src/controller.py": "b4c9586d5de615d3",
-    "src/exporter.py": "a6fdfcce4e1135f5",
-    "src/loader.py": "1d7ecba8594d015a",
+    "src/controller.py": "e375e2f5fd343405",
+    "src/exporter.py": "88a070c32d8306c5",
+    "src/loader.py": "149035fcfd4195c8",
     "src/scanner.py": "3746e1d337810a54",
     "src/storage.py": "e5feb00026c0dbc5",
-    "src/trainer.py": "3c0abcbc27d70514",
-    "src/ui.py": "2784fe94110157a8",
-    "src/unwrapper.py": "6f556fa3fb15fd9c",
-    "src/worker.py": "7104681fcf9e81cf",
-    "requirements-vesuvius.txt": "61384af45af4799c"
+    "src/trainer.py": "aee2727502717613",
+    "src/ui.py": "2c606d7d21b14bd5",
+    "src/unwrapper.py": "3cedb5393c2f92b0",
+    "src/worker.py": "312d592395ffaed3",
+    "requirements-vesuvius.txt": "61384af45af4799c",
+    "src/adaptive.py": "f36d10a60d2a9994",
+    "src/autonomous.py": "040868e24c0823f0",
+    "src/checkpoints.py": "dcbe06825be82e85",
+    "src/datasets.py": "9dd36ecbbf94b43f",
+    "src/evaluation.py": "72abb128f2cfcc74",
+    "src/plan.py": "649b2b1f7badb85f",
+    "src/quality.py": "908378d962326762",
+    "src/spatial.py": "3d16f0c0c217bbec",
+    "src/surface_volume.py": "609a74ee150ba37e",
+    "src/LICENSE": "7d74d6738b4cf764",
+    "config/vesuvius_calibrations.json": "79a3a00fdc7a99f0",
+    "config/vesuvius-model-references.json": "74edaa225ac99387"
   },
   "removed": [
     "mouh/learning/autopilot.py",

src/LICENSE

@@ -0,0 +1,24 @@
+MIT License
+
+Copyright (c) 2026 UNIQUE contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+
+This license covers this original laboratory add-on, not third-party code,
+model weights, annotations, or CT datasets. Those retain their own licenses.

src/adaptive.py

@@ -0,0 +1,113 @@
+"""Tuilage exact XY avec halo, réduction sur OOM et reprise durable par tuile."""
+from __future__ import annotations
+from contextlib import nullcontext
+import gc
+import hashlib
+import json
+import math
+import time
+
+
+class Preempted(RuntimeError):
+    def __init__(self, resume):
+        super().__init__('calcul préempté après checkpoint')
+        self.resume=resume
+
+
+class CudaBudget:
+    def __init__(self, device='cpu', reserve_bytes=1024**3, fraction=.65):
+        self.device=device;self.reserve=reserve_bytes;self.fraction=fraction
+        self.started=None;self.report={}
+
+    def __enter__(self):
+        import torch
+        if self.device=='cuda':
+            if not torch.cuda.is_available():raise RuntimeError('CUDA indisponible')
+            free,total=torch.cuda.mem_get_info()
+            self.report={'free_before':free,'total':total,'budget_bytes':max(0,int((free-self.reserve)*self.fraction))}
+            if self.report['budget_bytes']<64*1024**2:raise RuntimeError('VRAM réservée insuffisante')
+            torch.cuda.reset_peak_memory_stats()
+        self.started=time.monotonic();return self
+
+    def batch_size(self, depth, side):
+        # Majorant initial prudent, remplacé par les observations de pic dans le rapport.
+        per_tile=max(1,depth*side*side*4*64)
+        return 1 if self.device=='cpu' else max(1,min(16,self.report['budget_bytes']//per_tile))
+
+    def __exit__(self,*exc):
+        import torch
+        if self.device=='cuda':
+            self.report.update(peak_allocated=torch.cuda.max_memory_allocated(),peak_reserved=torch.cuda.max_memory_reserved())
+        self.report['seconds']=time.monotonic()-self.started
+
+
+def tiled_predict(volume, infer, storage, identity, *, side=32, halo=3, batch=1,
+                  resume=None, cancelled=lambda:False, oom_type=MemoryError):
+    """infer reçoit B×D×H×W ; il rend B×H×W. Pas de moyenne de bords inexacts."""
+    import numpy as np
+    if volume.ndim!=3 or not 8<=int(side)<=64 or halo!=3 or batch<1:
+        raise ValueError('tuilage XY de 8 à 64, halo 3 requis par le modèle local')
+    h,w=volume.shape[1:]
+    side=int(side)
+    if side>58 and max(h,w)>64:side=58
+    key=hashlib.sha256(json.dumps(identity,sort_keys=True).encode()).hexdigest()[:24]
+    name=key+'.tiles.json';out_path=storage.path('chunks',key+'.tiles.npy')
+    state_path=storage.path('chunks',name)
+    state=None
+    if resume or state_path.exists():
+        if resume and storage.checked(resume,'chunks')!=state_path:raise ValueError('reprise d’une autre expérience')
+        state=json.loads(state_path.read_text())
+        if state['identity']!=identity:raise ValueError('identité du checkpoint incompatible')
+    if state:
+        out=np.lib.format.open_memmap(out_path,mode='r+')
+        if out.shape!=(h,w) or out.dtype!=np.float32:raise ValueError('sortie de reprise incompatible')
+    else:
+        out=np.lib.format.open_memmap(out_path,mode='w+',dtype='float32',shape=(h,w));out[:]=np.nan;out.flush()
+        state={'identity':identity,'pending':[[y,min(y+side,h),x,min(x+side,w)]
+                for y in range(0,h,side) for x in range(0,w,side)],'committed':0,'oom_retries':0,
+                'output':str(out_path),'batch':int(batch)}
+        storage.json('chunks',name,state)
+    before=time.monotonic()
+    remaining_pixels=sum((r[1]-r[0])*(r[3]-r[2]) for r in state['pending'])
+    while state['pending']:
+        if cancelled():raise Preempted(str(state_path))
+        rect=state['pending'][0]
+        y0,y1,x0,x1=rect
+        a,b,c,d=max(0,y0-halo),min(h,y1+halo),max(0,x0-halo),min(w,x1+halo)
+        # Regroupe seulement les formes identiques : aucun padding artificiel aux bords du volume.
+        selected=[];patches=[];bounds=[]
+        for r in state['pending'][:state['batch']]:
+            u,v,s,t=r;aa,bb,cc,dd=max(0,u-halo),min(h,v+halo),max(0,s-halo),min(w,t+halo)
+            if (bb-aa,dd-cc)!=(b-a,d-c):break
+            selected.append(r);patches.append(np.asarray(volume[:,aa:bb,cc:dd],dtype='float32'));bounds.append((aa,cc))
+        try:
+            predictions=np.asarray(infer(np.stack(patches)))
+            if predictions.shape!=(len(selected),b-a,d-c) or not np.isfinite(predictions).all():
+                raise ValueError('sortie de modèle incohérente ou non finie')
+        except oom_type:
+            state['oom_retries']+=1
+            if state['oom_retries']>64:raise RuntimeError('circuit breaker OOM')
+            gc.collect()
+            try:
+                import torch
+                if torch.cuda.is_available():torch.cuda.empty_cache()
+            except ImportError:pass
+            if state['batch']>1:state['batch']=max(1,state['batch']//2)
+            elif max(y1-y0,x1-x0)>8:
+                if y1-y0>=x1-x0:
+                    m=(y0+y1)//2;children=[[y0,m,x0,x1],[m,y1,x0,x1]]
+                else:
+                    m=(x0+x1)//2;children=[[y0,y1,x0,m],[y0,y1,m,x1]]
+                state['pending'][0:1]=children
+            else:raise RuntimeError('OOM même à la taille minimale') from None
+            storage.json('chunks',name,state);continue
+        for r,p,(aa,cc) in zip(selected,predictions,bounds):
+            u,v,s,t=r;out[u:v,s:t]=p[u-aa:v-aa,s-cc:t-cc]
+        out.flush()  # La progression n'est validée qu'après écriture de la sortie.
+        state['pending']=state['pending'][len(selected):];state['committed']+=len(selected)
+        storage.json('chunks',name,state)
+    state['seconds_this_run']=time.monotonic()-before
+    state['pixels_per_second']=remaining_pixels/max(state['seconds_this_run'],1e-9)
+    state['pixels_this_run']=remaining_pixels
+    storage.json('chunks',name,state)
+    return np.asarray(out),{**state,'resume':str(state_path)}

src/autonomous.py

@@ -0,0 +1,187 @@
+"""File persistante mono-superviseur ; reprises bornées, aucune réécriture de vérité terrain."""
+import hashlib
+from copy import deepcopy
+import json
+from pathlib import Path
+import threading
+import time
+
+from .controller import Busy
+
+
+class Queue:
+    def __init__(self,storage):
+        self.storage=storage;self._cache=None;self._lock=threading.RLock()
+
+    def enqueue(self,tasks):
+        if not isinstance(tasks,list) or not 1<=len(tasks)<=256:raise ValueError('plan de 1 à 256 tâches requis')
+        names={}
+        for task in tasks:
+            if not isinstance(task,dict) or task.get('action') not in ('load','scan','unwrap','surface','train','predict','evaluate','export'):
+                raise ValueError('action de plan invalide')
+            if not isinstance(task.get('payload',{}),dict):raise ValueError('payload requis')
+            if task.get('payload',{}).get('role')=='test':raise ValueError('pas d’optimisation automatique sur le jeu test')
+            name=task.get('name')
+            if name:
+                if not isinstance(name,str) or name in names:raise ValueError('nom de tâche invalide ou dupliqué')
+                names[name]=task
+        canonical={};visiting=set()
+        def normalize(task):
+            token=id(task)
+            if token in canonical:return canonical[token]
+            if token in visiting:raise ValueError('cycle dans le plan')
+            visiting.add(token)
+            def replace(v):
+                if isinstance(v,str) and v.startswith('@'):
+                    if v[1:] in names:
+                        key,_=normalize(names[v[1:]]);return '@'+key
+                    if not self.storage.path('chunks','queue_'+v[1:]+'.json').exists():
+                        raise ValueError('référence de plan inconnue : '+v)
+                    return v
+                if isinstance(v,dict):return {k:replace(x) for k,x in v.items()}
+                if isinstance(v,list):return [replace(x) for x in v]
+                return v
+            transformed={**task,'payload':replace(task.get('payload',{}))}
+            key=hashlib.sha256(json.dumps(transformed,sort_keys=True,allow_nan=False).encode()).hexdigest()[:24]
+            visiting.remove(token);canonical[token]=(key,transformed);return key,transformed
+        normalized=[normalize(task) for task in tasks];ids=[]
+        for key,task in normalized:
+            path=self.storage.path('chunks','queue_'+key+'.json')
+            if not path.exists():self.save({'id':key,'task':task,'state':'queued','attempts':0,'due':0.,'events':[]})
+            ids.append(key)
+        return ids
+
+    def records(self):
+        with self._lock:
+            if self._cache is None:
+                self._cache={r['id']:r for r in [json.loads(p.read_text()) for p in sorted(self.storage.folder('chunks').glob('queue_*.json'))]}
+            return deepcopy(list(self._cache.values()))
+
+    def save(self,record):
+        with self._lock:
+            if self._cache is None:self.records()
+            self.storage.json('chunks','queue_'+record['id']+'.json',record)
+            self._cache[record['id']]=deepcopy(record)
+
+    def recover(self):
+        for record in self.records():
+            if record['state']=='running':
+                record['state']='queued';record['due']=time.time()+30
+                record['events'].append({'at':time.time(),'decision':'recovered_after_restart'})
+                self.save(record)
+
+    def file_hash(self,path):
+        for kind in self.storage.KINDS:
+            try:
+                candidate=self.storage.checked(path,kind)
+                if candidate.is_file():return self.storage.digest(candidate,kind)
+            except ValueError:pass
+        raise ValueError('artefact hors registre ou absent')
+
+    def freeze_inputs(self,record,payload):
+        hashes={}
+        def visit(value):
+            if isinstance(value,str) and value.startswith('/'):
+                hashes[value]=self.file_hash(value)
+            elif isinstance(value,dict):
+                for v in value.values():visit(v)
+            elif isinstance(value,list):
+                for v in value:visit(v)
+        visit(payload)
+        for path,digest in record.get('input_sha256',{}).items():
+            if self.file_hash(path)!=digest:raise ValueError('entrée modifiée après lancement')
+        record.setdefault('input_sha256',{}).update(hashes)
+        self.save(record)
+
+    def resolve(self,task,records):
+        # Référence exacte @id : champ path du résultat d'une tâche déjà réussie.
+        def value(v):
+            if isinstance(v,str) and v.startswith('@'):
+                dependency=records.get(v[1:])
+                if dependency and dependency['state']=='quarantined':raise ValueError('dépendance en quarantaine')
+                if not dependency or dependency['state']!='done':raise LookupError('dépendance non prête')
+                path=dependency['result']['path']
+                if dependency.get('output_sha256') and self.file_hash(path)!=dependency['output_sha256']:
+                    raise ValueError('artefact de dépendance modifié')
+                return path
+            if isinstance(v,dict):return {k:value(x) for k,x in v.items()}
+            if isinstance(v,list):return [value(x) for x in v]
+            return v
+        return value(task['payload'])
+
+    def finish(self,record,state,now=None):
+        now=time.time() if now is None else now
+        code=state.get('code','unknown')
+        if state['status']=='done':
+            record.update(state='done',result=state['result'])
+            artifact=state['result'].get('path')
+            if artifact and Path(artifact).is_file():
+                record['output_sha256']=self.file_hash(artifact)
+            if (state['result'].get('report',{}).get('acceptance',{}).get('automatic_gate_passed') is False
+                    or state['result'].get('report',{}).get('status')=='abstain'):
+                record['state']='quarantined';code='quality_gate_failed'
+        else:
+            resume=state.get('resume')
+            if code=='preempted' and resume:
+                action=record['task']['action']
+                if action=='train' and isinstance(resume,dict):record['task']['payload'].update(resume)
+                if action=='predict' and isinstance(resume,str):record['task']['payload']['resume']=resume
+            if code=='oom':
+                payload=record['task']['payload']
+                if record['task']['action']=='predict':payload['tile']=max(8,int(payload.get('tile',32))//2)
+                else:code='training_requires_operator_memory_review'
+            if code=='geometry' and record['task']['action']=='unwrap' and record['attempts']<2:
+                record['task']['payload']['iterations']=60
+                code='geometry_refinement'
+            retry=code in ('network','timeout','preempted','oom','geometry_refinement') and record['attempts']<5
+            record.update(state='queued' if retry else 'quarantined',due=now+min(900,30*2**max(0,record['attempts']-1)))
+        record['events']=(record.get('events',[])+[{'at':now,'decision':record['state'],'code':code,
+                                                  'error':state.get('error','')[:500]}])[-32:]
+        self.save(record)
+
+
+class Supervisor:
+    def __init__(self,controller):
+        self.controller=controller;self.queue=Queue(controller.storage)
+        self.stop_event=threading.Event();self.thread=None;self.error=''
+
+    def start(self,plan_path=None):
+        if self.thread and self.thread.is_alive():return 'déjà actif'
+        self.controller.storage.initialize()
+        path=self.controller.storage.checked(plan_path or self.controller.storage.path('chunks','competition-plan.json'),'chunks')
+        if path.stat().st_size>1024**2:raise ValueError('plan trop volumineux')
+        plan=json.loads(path.read_text());self.queue.enqueue(plan['tasks']);self.queue.recover()
+        self.stop_event.clear();self.thread=threading.Thread(target=self._loop,daemon=True,name='vesuvius-supervisor');self.thread.start()
+        return 'supervision active ; plan borné, reprises et quarantaines persistées'
+
+    def stop(self):self.stop_event.set();return self.controller.stop()
+
+    def status(self):
+        records=self.queue.records()
+        return {'running':bool(self.thread and self.thread.is_alive()),'error':self.error,
+                'counts':{s:sum(r['state']==s for r in records) for s in ('queued','running','done','quarantined')}}
+
+    def _loop(self):
+        while not self.stop_event.wait(1):
+            try:
+                if self.controller.status()['status']=='running':continue
+                records={r['id']:r for r in self.queue.records()}
+                for record in records.values():
+                    if record['state']!='queued' or record['due']>time.time():continue
+                    try:payload=self.queue.resolve(record['task'],records)
+                    except LookupError:continue
+                    except (ValueError,OSError,KeyError) as exc:
+                        record.update(state='quarantined',error=str(exc));self.queue.save(record);continue
+                    try:self.queue.freeze_inputs(record,payload)
+                    except (ValueError,OSError) as exc:
+                        record.update(state='quarantined',error=str(exc));self.queue.save(record);continue
+                    payload['_queue_id']=record['id']
+                    try:self.controller.start(record['task']['action'],payload)
+                    except Busy:continue # GPU prioritaire occupé : attente, pas un échec de science.
+                    record.update(state='running',attempts=record['attempts']+1);self.queue.save(record)
+                    while self.controller.status()['status']=='running':
+                        if self.stop_event.wait(.2):self.controller.stop()
+                    self.queue.finish(record,self.controller.status());break
+            except Exception as exc:
+                self.error=type(exc).__name__+': '+str(exc)[:500]
+                self.stop_event.wait(30)

src/checkpoints.py

@@ -0,0 +1,38 @@
+"""Snapshots sûrs du modèle et de l'optimiseur, sans pickle exécutable."""
+import json
+import uuid
+
+
+def save(storage, model, optimizer, report):
+    from safetensors.torch import save_file
+    name=uuid.uuid4().hex;path=storage.path('weights',name+'.safetensors')
+    save_file({k:v.detach().cpu().contiguous() for k,v in model.state_dict().items()},str(path))
+    state=optimizer.state_dict();flat={}
+    for index,entry in state['state'].items():
+        for key,value in entry.items():
+            if hasattr(value,'detach'):flat[f'{index}.{key}']=value.detach().cpu().contiguous()
+            else:raise ValueError('état optimiseur non tensoriel non pris en charge')
+    opt=storage.path('weights',name+'.optimizer.safetensors')
+    save_file(flat,str(opt))
+    result={**report,'optimizer_param_groups':state['param_groups'],
+            'weights_sha256':storage.digest(path,'weights'),'optimizer_sha256':storage.digest(opt,'weights')}
+    storage.json('weights',name+'.json',result)
+    return str(path),result
+
+
+def load(storage,path,model,optimizer=None,device='cpu'):
+    from safetensors.torch import load_file
+    path=storage.checked(path,'weights')
+    if path.stat().st_size>16*1024**2:raise ValueError('checkpoint trop volumineux')
+    metadata=json.loads(path.with_suffix('.json').read_text())
+    if metadata.get('weights_sha256') and storage.digest(path,'weights')!=metadata['weights_sha256']:
+        raise ValueError('poids modifiés après checkpoint')
+    model.load_state_dict(load_file(str(path),device=device))
+    if optimizer is not None and metadata.get('optimizer_param_groups') is not None:
+        opt=path.with_name(path.stem+'.optimizer.safetensors')
+        if storage.digest(opt,'weights')!=metadata['optimizer_sha256']:raise ValueError('optimiseur modifié')
+        state={}
+        for key,value in load_file(str(opt),device=device).items():
+            index,field=key.split('.',1);state.setdefault(int(index),{})[field]=value
+        optimizer.load_state_dict({'state':state,'param_groups':metadata['optimizer_param_groups']})
+    return metadata

src/controller.py

@@ -13,6 +13,10 @@ import uuid
 from .storage import Storage
 
 
+class Busy(RuntimeError):
+    pass
+
+
 class Controller:
     def __init__(self, storage=None, busy=lambda:None, preempt=lambda:False,
                  gpu_context=nullcontext, concurrent_uses=lambda:0):
@@ -27,13 +31,13 @@ class Controller:
         with self.lock:return dict(self.state)
 
     def start(self, action, payload):
-        if action not in ('load','scan','unwrap','train','predict','export'):
+        if action not in ('load','scan','unwrap','surface','train','predict','evaluate','export'):
             raise ValueError('action inconnue')
         with self.lock:
-            if self.state['status']=='running':raise RuntimeError('un job du laboratoire est déjà actif')
+            if self.state['status']=='running':raise Busy('un job du laboratoire est déjà actif')
             self.storage.initialize()
-            gpu=action=='train' and payload.get('device')=='cuda'
-            if gpu and self.busy():raise RuntimeError('GPU prioritaire occupé par UNIQUE : '+str(self.busy()))
+            gpu=action in ('train','predict') and payload.get('device')=='cuda'
+            if gpu and self.busy():raise Busy('GPU prioritaire occupé par UNIQUE : '+str(self.busy()))
             job=uuid.uuid4().hex
             request=self.storage.json('chunks',job+'.request.json',{'action':action,'payload':payload})
             self.gpu_active=gpu;self._cancel=False
@@ -64,21 +68,27 @@ class Controller:
                     deadline=time.monotonic()+(45 if gpu else 120)
                     while self.proc.poll() is None:
                         if self._cancel or time.monotonic()>deadline or (gpu and self.preempt()):
+                            request.with_suffix('.cancel').write_text('cancel')
                             self.proc.terminate()
                             try:self.proc.wait(timeout=3)
                             except subprocess.TimeoutExpired:self.proc.kill();self.proc.wait()
-                            raise RuntimeError('job annulé, préempté par UNIQUE ou budget épuisé')
+                            output=request.with_name(request.stem+'.result.json')
+                            if output.is_file():result=json.loads(output.read_text())
+                            else:result={'ok':False,'error':'job annulé, préempté ou budget épuisé',
+                                         'code':'timeout' if time.monotonic()>deadline else 'preempted'}
+                            break
                         time.sleep(0.2)
                 output=request.with_name(request.stem+'.result.json')
                 if output.is_file() and output.stat().st_size<1024**2:
                     result=json.loads(output.read_text())
-                else:result={'ok':False,'error':'worker indisponible ; voir '+str(log)}
+                elif result.get('code') is None:result={'ok':False,'error':'worker indisponible ; voir '+str(log),'code':'unknown'}
         except Exception as exc:result={'ok':False,'error':type(exc).__name__+': '+str(exc)[:1000]}
         finally:
             with self.lock:
                 self.gpu_active=False;self.proc=None
                 self.state.update(status='done' if result.get('ok') else 'error',gpu=False,
-                                  result=result.get('result'),error=result.get('error',''))
+                                  result=result.get('result'),error=result.get('error',''),
+                                  code=result.get('code'),resume=result.get('resume'))
 
     def stop(self):
         self._cancel=True

src/datasets.py

@@ -0,0 +1,16 @@
+"""Registre immuable des rôles spatiaux ; validation et calibration séparées."""
+import json
+
+
+def register(storage,region,role):
+    from .trainer import overlaps
+    if role not in ('train','calibration','validation','test','negative'):raise ValueError('rôle de région invalide')
+    path=storage.path('chunks','dataset-splits.json')
+    records=json.loads(path.read_text()) if path.exists() else []
+    for item in records:
+        if item['role']!=role and overlaps(region,item['region']):
+            raise ValueError('recouvrement de régions entre '+role+' et '+item['role'])
+    record={'region':region,'role':role}
+    if record not in records:
+        records.append(record);storage.json('chunks',path.name,records)
+    return record

src/evaluation.py

@@ -0,0 +1,69 @@
+"""Évaluation des vraies annotations ; controles négatifs et perturbations synthétiques."""
+import json
+import uuid
+
+
+def evaluate(storage,prediction,labels,chunk,negative_prediction=None,negative_labels=None,role='validation',threshold=.5,calibration_report=None):
+    import numpy as np
+    import torch
+    from .loader import read_chunk
+    from .trainer import build_model,overlaps
+    from .checkpoints import load
+    from .quality import ink_metrics,robustness,acceptance,choose_threshold
+    from .datasets import register
+    def read_prediction(path):
+        path=storage.checked(path,'chunks')
+        with np.load(path,allow_pickle=False) as f:p=f['prediction'];m=json.loads(str(f['metadata']))
+        if m['kind']!='ink_probability_unvalidated':raise ValueError('une reconstruction ne mesure pas de l’encre')
+        if any(overlaps(m['request'],r) for r in m['training']['training_regions']):raise ValueError('recouvrement entraînement/évaluation')
+        return p,m
+    p,meta=read_prediction(prediction)
+    if storage.digest(meta['checkpoint'],'weights')!=meta['checkpoint_sha256']:
+        raise ValueError('poids différents de la prédiction évaluée')
+    lab=storage.checked(labels,'chunks')
+    if lab.stat().st_size>1024**2:raise ValueError('annotations trop volumineuses')
+    y=np.load(lab,allow_pickle=False)
+    calibration_sha=None
+    if calibration_report:
+        cp=storage.checked(calibration_report,'submissions');calibration=json.loads(cp.read_text())
+        if calibration.get('role')!='calibration' or calibration.get('status')!='calibrated':
+            raise ValueError('calibration exploitable requise')
+        if calibration['weights_sha256']!=meta['checkpoint_sha256'] or overlaps(calibration['source'],meta['request']):
+            raise ValueError('modèle différent ou recouvrement calibration/validation')
+        threshold=float(calibration['threshold']);calibration_sha=storage.digest(cp,'submissions')
+    register(storage,meta['request'],role)
+    if role=='calibration':
+        result={'role':role,'source':meta['request'],'weights_sha256':meta['checkpoint_sha256'],
+                'labels_sha256':storage.digest(lab,'chunks'),**choose_threshold(p,y,role=role,valid=np.asarray(meta['valid_mask'],dtype=bool) if meta.get('valid_mask') is not None else None)}
+    else:
+        volume,source=read_chunk(storage,chunk)
+        if source['request']!=meta['request']:raise ValueError('chunk de validation différent de la prédiction')
+        model=build_model();training=load(storage,meta['checkpoint'],model);model.eval();torch.set_num_threads(1)
+        lo,hi=training['normalization']['low'],training['normalization']['high']
+        normalized=np.clip((volume.astype('float32')-lo)/max(hi-lo,1e-6),0,1).astype('float32')
+        def infer(x):
+            with torch.inference_mode():return model(torch.from_numpy(x[None,None])).sigmoid()[0,0].numpy()
+        valid=np.asarray(meta['valid_mask'],dtype=bool) if meta.get('valid_mask') is not None else None
+        noise=robustness(normalized,infer,y,threshold,valid=valid)
+        noise_ok=all((r['metrics']['precision'] or 0)>=.95 and (r['metrics']['dice'] or 0)>=.6 for r in noise['reports'])
+        negative=None;negative_ok=False
+        if negative_prediction and negative_labels:
+            npred,nmeta=read_prediction(negative_prediction)
+            if nmeta['checkpoint_sha256']!=meta['checkpoint_sha256']:raise ValueError('contrôle négatif calculé avec un autre modèle')
+            if overlaps(meta['request'],nmeta['request']):raise ValueError('contrôle négatif indépendant requis')
+            npath=storage.checked(negative_labels,'chunks')
+            if npath.stat().st_size>1024**2:raise ValueError('annotations négatives trop volumineuses')
+            ny=np.load(npath,allow_pickle=False)
+            if np.any(ny!=0):raise ValueError('le contrôle négatif doit être annoté sans encre')
+            register(storage,nmeta['request'],'negative')
+            negative=ink_metrics(npred,ny,threshold,np.asarray(nmeta['valid_mask'],dtype=bool) if nmeta.get('valid_mask') is not None else None)
+            negative_ok=negative['false_positive_rate'] is not None and negative['false_positive_rate']<=.01
+        result={'role':role,'source':meta['request'],'geometry_verified':bool(meta.get('geometry') and meta['geometry'].get('verified')),'disjoint':True,'metrics':ink_metrics(p,y,threshold,valid),
+                'surface_conditioned':meta.get('input_representation')=='surface_conditioned',
+                'provided_surface':meta.get('surface_kind')=='provided_surface',
+                'threshold':threshold,'calibration_sha256':calibration_sha,'noise':noise,'noise_control_passed':noise_ok,
+                'negative':negative,'negative_control_passed':negative_ok,
+                'weights_sha256':meta['checkpoint_sha256'],'labels_sha256':storage.digest(lab,'chunks')}
+        result['acceptance']=acceptance(result)
+    path=storage.json('submissions','evaluation_'+uuid.uuid4().hex+'.json',result)
+    return {'path':str(path),'report':result}

src/exporter.py

@@ -5,9 +5,9 @@ import uuid
 import zipfile
 
 
-def export(storage, mesh_path, prediction_path=None, pixels=1024):
+def export(storage, mesh_path, prediction_path=None, pixels=1024, validation_report=None):
     import numpy as np
-    from scipy.interpolate import LinearNDInterpolator
+    from .spatial import rasterize
     from scipy.ndimage import map_coordinates
     from PIL import Image,ImageDraw
     import tifffile
@@ -16,10 +16,10 @@ def export(storage, mesh_path, prediction_path=None, pixels=1024):
     if not 64<=int(pixels)<=2048:raise ValueError('résolution de 64 à 2048 pixels par axe')
     path=storage.checked(mesh_path,'meshes')
     with np.load(path,allow_pickle=False) as data:
-        xyz=data['xyz'];uv=data['uv'];meta=json.loads(str(data['metadata']))
+        xyz=data['xyz'];uv=data['uv'];meta=json.loads(str(data['metadata']));mask=data['mask'] if 'mask' in data else None
     if xyz.shape[:2]!=uv.shape[:2] or max(xyz.shape[:2])>64 or meta['quality']['folds']:
         raise ValueError('chart invalide')
-    if meta['quality']['max_relative_stretch']>0.15:raise ValueError('distorsion supérieure à 15 % : réviser la surface')
+    if meta['quality']['max_relative_stretch']>0.05:raise ValueError('distorsion supérieure à 5 % : réviser la surface')
     volume,chunk_meta=read_chunk(storage,meta['chunk'])
     if chunk_meta['request']!=meta['request']:raise ValueError('provenance du chunk modifiée')
     coordinates=xyz[...,::-1]-np.array(meta['request']['origin'])
@@ -36,49 +36,69 @@ def export(storage, mesh_path, prediction_path=None, pixels=1024):
         if any(overlaps(meta['request'],r) for r in prediction_meta['training']['training_regions']):
             raise ValueError('entraînement et export se recouvrent')
         if not np.isfinite(predicted).all():raise ValueError('prédiction non finie')
+        if prediction_meta.get('input_representation')=='surface_conditioned' and prediction_meta.get('source_mesh_sha256')!=storage.digest(path,'meshes'):
+            raise ValueError('prédiction issue d’une autre surface')
+        if prediction_meta.get('valid_mask') is not None:
+            sample_mask=np.asarray(prediction_meta['valid_mask'],dtype=bool)
+            if sample_mask.shape!=values.shape:raise ValueError('masque de contexte incompatible')
+            mask=sample_mask if mask is None else np.asarray(mask,dtype=bool)&sample_mask
         values=predicted
-    low=uv.reshape(-1,2).min(0);high=uv.reshape(-1,2).max(0)
-    if np.min(high-low)<=1e-8:raise ValueError('chart sans étendue')
-    # Grille UV régulière ; la carte XYZ est rééchantillonnée pour conserver la correspondance.
-    n=int(pixels);xs=np.linspace(low[0],high[0],n);ys=np.linspace(low[1],high[1],n)
-    gx,gy=np.meshgrid(xs,ys)
-    interpolator=LinearNDInterpolator(uv.reshape(-1,2),np.c_[xyz.reshape(-1,3),values.ravel()])
-    mapped=interpolator(gx,gy);valid=np.isfinite(mapped).all(axis=-1)
+    geometry=meta.get('geometry',{'scale_zyx_um':[meta['request']['voxel_um']]*3,'translation_zyx_um':[0.,0.,0.],'verified':False})
+    physical=xyz*np.asarray(geometry['scale_zyx_um'][::-1])+np.asarray(geometry['translation_zyx_um'][::-1])
+    metric_xyz=physical if meta.get('uv_units')=='micrometres' else xyz
+    mapped,raster=rasterize(xyz,uv,values,pixels,mask,metric_xyz)
+    valid=np.isfinite(mapped).all(axis=-1)
     if valid.sum()==0:raise ValueError('paramétrisation vide')
+    height,width=mapped.shape[:2]
+    low,high=np.asarray(raster['bounds'][0]),np.asarray(raster['bounds'][1])
+    spacing=raster['spacing_uv']
     raw=np.where(valid,mapped[...,3],0)
     lo,hi=np.percentile(raw[valid],[1,99])
     normalized=np.where(valid,np.clip((raw-lo)/max(float(hi-lo),1e-6),0,1),0)
     name='patch_'+uuid.uuid4().hex
     folder=storage.path('submissions',name);folder.mkdir()
     mesh=folder/(name+'.tifxyz');mesh.mkdir()
+    np.savez_compressed(folder/'original_geometry.npz',xyz=xyz,uv=uv,mask=np.isfinite(xyz).all(-1) if mask is None else mask)
+    quantization=float(np.max(np.linalg.norm((mapped[...,:3][valid].astype('float32').astype('float64')-mapped[...,:3][valid])*np.asarray(geometry['scale_zyx_um'][::-1]),axis=1)))
+    if quantization>.1:raise ValueError('quantification TIFXYZ supérieure à 0,1 µm')
     for i,axis in enumerate('xyz'):
         tifffile.imwrite(mesh/(axis+'.tif'),np.where(valid,mapped[...,i],-1).astype('float32'))
     Image.fromarray((valid*255).astype('uint8')).save(mesh/'mask.png')
     tifffile.imwrite(mesh/'mask.tif',(valid*255).astype('uint8'))
     tifffile.imwrite(folder/(name+'.raw.tif'),raw.astype('float32'))
     image=Image.fromarray((normalized*65535).astype('uint16'));image.save(folder/(name+'.png'))
-    voxel_um=meta['request']['voxel_um'];um_per_pixel=float((high[0]-low[0])*voxel_um/(n-1))
-    possible_mm=float((high[0]-low[0])*voxel_um/1000)
+    voxel_um=meta['request']['voxel_um'];uv_scale=1. if meta.get('uv_units')=='micrometres' else voxel_um
+    um_per_pixel=float(spacing[0]*uv_scale)
+    possible_mm=float((high[0]-low[0])*uv_scale/1000)
     bar_mm=float(10.0 if possible_mm>=12 else max(0.001,possible_mm/4))
     bar_pixels=max(1,int(round(bar_mm*1000/um_per_pixel)))
     preview=Image.fromarray((normalized*255).astype('uint8')).convert('RGB')
-    canvas=Image.new('RGB',(n,n+48),'black');canvas.paste(preview,(0,0));draw=ImageDraw.Draw(canvas)
-    draw.line((8,n+12,8+bar_pixels,n+12),fill='white',width=3)
-    draw.text((8,n+22),f'{bar_mm:g} mm',fill='white');canvas.save(folder/(name+'.scale.png'))
+    canvas=Image.new('RGB',(width,height+48),'black');canvas.paste(preview,(0,0));draw=ImageDraw.Draw(canvas)
+    draw.line((8,height+12,8+bar_pixels,height+12),fill='white',width=3)
+    draw.text((8,height+22),f'{bar_mm:g} mm',fill='white');canvas.save(folder/(name+'.scale.png'))
+    validation_evidence=None
+    if validation_report:
+        evidence_path=storage.checked(validation_report,'submissions')
+        validation_evidence=json.loads(evidence_path.read_text())
+        if not validation_evidence.get('acceptance',{}).get('automatic_gate_passed'):
+            raise ValueError('validation scientifique automatique non réussie')
+        if not prediction_meta or validation_evidence['weights_sha256']!=prediction_meta['checkpoint_sha256']:
+            raise ValueError('validation d’un autre modèle')
     report={'schema':'unique-vesuvius-research/1','created_at':time.time(),'submission_ready':False,
             'reasons':['local_patch_not_full_column','held_out_and_papyrological_validation_missing',
                        'VC3D_roundtrip_not_certified'],
             'source':meta['request'],'mesh':name+'.tifxyz','coordinate_units':'selected_level_voxels',
-            'axes':'xyz','shape':[n,n],'uv_bounds':[low.tolist(),high.tolist()],
-            'micrometres_per_pixel_x':um_per_pixel,
+            'axes':'xyz','shape':[height,width],'quantization_max_um':quantization,
+            'geometry_calibration':geometry,'interpolation':'piecewise_linear_structured_triangles_no_hole_bridging','uv_bounds':[low.tolist(),high.tolist()],
+            'micrometres_per_pixel_x':um_per_pixel,'micrometres_per_pixel_y':float(spacing[1]*uv_scale),
             'scale_bar':{'length_mm':bar_mm,'pixels':bar_pixels,'official_1cm_fits':bar_mm==10},
             'chunk_sha256':storage.digest(meta['chunk'],'chunks'),'geometry':meta['quality'],'surface_kind':meta['surface_kind'],
             'render_kind':prediction_meta['kind'] if prediction_meta else 'CT_density_not_ink',
-            'prediction':prediction_meta,'mesh_sha256':storage.digest(path,'meshes'),
+            'prediction':prediction_meta,'validation_evidence':validation_evidence,'mesh_sha256':storage.digest(path,'meshes'),
             'note':'Une grande image rééchantillonnée ne crée pas de résolution CT supplémentaire.'}
     valid_xyz=mapped[...,:3][valid]
     (mesh/'meta.json').write_text(json.dumps({'format':'tifxyz','type':'seg','uuid':name,
-        'scale':[float((n-1)/(high[0]-low[0])),float((n-1)/(high[1]-low[1]))],
+        'scale':[float(voxel_um/(spacing[0]*uv_scale)),float(voxel_um/(spacing[1]*uv_scale))],
         'bbox':[valid_xyz.min(0).tolist(),valid_xyz.max(0).tolist()],
         'target_volume':meta['request']['uri']+'#vc-base-scale='+meta['request']['level'],
         'coordinate_system':'selected_level_voxels','source':meta['request']},indent=2))

src/loader.py

@@ -38,7 +38,21 @@ class Loader:
                                 'retries':{'max_attempts':1}}, default_fill_cache=False)
         store = fs.get_mapper(spec['uri'], check=False)
         # mode r : pas de création de métadonnées ni d'objets S3.
-        return zarr.open_array(store=store, path=spec['level'], mode='r')
+        array=zarr.open_array(store=store,path=spec['level'],mode='r')
+        from .spatial import ngff_geometry
+        try:attrs=dict(zarr.open_group(store=store,mode='r').attrs)
+        except zarr.errors.GroupNotFoundError:attrs={}
+        from pathlib import Path
+        calibration_file=Path(__file__).resolve().parent.parent/'config/vesuvius_calibrations.json'
+        catalogue=json.loads(calibration_file.read_text()) if calibration_file.exists() else {'volumes':{}}
+        calibration=catalogue.get('volumes',{}).get(spec['uri'])
+        geometry=ngff_geometry(attrs,spec['level'],spec['voxel_um'],calibration)
+        if calibration:geometry['calibration_reference']=calibration['reference']
+        class ReadOnlyArray:
+            shape=array.shape;chunks=array.chunks;dtype=array.dtype
+            def __getitem__(self,slices):return array[slices]
+        result=ReadOnlyArray();result.geometry=geometry
+        return result
 
     def load(self, spec):
         import numpy as np
@@ -63,12 +77,14 @@ class Loader:
             if not np.isfinite(volume).all():
                 raise ValueError('voxels non finis')
             metadata = {'request':spec, 'source_shape':list(array.shape), 'loaded_at':time.time(),
-                        'provenance':'public_CT', 'cache_fallback':False}
+                        'provenance':'public_CT', 'cache_fallback':False,
+                        'geometry':getattr(array,'geometry',{'verified':False,'source':'user_declared_isotropic',
+                            'scale_zyx_um':[spec['voxel_um']]*3,'translation_zyx_um':[0.,0.,0.]})}
             tmp = cache.with_suffix('.tmp.npz')
             np.savez_compressed(tmp, volume=volume, metadata=json.dumps(metadata))
             tmp.replace(cache)
             # Quota du laboratoire uniquement, les autres dossiers restent intacts.
-            entries = sorted(self.storage.folder('chunks').glob('*.npz'), key=lambda p:p.stat().st_mtime)
+            entries = sorted(self.storage.folder('chunks').glob('????????????????????????.npz'), key=lambda p:p.stat().st_mtime)
             total = sum(p.stat().st_size for p in entries)
             for p in entries:
                 if total <= 512*1024**2: break
@@ -96,6 +112,6 @@ def read_chunk(storage, path):
         volume = saved['volume'].copy()
         metadata = json.loads(str(saved['metadata']))
     spec = request_spec(**{k:metadata['request'][k] for k in ('uri','level','origin','shape','voxel_um')})
-    if list(volume.shape) != spec['shape'] or not np.isfinite(volume).all():
+    if list(volume.shape) != metadata.get('sample_shape',spec['shape']) or not np.isfinite(volume).all():
         raise ValueError('chunk incohérent')
     return volume, metadata

src/plan.py

@@ -0,0 +1,54 @@
+"""Construit un DAG reproductible à partir de vraies surfaces et annotations."""
+import argparse
+import json
+from pathlib import Path
+
+
+def build(storage,regions,device='cuda',steps=4):
+    import numpy as np
+    from .loader import request_spec
+    from .trainer import overlaps
+    roles=('train','calibration','validation','negative');specs={};tasks=[];manifest={}
+    for role in roles:
+        data=regions[role];r=data['roi']
+        specs[role]=request_spec(**{k:r[k] for k in ('uri','level','origin','shape','voxel_um')})
+        xyz=storage.checked(data['surface_xyz'],'meshes');label=storage.checked(data['labels'],'chunks')
+        if xyz.stat().st_size>128000 or label.stat().st_size>1024**2:raise ValueError('surface ou annotation trop volumineuse')
+        points=np.load(xyz,allow_pickle=False);labels=np.load(label,allow_pickle=False)
+        if points.ndim!=3 or points.shape[-1]!=3 or labels.shape!=points.shape[:2] or not np.isin(labels,[0,1]).all():
+            raise ValueError('surface et annotations binaires alignées requises')
+        if role=='negative' and np.any(labels):raise ValueError('contrôle négatif non vide')
+        manifest[role]={'roi':specs[role],'xyz_sha256':storage.digest(xyz,'meshes'),'labels_sha256':storage.digest(label,'chunks')}
+        tasks.extend([
+            {'name':'load_'+role,'action':'load','payload':specs[role]},
+            {'name':'mesh_'+role,'action':'unwrap','payload':{'chunk':'@load_'+role,'surface':str(xyz)}},
+            {'name':'surface_'+role,'action':'surface','payload':{'mesh':'@mesh_'+role,'layers':17}}])
+    for i,role in enumerate(roles):
+        if any(overlaps(specs[role],specs[other]) for other in roles[i+1:]):raise ValueError('régions de benchmark non disjointes')
+    tasks.append({'name':'fit','action':'train','payload':{'chunk':'@surface_train','mask':regions['train']['labels'],
+        'mode':'ink_supervised','device':device,'steps':int(steps)}})
+    for role in roles[1:]:
+        tasks.append({'name':'predict_'+role,'action':'predict','payload':{'chunk':'@surface_'+role,'checkpoint':'@fit','device':device}})
+    tasks.append({'name':'calibrate','action':'evaluate','payload':{'prediction':'@predict_calibration',
+        'labels':regions['calibration']['labels'],'chunk':'@surface_calibration','role':'calibration'}})
+    tasks.append({'name':'validate','action':'evaluate','payload':{'prediction':'@predict_validation',
+        'labels':regions['validation']['labels'],'chunk':'@surface_validation','role':'validation',
+        'calibration_report':'@calibrate','negative_prediction':'@predict_negative','negative_labels':regions['negative']['labels']}})
+    tasks.append({'name':'research_export','action':'export','payload':{'mesh':'@mesh_validation',
+        'prediction':'@predict_validation','validation_report':'@validate','pixels':1024}})
+    return {'schema':'unique-competition-plan/1','model':'tiny_hybrid_3d_2d_v1_experimental',
+            'source_manifest':manifest,'tasks':tasks,'official_submission_authorized':False}
+
+
+def main():
+    from .storage import Storage
+    parser=argparse.ArgumentParser()
+    parser.add_argument('--regions',required=True);parser.add_argument('--device',choices=['cuda','cpu'],default='cuda')
+    parser.add_argument('--steps',type=int,default=4);args=parser.parse_args()
+    storage=Storage();storage.initialize()
+    path=storage.checked(args.regions,'chunks')
+    result=build(storage,json.loads(path.read_text()),args.device,args.steps)
+    print(storage.json('chunks','competition-plan.json',result))
+
+
+if __name__=='__main__':main()

src/quality.py

@@ -0,0 +1,83 @@
+"""Mesures supervisées, négatifs et bruit : aucune vérité terrain inventée."""
+import math
+
+
+def surface_metrics(predicted_xyz, reference_xyz, scale_xyz_um=(1.,1.,1.)):
+    import numpy as np
+    from scipy.spatial import cKDTree
+    p=np.asarray(predicted_xyz,dtype=float).reshape(-1,3)*scale_xyz_um
+    r=np.asarray(reference_xyz,dtype=float).reshape(-1,3)*scale_xyz_um
+    if not len(p) or not len(r) or not np.isfinite(p).all() or not np.isfinite(r).all():
+        raise ValueError('surfaces de référence finies et non vides requises')
+    forward=cKDTree(r).query(p,workers=1)[0];backward=cKDTree(p).query(r,workers=1)[0]
+    return {'chamfer_mean_um':float((forward.mean()+backward.mean())/2),
+            'hausdorff_max_um':float(max(forward.max(),backward.max())),
+            'hausdorff_p95_um':float(max(np.quantile(forward,.95),np.quantile(backward,.95))),
+            'predicted_points':len(p),'reference_points':len(r),'reference_frame':'shared_selected_level_voxels'}
+
+
+def ink_metrics(probability, labels, threshold=.5, valid=None):
+    import numpy as np
+    from scipy.ndimage import binary_erosion,distance_transform_edt
+    p=np.asarray(probability,dtype='float64');y=np.asarray(labels)
+    if p.shape!=y.shape or p.ndim!=2 or not np.isfinite(p).all() or np.any((p<0)|(p>1)):
+        raise ValueError('probabilités H×W dans [0,1] requises')
+    if not np.isin(y,[0,1]).all():raise ValueError('vérité terrain binaire requise')
+    mask=np.ones(y.shape,dtype=bool) if valid is None else np.asarray(valid,dtype=bool)
+    if mask.shape!=y.shape or not mask.any():raise ValueError('masque de validation vide/invalide')
+    truth=y[mask].astype(bool);pred=p[mask]>=threshold
+    tp=int(np.sum(pred&truth));fp=int(np.sum(pred&~truth));fn=int(np.sum(~pred&truth));tn=int(np.sum(~pred&~truth))
+    ratio=lambda n,d:float(n/d) if d else None
+    calibration=0.
+    for lo in np.linspace(0,.9,10):
+        bin_mask=(p[mask]>=lo)&(p[mask]<(lo+.1) if lo<.89 else p[mask]<=1)
+        if bin_mask.any():calibration+=float(bin_mask.mean()*abs(p[mask][bin_mask].mean()-truth[bin_mask].mean()))
+    target_edge=(y.astype(bool)&~binary_erosion(y.astype(bool)))&mask
+    predicted=(p>=threshold)&mask;pred_edge=predicted&~binary_erosion(predicted)
+    bp=ratio(int((pred_edge&(distance_transform_edt(~target_edge)<=1)).sum()),int(pred_edge.sum())) if target_edge.any() else None
+    br=ratio(int((target_edge&(distance_transform_edt(~pred_edge)<=1)).sum()),int(target_edge.sum())) if pred_edge.any() else None
+    bf=2*bp*br/(bp+br) if bp is not None and br is not None and bp+br else None
+    return {'precision':ratio(tp,tp+fp),'recall':ratio(tp,tp+fn),'dice':ratio(2*tp,2*tp+fp+fn),
+            'iou':ratio(tp,tp+fp+fn),'false_positive_rate':ratio(fp,fp+tn),
+            'brier':float(np.mean((p[mask]-truth)**2)),'ece':calibration,'boundary_f1_1px':bf,
+            'tp':tp,'fp':fp,'fn':fn,'tn':tn,'pixels':int(mask.sum())}
+
+
+def choose_threshold(probability, labels, *, role, minimum_precision=.95, valid=None):
+    if role!='calibration':raise ValueError('seuil réglable sur calibration seulement, jamais sur validation/test')
+    candidates=[]
+    for t in (.1,.2,.3,.4,.5,.6,.7,.8,.9):
+        m=ink_metrics(probability,labels,t,valid)
+        if m['precision'] is not None and m['precision']>=minimum_precision:
+            candidates.append((m['recall'] or 0,t,m))
+    if not candidates:return {'status':'abstain','threshold':None}
+    _,t,m=max(candidates,key=lambda x:(x[0],x[1]))
+    return {'status':'calibrated','threshold':t,'metrics':m}
+
+
+def robustness(volume, infer, labels, threshold=.5, seed=0, valid=None):
+    import numpy as np
+    v=np.asarray(volume,dtype='float32')
+    rng=np.random.default_rng(seed);reports=[]
+    for sigma in (0.,.01,.03):
+        perturbed=np.clip(v+rng.normal(0,sigma,v.shape).astype('float32'),0,1)
+        reports.append({'simulated_sigma':sigma,'metrics':ink_metrics(infer(perturbed),labels,threshold,valid)})
+    return {'seed':seed,'noise_model':'synthetic_additive_gaussian_normalized_intensity',
+            'physical_scanner_noise_validated':False,'reports':reports}
+
+
+def acceptance(report, minimum_precision=.95, minimum_dice=.6, max_false_positive_rate=.01):
+    reasons=[]
+    if report.get('role')!='validation':reasons.append('independent_validation_required')
+    if not report.get('surface_conditioned',False):reasons.append('surface_conditioned_input_required')
+    if not report.get('provided_surface',False):reasons.append('provided_surface_required')
+    if not report.get('geometry_verified',False):reasons.append('unverified_geometry')
+    if not report.get('disjoint',False):reasons.append('dataset_leakage_or_unknown')
+    m=report.get('metrics',{})
+    for key,limit,direction in [('precision',minimum_precision,1),('dice',minimum_dice,1),('false_positive_rate',max_false_positive_rate,-1)]:
+        value=m.get(key)
+        if value is None or not math.isfinite(value) or (value<limit if direction==1 else value>limit):reasons.append(key)
+    if not report.get('negative_control_passed'):reasons.append('negative_control_required')
+    if not report.get('noise_control_passed'):reasons.append('noise_control_required')
+    return {'automatic_gate_passed':not reasons,'reasons':reasons,
+            'legibility_certified':False,'competition_eligibility_certified':False}

src/spatial.py

@@ -0,0 +1,110 @@
+"""Calibration NGFF, validation triangulaire et rendu sans pont à travers les masques."""
+import math
+
+
+def ngff_geometry(attrs, level, declared_voxel_um, base_calibration=None):
+    import numpy as np
+    multiscales=attrs.get('multiscales',[])
+    if not multiscales:
+        return {'verified':False,'source':'user_declared_isotropic','scale_zyx_um':[declared_voxel_um]*3,
+                'translation_zyx_um':[0.,0.,0.],'axes':'zyx'}
+    entry=multiscales[0];axes=entry.get('axes',[])
+    names=[a.get('name') if isinstance(a,dict) else a for a in axes]
+    if names!=['z','y','x']:raise ValueError('axes NGFF non z,y,x : transformation explicite requise')
+    factors=[]
+    for a in axes:
+        unit=a.get('unit') if isinstance(a,dict) else None
+        units={'micrometer':1.,'micrometre':1.,'um':1.,'µm':1.,'nanometer':.001,'millimeter':1000.}
+        if unit is not None and unit not in units:raise ValueError('unité NGFF non prise en charge')
+        factors.append(units.get(unit))
+    dataset=next((d for d in entry.get('datasets',[]) if d.get('path')==str(level)),None)
+    if dataset is None:raise ValueError('niveau absent des métadonnées NGFF')
+    scale=np.ones(3);translation=np.zeros(3)
+    transforms=list(dataset.get('coordinateTransformations',[]))+list(entry.get('coordinateTransformations',[]))
+    for t in transforms:
+        if t.get('type')=='scale':
+            v=np.asarray(t.get('scale'),dtype=float)
+            if v.shape!=(3,) or np.any(v<=0) or not np.isfinite(v).all():raise ValueError('échelle NGFF invalide')
+            scale*=v;translation*=v
+        elif t.get('type')=='translation':
+            v=np.asarray(t.get('translation'),dtype=float)
+            if v.shape!=(3,) or not np.isfinite(v).all():raise ValueError('translation NGFF invalide')
+            translation+=v
+        else:raise ValueError('transformation NGFF non prise en charge')
+    raw_scale=scale.copy();raw_translation=translation.copy()
+    if all(f is None for f in factors):
+        if base_calibration:
+            factors=[float(base_calibration['base_voxel_um'])]*3
+        else:
+            return {'verified':False,'source':'user_declared_with_NGFF_pixel_transform',
+                    'scale_zyx_um':[float(declared_voxel_um)]*3,
+                    'translation_zyx_um':(translation*declared_voxel_um/scale).tolist(),
+                    'raw_scale_zyx':raw_scale.tolist(),'raw_translation_zyx':raw_translation.tolist(),'axes':'zyx'}
+    elif any(f is None for f in factors):raise ValueError('unités NGFF partiellement renseignées')
+    scale*=factors;translation*=factors
+    if not np.allclose(scale,declared_voxel_um,rtol=1e-5,atol=1e-6):
+        raise ValueError('calibration NGFF différente du pas isotrope demandé ; choisir un niveau compatible')
+    return {'verified':True,'source':'curated_catalogue_plus_NGFF' if base_calibration and not any(isinstance(a,dict) and a.get('unit') for a in axes) else 'OME_NGFF','scale_zyx_um':scale.tolist(),
+            'translation_zyx_um':translation.tolist(),'axes':'zyx'}
+
+
+def validate_geometry(xyz,uv,valid=None):
+    import numpy as np
+    xyz=np.asarray(xyz,dtype=float);uv=np.asarray(uv,dtype=float)
+    if xyz.ndim!=3 or xyz.shape[-1]!=3 or uv.shape!=xyz.shape[:2]+(2,):raise ValueError('géométrie H×W invalide')
+    good=np.isfinite(xyz).all(-1)&np.isfinite(uv).all(-1)
+    if valid is not None:good&=np.asarray(valid,dtype=bool)
+    h,w=good.shape;triangles=[]
+    for y in range(h-1):
+        for x in range(w-1):
+            # Même diagonale p10-p01 que les surfaces quad de Villa.
+            a=y*w+x;b=a+1;c=a+w;d=c+1
+            for t in ((a,b,c),(b,d,c)):
+                if good.ravel()[list(t)].all():triangles.append(t)
+    if not triangles:raise ValueError('aucun triangle valide')
+    triangles=np.asarray(triangles);p=xyz.reshape(-1,3)[triangles];q=uv.reshape(-1,2)[triangles]
+    norms=np.cross(p[:,1]-p[:,0],p[:,2]-p[:,0]);areas=np.linalg.norm(norms,axis=1)/2
+    cross=(q[:,1,0]-q[:,0,0])*(q[:,2,1]-q[:,0,1])-(q[:,1,1]-q[:,0,1])*(q[:,2,0]-q[:,0,0])
+    if np.any(areas<=1e-10) or np.any(np.abs(cross)<=1e-10):raise ValueError('triangles dégénérés')
+    if np.any(cross>0) and np.any(cross<0):raise ValueError('triangles retournés dans UV')
+    edges=np.concatenate([triangles[:,[0,1]],triangles[:,[1,2]],triangles[:,[2,0]]])
+    unique,counts=np.unique(np.sort(edges,axis=1),axis=0,return_counts=True)
+    boundary=unique[counts==1];flat=uv.reshape(-1,2)
+    # Un bord auto-intersecté invalide le chart même si les Jacobiennes locales sont positives.
+    def orient(a,b,c):return (b[0]-a[0])*(c[1]-a[1])-(b[1]-a[1])*(c[0]-a[0])
+    for i,(a,b) in enumerate(boundary):
+        for c,d in boundary[i+1:]:
+            if len({int(a),int(b),int(c),int(d)})<4:continue
+            if orient(flat[a],flat[b],flat[c])*orient(flat[a],flat[b],flat[d])<0 and orient(flat[c],flat[d],flat[a])*orient(flat[c],flat[d],flat[b])<0:
+                raise ValueError('bord UV auto-intersecté')
+    length3=np.linalg.norm(xyz.reshape(-1,3)[unique[:,0]]-xyz.reshape(-1,3)[unique[:,1]],axis=1)
+    length2=np.linalg.norm(flat[unique[:,0]]-flat[unique[:,1]],axis=1)
+    if np.any(length3<=1e-10):raise ValueError('arête nulle')
+    stretch=np.abs(length2/length3-1)
+    return {'triangles':int(len(triangles)),'valid_fraction':float(good.mean()),'area':float(areas.sum()),
+            'max_relative_stretch':float(stretch.max()),'p95_relative_stretch':float(np.quantile(stretch,.95)),
+            'rms_relative_stretch':float(np.sqrt(np.mean(stretch**2)))},triangles
+
+
+def rasterize(xyz,uv,values,pixels,valid=None,metric_xyz=None):
+    import numpy as np
+    report,triangles=validate_geometry(xyz if metric_xyz is None else metric_xyz,uv,valid)
+    flat=uv.reshape(-1,2);used=flat[np.unique(triangles)];lo=used.min(0);hi=used.max(0);span=hi-lo
+    spacing=float(span.max()/(int(pixels)-1))
+    if spacing<=0:raise ValueError('chart vide')
+    width=max(2,int(round(span[0]/spacing))+1);height=max(2,int(round(span[1]/spacing))+1)
+    xs=np.linspace(lo[0],hi[0],width);ys=np.linspace(lo[1],hi[1],height)
+    mapped=np.full((height,width,4),np.nan);payload=np.c_[xyz.reshape(-1,3),np.asarray(values).ravel()]
+    for ids in triangles:
+        triangle=flat[ids];a=triangle.min(0);b=triangle.max(0)
+        x0=max(0,int(np.searchsorted(xs,a[0],side='left'))-1);x1=min(width,int(np.searchsorted(xs,b[0],side='right'))+1)
+        y0=max(0,int(np.searchsorted(ys,a[1],side='left'))-1);y1=min(height,int(np.searchsorted(ys,b[1],side='right'))+1)
+        gx,gy=np.meshgrid(xs[x0:x1],ys[y0:y1]);points=np.stack([gx,gy],axis=-1)
+        inverse=np.linalg.inv(np.stack([triangle[1]-triangle[0],triangle[2]-triangle[0]],axis=1))
+        bary=(points-triangle[0])@inverse.T
+        inside=(bary[...,0]>=-1e-9)&(bary[...,1]>=-1e-9)&(bary.sum(-1)<=1+1e-9)
+        weights=np.concatenate([1-bary.sum(-1,keepdims=True),bary],axis=-1)
+        output=weights@payload[ids]
+        block=mapped[y0:y1,x0:x1];block[inside]=output[inside]
+    return mapped,{'bounds':[lo.tolist(),hi.tolist()], 'spacing_uv':[float(span[0]/(width-1)),float(span[1]/(height-1))],
+                   'shape':[height,width],'geometry':report}

src/surface_volume.py

@@ -0,0 +1,36 @@
+"""Échantillonnage 3D le long des normales, masque des contextes hors CT."""
+import json
+import uuid
+
+
+def render(storage,mesh_path,layers=17):
+    import numpy as np
+    from scipy.ndimage import map_coordinates,binary_erosion
+    from .loader import read_chunk
+    path=storage.checked(mesh_path,'meshes')
+    with np.load(path,allow_pickle=False) as f:xyz=f['xyz'];meta=json.loads(str(f['metadata']))
+    if not 3<=int(layers)<=63 or int(layers)%2!=1:raise ValueError('nombre impair de couches de 3 à 63 requis')
+    volume,source=read_chunk(storage,meta['chunk'])
+    if meta.get('source_chunk_sha256') and storage.digest(meta['chunk'],'chunks')!=meta['source_chunk_sha256']:
+        raise ValueError('CT modifié depuis la construction de la surface')
+    scale=np.asarray(source.get('geometry',{}).get('scale_zyx_um',[source['request']['voxel_um']]*3),dtype=float)
+    physical=xyz*scale[::-1]
+    dy,dx=np.gradient(physical,axis=(0,1));normal=np.cross(dx,dy)
+    norm=np.linalg.norm(normal,axis=-1)
+    if np.any(norm<1e-10):raise ValueError('normales de surface dégénérées')
+    normal/=norm[...,None]
+    offsets=np.arange(int(layers))-int(layers)//2
+    positions=xyz[None]+offsets[:,None,None,None]*normal[None]*source['request']['voxel_um']/scale[::-1]
+    local=positions[...,::-1]-np.array(source['request']['origin'])
+    valid=((local>=0)&(local<=np.asarray(volume.shape)-1)).all(-1).all(0)
+    valid=binary_erosion(valid,iterations=3) # exclut le halo d'influence du padding artificiel
+    if not valid.any():raise ValueError('aucun contexte complet : charger une ROI avec davantage de marge')
+    samples=map_coordinates(volume.astype('float32'),local.reshape(-1,3).T,order=1,mode='constant',cval=0)
+    samples=samples.reshape((int(layers),)+xyz.shape[:2]).astype('float32')
+    target=storage.path('chunks',uuid.uuid4().hex+'.surface.npz')
+    metadata={**source,'sample_shape':list(samples.shape),'input_representation':'surface_conditioned',
+              'source_mesh_sha256':storage.digest(path,'meshes'),'surface_kind':meta['surface_kind'],
+              'valid_mask':valid.tolist(),'layer_spacing_um':source['request']['voxel_um'],
+              'layer_offsets':offsets.tolist(),'interpolation_order':1}
+    np.savez_compressed(target,volume=samples,metadata=json.dumps(metadata))
+    return {'path':str(target),'shape':list(samples.shape),'valid_fraction':float(valid.mean())}

src/trainer.py

@@ -23,32 +23,38 @@ def build_model():
     return Hybrid()
 
 
-def train(storage, chunk_path, steps=4, mode='reconstruction', mask_path=None, checkpoint=None, device='cpu'):
+def train(storage, chunk_path, steps=4, mode='reconstruction', mask_path=None, checkpoint=None, device='cpu', cancelled=lambda:False, run_id=None):
     import numpy as np
     import torch
-    from safetensors.torch import load_file,save_file
     from .loader import read_chunk
+    from . import checkpoints
+    from .adaptive import Preempted,CudaBudget
     if mode not in ('reconstruction','ink_supervised') or not 1<=int(steps)<=32:
         raise ValueError('mode ou budget de microcycle invalide')
     volume,metadata=read_chunk(storage,chunk_path)
+    pointer_name='training-run_'+run_id+'.json' if run_id else None
+    source_sha=storage.digest(chunk_path,'chunks')
+    if pointer_name:
+        pointer=storage.path('weights',pointer_name)
+        if pointer.exists():
+            saved=json.loads(pointer.read_text())
+            if saved['source_sha']!=source_sha or saved['mode']!=mode:raise ValueError('reprise d’une autre expérience')
+            checkpoint=saved['checkpoint'];steps=saved['remaining_steps']
+            if steps==0:return {'path':checkpoint,'report':json.loads(storage.checked(checkpoint,'weights').with_suffix('.json').read_text()),'cached':True}
+    from .datasets import register
+    register(storage,metadata['request'],'train')
     torch.set_num_threads(1)
-    with torch.random.fork_rng(devices=[0] if device=='cuda' else []):
-        torch.manual_seed(0)
-        torch.use_deterministic_algorithms(True)
-        if device=='cuda':
-            if not torch.cuda.is_available():raise RuntimeError('CUDA indisponible')
-            if torch.cuda.mem_get_info()[0]<1024**3:raise RuntimeError('moins de 1 Gio de VRAM libre')
-        model=build_model().to(device)
-        history=[];initial='random'
+    with torch.random.fork_rng(devices=[0] if device=='cuda' else []),CudaBudget(device) as budget:
+        torch.manual_seed(0);torch.use_deterministic_algorithms(True)
+        model=build_model().to(device);optimizer=torch.optim.AdamW(model.parameters(),lr=1e-3)
+        history=[];initial='random';global_step=0
         if checkpoint:
-            path=storage.checked(checkpoint,'weights')
-            if path.stat().st_size>16*1024**2:raise ValueError('checkpoint trop volumineux')
-            prior=json.loads(path.with_suffix('.json').read_text())
+            prior=checkpoints.load(storage,checkpoint,model,optimizer,device)
             if prior['mode']!=mode:raise ValueError('objectif du checkpoint incompatible')
-            model.load_state_dict(load_file(str(path),device=device))
-            history=list(prior['training_regions']);initial=str(path)
+            history=list(prior['training_regions']);initial=str(checkpoint);global_step=int(prior.get('global_step',0))
         normalized=volume.astype('float32')
-        lo,hi=np.percentile(normalized,[1,99]);normalized=np.clip((normalized-lo)/max(float(hi-lo),1e-6),0,1).astype("float32")
+        calibration_pixels=normalized[:,np.asarray(metadata['valid_mask'],dtype=bool)] if metadata.get('valid_mask') is not None else normalized
+        lo,hi=np.percentile(calibration_pixels,[1,99]);normalized=np.clip((normalized-lo)/max(float(hi-lo),1e-6),0,1).astype('float32')
         x=torch.from_numpy(normalized[None,None]).to(device)
         if mode=='ink_supervised':
             if not mask_path:raise ValueError('masque d’encre annoté requis pour un objectif supervisé')
@@ -59,52 +65,75 @@ def train(storage, chunk_path, steps=4, mode='reconstruction', mask_path=None, c
                 raise ValueError('masque attendu H×W dans [0,1]')
             target=torch.from_numpy(mask.astype('float32')[None,None]).to(device)
         else:target=x.mean(dim=2)
-        optimizer=torch.optim.AdamW(model.parameters(),lr=1e-3)
         bf16=device=='cuda' and torch.cuda.is_bf16_supported()
-        loss_fn=torch.nn.BCEWithLogitsLoss() if mode=='ink_supervised' else torch.nn.MSELoss()
-        loss_values=[]
-        model.train()
-        for _ in range(int(steps)):
+        loss_fn=torch.nn.BCEWithLogitsLoss(reduction='none') if mode=='ink_supervised' else torch.nn.MSELoss(reduction='none')
+        valid=np.asarray(metadata.get('valid_mask',np.ones(volume.shape[1:],bool)),dtype='float32')
+        if valid.shape!=volume.shape[1:] or valid.sum()==0:raise ValueError('masque d’apprentissage vide')
+        valid_tensor=torch.from_numpy(valid[None,None]).to(device)
+        if metadata['request'] not in history:history.append(metadata['request'])
+        loss_values=[];model.train();last_path=None;result=None
+        def snapshot():
+            report={'mode':mode,'seed':0,'steps':len(loss_values),'global_step':global_step,
+                'loss':list(loss_values),'device':device,'precision':'bf16' if bf16 else 'float32',
+                'initialization':initial,'training_regions':history,'held_out_evaluated':False,
+                'ink_quality_measured':False,'created_at':time.time(),'architecture':'tiny_hybrid_3d_2d_v1','input_representation':metadata.get('input_representation','raw_CT_projection_experimental'),
+                'torch_version':torch.__version__,'numpy_version':np.__version__,
+                'training_chunk_sha256':storage.digest(chunk_path,'chunks'),
+                'normalization':{'low':float(lo),'high':float(hi)}}
+            return checkpoints.save(storage,model,optimizer,report)
+        for index in range(int(steps)):
+            if cancelled():
+                if last_path is None:last_path,result=snapshot()
+                raise Preempted({'checkpoint':last_path,'steps':int(steps)-index})
+            torch.manual_seed(global_step)  # même masque et même AdamW après reprise
             optimizer.zero_grad(set_to_none=True)
-            # Dénoyautage masqué pour la reconstruction ; jamais présenté comme une carte d'encre.
             inp=x*(torch.rand_like(x)>0.15) if mode=='reconstruction' else x
             with torch.autocast(device_type=device,dtype=torch.bfloat16,enabled=bf16):
-                output=model(inp);loss=loss_fn(output,target)
+                output=model(inp);loss=(loss_fn(output,target)*valid_tensor).sum()/valid_tensor.sum()
             if not torch.isfinite(loss):raise RuntimeError('loss non finie')
-            loss.backward();optimizer.step();loss_values.append(float(loss.detach().cpu()))
-        name=uuid.uuid4().hex
-        path=storage.path('weights',name+'.safetensors')
-        save_file({k:v.detach().cpu().contiguous() for k,v in model.state_dict().items()},str(path))
-        history.append(metadata['request'])
-        result={'mode':mode,'seed':0,'steps':int(steps),'loss':loss_values,'device':device,
-                'precision':'bf16' if bf16 else 'float32','initialization':initial,'training_regions':history,
-                'held_out_evaluated':False,'ink_quality_measured':False,'created_at':time.time(),
-                'architecture':'tiny_hybrid_3d_2d_v1','torch_version':torch.__version__,'numpy_version':np.__version__,
-                'training_chunk_sha256':storage.digest(chunk_path,'chunks'),'normalization':{'low':float(lo),'high':float(hi)}}
-        storage.json('weights',name+'.json',result)
-        return {'path':str(path),'report':result}
+            loss.backward();optimizer.step();loss_values.append(float(loss.detach().cpu()));global_step+=1
+            last_path,result=snapshot()
+            if pointer_name:storage.json('weights',pointer_name,{'source_sha':source_sha,'mode':mode,
+                'checkpoint':last_path,'remaining_steps':int(steps)-index-1})
+        return {'path':last_path,'report':result,'performance':budget.report}
 
 
-def predict(storage, chunk_path, checkpoint):
+def predict(storage, chunk_path, checkpoint, device='cpu', tile=64, resume=None, cancelled=lambda:False):
     import numpy as np
     import torch
-    from safetensors.torch import load_file
     from .loader import read_chunk
+    from .checkpoints import load
+    from .adaptive import tiled_predict,CudaBudget
     volume,metadata=read_chunk(storage,chunk_path)
+    torch.set_num_threads(1)
     path=storage.checked(checkpoint,'weights')
-    if path.stat().st_size>16*1024**2:raise ValueError('checkpoint trop volumineux')
-    report=json.loads(path.with_suffix('.json').read_text())
+    model=build_model();report=load(storage,path,model)
+    if report.get('architecture')!='tiny_hybrid_3d_2d_v1':raise ValueError('adaptateur de modèle et halo validés requis')
     if any(overlaps(metadata['request'],region) for region in report['training_regions']):
         raise ValueError('région de prédiction en recouvrement avec un entraînement : refus')
-    model=build_model();model.load_state_dict(load_file(str(path),device='cpu'));model.eval()
     lo,hi=report['normalization']['low'],report['normalization']['high']
-    x=np.clip((volume.astype('float32')-lo)/max(hi-lo,1e-6),0,1).astype("float32")
-    with torch.inference_mode():out=model(torch.from_numpy(x[None,None]))
-    if report['mode']=='ink_supervised':out=out.sigmoid()
-    out=out.squeeze().numpy()
+    x=np.clip((volume.astype('float32')-lo)/max(hi-lo,1e-6),0,1).astype('float32')
+    with CudaBudget(device) as budget:
+        model=model.to(device).eval();bf16=device=='cuda' and torch.cuda.is_bf16_supported()
+        def infer(batch):
+            tensor=torch.from_numpy(batch[:,None])
+            if device=='cuda':tensor=tensor.pin_memory().to(device,non_blocking=True)
+            with torch.inference_mode(),torch.autocast(device_type=device,dtype=torch.bfloat16,enabled=bf16):
+                output=model(tensor)
+                if report['mode']=='ink_supervised':output=output.sigmoid()
+            return output[:,0].float().cpu().numpy()
+        identity={'source':storage.digest(chunk_path,'chunks'),'weights':storage.digest(path,'weights'),
+                  'shape':list(volume.shape),'halo':3,'device':device,'bf16':bf16,'tile':int(tile)}
+        out,tiling=tiled_predict(x,infer,storage,identity,side=int(tile),halo=3,
+            batch=budget.batch_size(volume.shape[0],int(tile)+6),resume=resume,cancelled=cancelled,
+            oom_type=torch.cuda.OutOfMemoryError)
     name=uuid.uuid4().hex
     target=storage.path('chunks',name+'.prediction.npz')
     np.savez_compressed(target,prediction=out,metadata=json.dumps({'request':metadata['request'],
         'checkpoint':str(path),'checkpoint_sha256':storage.digest(path,'weights'),'training':report,
-        'kind':'ink_probability_unvalidated' if report['mode']=='ink_supervised' else 'reconstruction_not_ink'}))
-    return {'path':str(target),'kind':report['mode'],'held_out_evaluated':False}
+        'kind':'ink_probability_unvalidated' if report['mode']=='ink_supervised' else 'reconstruction_not_ink',
+        'performance':budget.report,'tiling':tiling,'geometry':metadata.get('geometry'),'input_representation':metadata.get('input_representation','raw_CT_projection_experimental'),
+        'valid_mask':metadata.get('valid_mask'),'surface_kind':metadata.get('surface_kind'),
+        'source_mesh_sha256':metadata.get('source_mesh_sha256')}))
+    return {'path':str(target),'kind':report['mode'],'held_out_evaluated':False,
+            'performance':budget.report,'tiling':tiling}

src/ui.py

@@ -5,6 +5,9 @@ import importlib.util
 
 def build_tab(controller, authorized):
     import gradio as gr
+    from .autonomous import Supervisor
+    supervisor=Supervisor(controller)
+    controller.supervisor=supervisor
     with gr.Tab('Laboratoire Vesuvius 3D'):
         gr.Markdown('## Vesuvius — laboratoire de recherche\n'
             'Jobs manuels et isolés. Les modèles et les missions UNIQUE restent prioritaires. '
@@ -45,6 +48,8 @@ def build_tab(controller, authorized):
                 unwrap=gr.Button('Construire le chart local')
                 unwrap.click(lambda k,c,s:call('unwrap',{'chunk':c,'surface':s},k),[key,chunk,surface],status)
                 mesh=gr.Textbox(label='Chemin du mesh .npz produit (/data/meshes/vesuvius/...)')
+                sample=gr.Button('Extraire 17 couches le long des normales du mesh')
+                sample.click(lambda k,m:call('surface',{'mesh':m,'layers':17},k),[key,mesh],status)
                 plot=gr.Plot(label='Surface 3D — coordonnées du niveau choisi')
                 preview=gr.Button('Afficher le mesh 3D')
                 def show(secret,path):
@@ -72,7 +77,7 @@ def build_tab(controller, authorized):
                 train.click(lambda k,c,m,ma,cp,s,d:call('train',{'chunk':c,'mode':m,'mask':ma,
                     'checkpoint':cp,'steps':int(s),'device':d},k),[key,chunk,mode,mask,checkpoint,steps,device],status)
                 predict=gr.Button('Prédire une autre ROI, disjointe')
-                predict.click(lambda k,c,cp:call('predict',{'chunk':c,'checkpoint':cp},k),[key,chunk,checkpoint],status)
+                predict.click(lambda k,c,cp,d:call('predict',{'chunk':c,'checkpoint':cp,'device':d},k),[key,chunk,checkpoint,device],status)
             with gr.Tab('Export de recherche'):
                 prediction=gr.Textbox(label='Prédiction .prediction.npz correspondante (facultative ; sinon rendu CT)')
                 pixels=gr.Dropdown([256,512,1024,2048],value=1024,label='Pixels de sortie (rééchantillonnage)')
@@ -82,6 +87,28 @@ def build_tab(controller, authorized):
                 gr.Markdown('Le ZIP reste dans `/data/submissions/vesuvius/`. '
                             'La conformité Grand Prize n’est pas certifiée : colonnes complètes, validation tenue à part '
                             'et vérification VC3D restent nécessaires. Aucun envoi aux organisateurs.')
+            with gr.Tab('Validation et supervision'):
+                gr.Markdown('Les seuils se règlent sur calibration seulement. Les annotations de validation et les contrôles négatifs restent indépendants. Aucun score ne certifie la lisibilité.')
+                labels=gr.Textbox(label='Annotations binaires .npy sous /data/chunks/vesuvius')
+                negative_prediction=gr.Textbox(label='Prédiction d’un contrôle négatif indépendant .npz')
+                negative_labels=gr.Textbox(label='Annotations négatives .npy (absence d’encre documentée)')
+                role=gr.Dropdown(['calibration','validation'],value='validation',label='Rôle verrouillé dans le registre spatial')
+                evaluate=gr.Button('Évaluer Dice, précision, bruit simulé et contrôles')
+                evaluate.click(lambda k,p,l,c,np,nl,r:call('evaluate',{'prediction':p,'labels':l,'chunk':c,
+                    'negative_prediction':np or None,'negative_labels':nl or None,'role':r},k),
+                    [key,prediction,labels,chunk,negative_prediction,negative_labels,role],status)
+                plan=gr.Textbox(label='Plan de supervision JSON sous /data/chunks/vesuvius',
+                                value='/data/chunks/vesuvius/competition-plan.json')
+                continuous=gr.Button('Démarrer la file persistante')
+                supervision=gr.Button('État de la supervision')
+                def control(secret,path):
+                    if not authorized(secret):return {'error':'clé requise'}
+                    try:return {'message':supervisor.start(path),'supervision':supervisor.status()}
+                    except Exception as exc:return {'error':str(exc)}
+                continuous.click(control,[key,plan],status)
+                supervision.click(lambda k:supervisor.status() if authorized(k) else {'error':'clé requise'},key,status)
+                stop_queue=gr.Button('Arrêter la supervision et le job actif')
+                stop_queue.click(lambda k:{'message':supervisor.stop()} if authorized(k) else {'error':'clé requise'},key,status)
         halt=gr.Button('Arrêter le job du laboratoire')
         halt.click(lambda k:{'message':controller.stop()} if authorized(k) else {'error':'clé requise'},key,status)
         timer=gr.Timer(2)

src/unwrapper.py

@@ -55,10 +55,10 @@ def flatten(xyz, iterations=30):
     report={'method':'local_edge_length_least_squares','max_relative_stretch':float(np.max(np.abs(metric))),
             'rms_relative_stretch':float(np.sqrt(np.mean(metric**2))), 'folds':folds,
             'converged':bool(fit.success),'isometry_guaranteed':False,'window':[h,w]}
-    return uv.astype('float32'),report
+    return uv,report
 
 
-def unwrap(storage, chunk_path, surface_path=None):
+def unwrap(storage, chunk_path, surface_path=None, iterations=30):
     import numpy as np
     from .loader import read_chunk
     volume,metadata=read_chunk(storage,chunk_path)
@@ -69,10 +69,16 @@ def unwrap(storage, chunk_path, surface_path=None):
         kind='provided_surface'
     else:
         xyz=candidate_surface(volume,metadata['request']['origin']);kind='unreviewed_gradient_candidate'
-    uv,quality=flatten(xyz)
+    geometry=metadata.get('geometry',{'scale_zyx_um':[metadata['request']['voxel_um']]*3,
+                                      'translation_zyx_um':[0.,0.,0.],'verified':False})
+    physical=xyz.astype('float64')*np.array(geometry['scale_zyx_um'][::-1])+np.array(geometry['translation_zyx_um'][::-1])
+    uv,quality=flatten(physical,iterations=iterations)
+    from .spatial import validate_geometry
+    strict,_=validate_geometry(physical,uv)
+    quality.update(strict)
     if quality['folds']:raise ValueError('pli ou dégénérescence détectée dans le chart')
     artifact=storage.path('meshes',uuid.uuid4().hex+'.npz')
-    np.savez_compressed(artifact,xyz=xyz.astype('float32'),uv=uv,
-                        metadata=json.dumps({'chunk':str(chunk_path),'request':metadata['request'],
-                                             'surface_kind':kind,'quality':quality}))
+    np.savez_compressed(artifact,xyz=xyz.astype('float64'),uv=uv,
+                        metadata=json.dumps({'chunk':str(chunk_path),'source_chunk_sha256':storage.digest(chunk_path,'chunks'),'request':metadata['request'],
+                                             'surface_kind':kind,'quality':quality,'geometry':geometry,'uv_units':'micrometres'}))
     return {'path':str(artifact),'quality':quality,'surface_kind':kind}

src/worker.py

@@ -1,6 +1,7 @@
 """Entrée de calcul séparée du serveur UNIQUE ; requête et résultat sur /data."""
 import json
 import os
+import signal
 from pathlib import Path
 import sys
 import traceback
@@ -8,7 +9,7 @@ import traceback
 from .storage import Storage
 
 
-def execute(storage, action, payload):
+def execute(storage, action, payload, cancelled=lambda:False):
     if action=='load':
         from .loader import Loader
         return Loader(storage).load(payload)
@@ -18,17 +19,24 @@ def execute(storage, action, payload):
         return scan(read_chunk(storage,payload['chunk'])[0],payload.get('tile',16))
     if action=='unwrap':
         from .unwrapper import unwrap
-        return unwrap(storage,payload['chunk'],payload.get('surface') or None)
+        return unwrap(storage,payload['chunk'],payload.get('surface') or None,payload.get('iterations',30))
+    if action=='surface':
+        from .surface_volume import render
+        return render(storage,payload['mesh'],payload.get('layers',17))
     if action=='train':
         from .trainer import train
         return train(storage,payload['chunk'],payload.get('steps',4),payload.get('mode','reconstruction'),
-                     payload.get('mask') or None,payload.get('checkpoint') or None,payload.get('device','cpu'))
+                     payload.get('mask') or None,payload.get('checkpoint') or None,payload.get('device','cpu'),cancelled=cancelled,run_id=payload.get('_queue_id'))
     if action=='predict':
         from .trainer import predict
-        return predict(storage,payload['chunk'],payload['checkpoint'])
+        return predict(storage,payload['chunk'],payload['checkpoint'],payload.get('device','cpu'),
+                       payload.get('tile',64),payload.get('resume'),cancelled=cancelled)
+    if action=='evaluate':
+        from .evaluation import evaluate
+        return evaluate(storage,**{k:v for k,v in payload.items() if not k.startswith('_')})
     if action=='export':
         from .exporter import export
-        return export(storage,payload['mesh'],payload.get('prediction') or None,payload.get('pixels',1024))
+        return export(storage,payload['mesh'],payload.get('prediction') or None,payload.get('pixels',1024),payload.get('validation_report'))
     raise ValueError('action inconnue')
 
 
@@ -37,11 +45,19 @@ def main():
     storage.initialize()
     request=storage.checked(sys.argv[1],'chunks')
     data=json.loads(request.read_text())
+    flag=[False]
+    signal.signal(signal.SIGTERM,lambda *args:flag.__setitem__(0,True))
+    cancelled=lambda:flag[0] or request.with_suffix('.cancel').exists()
     try:
         if hasattr(os,'nice'):os.nice(10)
-        result={'ok':True,'result':execute(storage,data['action'],data['payload'])}
+        result={'ok':True,'result':execute(storage,data['action'],data['payload'],cancelled)}
     except Exception as exc:
-        result={'ok':False,'error':type(exc).__name__+': '+str(exc)[:1000]}
+        message=type(exc).__name__+': '+str(exc)[:1000]
+        lowered=message.lower()
+        code=('preempted' if type(exc).__name__=='Preempted' else 'oom' if 'outofmemory' in lowered or 'oom' in lowered
+              else 'network' if 's3' in lowered or 'connect' in lowered else 'geometry' if any(w in lowered for w in ('triangle','chart','distorsion','pli'))
+              else 'unknown')
+        result={'ok':False,'error':message,'code':code,'resume':getattr(exc,'resume',None)}
         traceback.print_exc()
     storage.json('chunks',request.stem+'.result.json',result)
     return 0 if result['ok'] else 1

tests/test_competition.py

@@ -0,0 +1,315 @@
+import json
+import math
+from pathlib import Path
+import time
+
+import numpy as np
+import pytest
+
+from test_vesuvius import storage,chunk,spec
+from src.adaptive import tiled_predict,Preempted
+
+
+def test_tiling_matches_full_model_with_halo(storage):
+    import torch
+    from src.trainer import build_model
+    torch.manual_seed(0);torch.set_num_threads(1);model=build_model().eval()
+    volume=np.random.default_rng(2).random((8,48,48),dtype='float32')
+    def infer(batch):
+        with torch.inference_mode():return model(torch.from_numpy(batch[:,None]))[:,0].numpy()
+    full=infer(volume[None])[0]
+    tiles,report=tiled_predict(volume,infer,storage,{'test':'halo'},side=16,batch=4)
+    np.testing.assert_allclose(tiles,full,atol=1e-6)
+    assert report['committed']==9
+
+
+def test_oom_reduces_batches_then_subdivides_tiles(storage):
+    volume=np.ones((4,40,40),dtype='float32')
+    class FakeOOM(Exception):pass
+    def infer(batch):
+        if batch.shape[0]>1 or max(batch.shape[-2:])>22:raise FakeOOM()
+        return batch.mean(1)
+    result,report=tiled_predict(volume,infer,storage,{'test':'oom'},side=32,batch=4,oom_type=FakeOOM)
+    assert np.all(result==1) and report['oom_retries']>0
+
+
+def test_tile_checkpoint_resumes_without_repeating_committed_work(storage):
+    volume=np.ones((4,32,32),dtype='float32');calls=[]
+    def infer(batch):calls.append(1);return batch.mean(1)
+    with pytest.raises(Preempted) as exc:
+        tiled_predict(volume,infer,storage,{'test':'resume'},side=16,cancelled=lambda:len(calls)==1)
+    assert len(calls)==1
+    output,state=tiled_predict(volume,infer,storage,{'test':'resume'},side=16,resume=exc.value.resume)
+    assert len(calls)==4 and np.all(output==1) and state['committed']==4
+
+
+def test_optimizer_resume_matches_uninterrupted_training(storage):
+    from src.trainer import train
+    from safetensors.numpy import load_file
+    path=chunk(storage);full=train(storage,path,steps=4)
+    checks=[0]
+    def cancelled():checks[0]+=1;return checks[0]>2
+    with pytest.raises(Preempted) as exc:train(storage,path,steps=4,cancelled=cancelled)
+    resumed=train(storage,path,**exc.value.resume)
+    assert resumed['report']['global_step']==4
+    for key,value in load_file(full['path']).items():
+        np.testing.assert_array_equal(value,load_file(resumed['path'])[key])
+
+
+def test_ngff_axes_units_and_translations_are_preserved():
+    from src.spatial import ngff_geometry
+    attrs={'multiscales':[{'axes':[{'name':a,'unit':'nanometer'} for a in 'zyx'],
+        'datasets':[{'path':'0','coordinateTransformations':[{'type':'scale','scale':[2400]*3},
+                      {'type':'translation','translation':[1000,2000,3000]}]}]}]}
+    g=ngff_geometry(attrs,'0',2.4)
+    assert g['verified'] and g['scale_zyx_um']==[2.4]*3 and g['translation_zyx_um']==[1,2,3]
+    with pytest.raises(ValueError,match='calibration'):ngff_geometry(attrs,'0',7.91)
+    attrs['multiscales'][0]['axes'][0]['name']='x'
+    with pytest.raises(ValueError,match='axes'):ngff_geometry(attrs,'0',2.4)
+
+
+def test_unverified_calibration_is_explicit():
+    from src.spatial import ngff_geometry
+    assert not ngff_geometry({},'0',2.4)['verified']
+
+
+def test_second_triangle_fold_is_rejected():
+    from src.spatial import validate_geometry
+    y,x=np.indices((2,2));xyz=np.stack([x,y,np.zeros_like(x)],-1)
+    uv=np.stack([x,y],-1).astype(float);uv[1,1]=[-1,-1]
+    with pytest.raises(ValueError,match='retournés'):validate_geometry(xyz,uv)
+
+
+def test_raster_does_not_bridge_mask_holes_and_respects_aspect_ratio():
+    from src.spatial import rasterize
+    y,x=np.indices((5,7));xyz=np.stack([x,y,np.zeros_like(x)],-1).astype(float)
+    uv=xyz[...,:2];valid=np.ones((5,7),bool);valid[2,3]=False
+    image,report=rasterize(xyz,uv,x,64,valid)
+    assert report['shape'][1]==64 and report['shape'][0]<64
+    assert np.isnan(image[report['shape'][0]//2,32]).all()
+
+
+def test_metrics_include_false_positives_and_do_not_reward_empty_labels():
+    from src.quality import ink_metrics
+    y=np.array([[1,0],[1,0]]);p=np.array([[.9,.8],[.1,.1]])
+    m=ink_metrics(p,y)
+    assert m['tp']==1 and m['fp']==1 and m['fn']==1
+    assert m['precision']==.5 and m['dice']==.5 and m['false_positive_rate']==.5
+    empty=ink_metrics(np.zeros((4,4)),np.zeros((4,4)))
+    assert empty['precision'] is None and empty['dice'] is None
+
+
+@pytest.mark.parametrize('role',['validation','test','train'])
+def test_threshold_cannot_be_optimized_on_held_out_data(role):
+    from src.quality import choose_threshold
+    with pytest.raises(ValueError):choose_threshold(np.zeros((2,2)),np.zeros((2,2)),role=role)
+
+
+def test_scientific_acceptance_requires_independent_controls():
+    from src.quality import acceptance
+    report={'role':'validation','surface_conditioned':True,'provided_surface':True,'geometry_verified':True,'disjoint':True,'metrics':{'precision':1.,'dice':.9,'false_positive_rate':0.}}
+    assert not acceptance(report)['automatic_gate_passed']
+    report.update(negative_control_passed=True,noise_control_passed=True)
+    assert acceptance(report)['automatic_gate_passed']
+    assert not acceptance(report)['legibility_certified']
+
+
+def test_noise_benchmark_is_seeded_and_marked_as_synthetic():
+    from src.quality import robustness
+    v=np.zeros((4,4,4),dtype='float32');labels=np.zeros((4,4))
+    a=robustness(v,lambda x:np.clip(x.mean(0),0,1),labels)
+    b=robustness(v,lambda x:np.clip(x.mean(0),0,1),labels)
+    assert a==b and not a['physical_scanner_noise_validated']
+
+
+def test_dataset_split_leakage_is_rejected(storage):
+    from src.datasets import register
+    register(storage,spec(),'train')
+    with pytest.raises(ValueError,match='recouvrement'):register(storage,spec(),'validation')
+    register(storage,spec(origin=(8,0,0)),'validation')
+
+
+def test_queue_idempotency_and_bounded_network_retries(storage):
+    from src.autonomous import Queue
+    queue=Queue(storage);task={'action':'scan','payload':{'chunk':'fixed'}}
+    assert queue.enqueue([task])==queue.enqueue([task]) and len(queue.records())==1
+    record=queue.records()[0];record['attempts']=1
+    queue.finish(record,{'status':'error','code':'network','error':'offline'},now=100)
+    assert record['state']=='queued' and record['due']==130
+    record['attempts']=5
+    queue.finish(record,{'status':'error','code':'network','error':'offline'},now=200)
+    assert record['state']=='quarantined'
+
+
+def test_queue_recovers_running_jobs_and_preserves_resume_payload(storage):
+    from src.autonomous import Queue
+    queue=Queue(storage);queue.enqueue([{'action':'train','payload':{'chunk':'fixed','steps':4}}])
+    record=queue.records()[0];record.update(state='running',attempts=1);queue.save(record);queue.recover()
+    assert queue.records()[0]['state']=='queued'
+    queue.finish(record,{'status':'error','code':'preempted','resume':{'checkpoint':'fixed','steps':2}},now=100)
+    assert record['task']['payload']['steps']==2 and record['state']=='queued'
+
+
+def test_named_plan_dependencies_and_cycles(storage):
+    from src.autonomous import Queue
+    queue=Queue(storage)
+    ids=queue.enqueue([{'name':'load','action':'load','payload':{}},
+                       {'name':'scan','action':'scan','payload':{'chunk':'@load'}}])
+    records={r['id']:r for r in queue.records()};records[ids[0]].update(state='done',result={'path':'real.npz'})
+    assert queue.resolve(records[ids[1]]['task'],records)['chunk']=='real.npz'
+    with pytest.raises(ValueError,match='cycle'):
+        queue.enqueue([{'name':'a','action':'scan','payload':{'chunk':'@b'}},
+                       {'name':'b','action':'scan','payload':{'chunk':'@a'}}])
+
+
+def test_failed_quality_is_quarantined_not_relabelled(storage):
+    from src.autonomous import Queue
+    q=Queue(storage);q.enqueue([{'action':'evaluate','payload':{'labels':'immutable.npy'}}]);r=q.records()[0]
+    q.finish(r,{'status':'done','result':{'report':{'acceptance':{'automatic_gate_passed':False}}}})
+    assert r['state']=='quarantined' and r['task']['payload']['labels']=='immutable.npy'
+
+
+def test_hard_restart_finds_committed_tile_checkpoint(storage):
+    calls=[]
+    def infer(x):calls.append(1);return x.mean(1)
+    volume=np.ones((4,32,32),dtype='float32')
+    with pytest.raises(Preempted):
+        tiled_predict(volume,infer,storage,{'hard':'restart'},side=16,cancelled=lambda:len(calls)==1)
+    tiled_predict(volume,infer,storage,{'hard':'restart'},side=16)
+    assert len(calls)==4
+
+
+def test_hard_restart_training_recovers_run_pointer(storage):
+    from src.trainer import train
+    path=chunk(storage);checks=[0]
+    def cancel():checks[0]+=1;return checks[0]>1
+    with pytest.raises(Preempted):train(storage,path,steps=3,run_id='fixed',cancelled=cancel)
+    resumed=train(storage,path,steps=3,run_id='fixed')
+    assert resumed['report']['global_step']==3
+    cached=train(storage,path,steps=3,run_id='fixed')
+    assert cached['cached'] and cached['path']==resumed['path']
+
+
+def test_frozen_input_mutation_is_rejected(storage):
+    from src.autonomous import Queue
+    q=Queue(storage);source=storage.path('chunks','fixed.npy');np.save(source,np.ones((4,4)))
+    q.enqueue([{'action':'evaluate','payload':{'labels':str(source)}}]);record=q.records()[0]
+    q.freeze_inputs(record,record['task']['payload'])
+    np.save(source,np.zeros((4,4)))
+    with pytest.raises(ValueError,match='modifiée'):q.freeze_inputs(record,record['task']['payload'])
+
+
+def test_geometry_refinement_is_bounded_and_does_not_relax_thresholds(storage):
+    from src.autonomous import Queue
+    q=Queue(storage);q.enqueue([{'action':'unwrap','payload':{'chunk':'fixed','iterations':30}}]);r=q.records()[0]
+    r['attempts']=1;q.finish(r,{'status':'error','code':'geometry'},now=100)
+    assert r['state']=='queued' and r['task']['payload']['iterations']==60
+    r['attempts']=2;q.finish(r,{'status':'error','code':'geometry'},now=200)
+    assert r['state']=='quarantined'
+
+
+def test_bad_dependency_is_rejected_instead_of_waiting_forever(storage):
+    from src.autonomous import Queue
+    q=Queue(storage)
+    with pytest.raises(ValueError,match='inconnue'):
+        q.enqueue([{'action':'scan','payload':{'chunk':'@missing'}}])
+
+
+def test_quarantined_dependency_blocks_downstream_tasks(storage):
+    from src.autonomous import Queue
+    q=Queue(storage);ids=q.enqueue([{'name':'a','action':'scan','payload':{}},
+                                  {'name':'b','action':'scan','payload':{'chunk':'@a'}}])
+    records={r['id']:r for r in q.records()};records[ids[0]]['state']='quarantined'
+    with pytest.raises(ValueError,match='quarantaine'):q.resolve(records[ids[1]]['task'],records)
+
+
+def test_surface_conditioning_preserves_normals_and_masks_invalid_contexts(storage):
+    from src.loader import Loader,request_spec,read_chunk
+    from src.unwrapper import unwrap
+    from src.surface_volume import render
+    import zarr
+    z,y,x=np.indices((24,24,24));array=zarr.array(z.astype('float32'),chunks=(8,8,8))
+    request=request_spec('s3://vesuvius-challenge-open-data/surface.zarr','0',[0,0,0],[24,24,24],2.4)
+    source=Loader(storage,opener=lambda s:array).load(request)['path']
+    yy,xx=np.indices((12,12),dtype=float)
+    points=np.stack([xx+6,yy+6,np.ones_like(xx)*12],axis=-1)
+    path=storage.path('meshes','reviewable.npy');np.save(path,points)
+    mesh=unwrap(storage,source,str(path));result=render(storage,mesh['path'],layers=7)
+    volume,metadata=read_chunk(storage,result['path'])
+    assert volume.shape==(7,12,12) and metadata['input_representation']=='surface_conditioned'
+    np.testing.assert_allclose(volume[:,6,6],np.arange(9,16))
+    assert np.asarray(metadata['valid_mask']).sum()==36
+
+
+def test_calibrated_public_ngff_without_units_requires_explicit_catalogue():
+    from src.spatial import ngff_geometry
+    attrs={'multiscales':[{'axes':[{'name':a} for a in 'zyx'],
+        'datasets':[{'path':'2','coordinateTransformations':[{'type':'scale','scale':[4,4,4]}]}]}]}
+    assert not ngff_geometry(attrs,'2',9.6)['verified']
+    verified=ngff_geometry(attrs,'2',9.6,{'base_voxel_um':2.4})
+    assert verified['verified'] and verified['scale_zyx_um']==[9.6]*3
+
+
+def test_supervised_plan_has_disjoint_named_dependencies(storage):
+    from src.plan import build
+    from src.autonomous import Queue
+    regions={}
+    for index,role in enumerate(('train','calibration','validation','negative')):
+        points=storage.path('meshes',role+'.npy');labels=storage.path('chunks',role+'.npy')
+        yy,xx=np.indices((8,8),dtype=float)
+        np.save(points,np.stack([xx,yy,np.ones_like(xx)*3],-1));np.save(labels,np.zeros((8,8)))
+        regions[role]={'roi':spec(origin=(index*8,0,0)),'surface_xyz':str(points),'labels':str(labels)}
+    plan=build(storage,regions,device='cpu',steps=1)
+    assert not plan['official_submission_authorized']
+    assert len(Queue(storage).enqueue(plan['tasks']))==19
+    regions['validation']['roi']=regions['train']['roi']
+    with pytest.raises(ValueError,match='disjointes'):build(storage,regions)
+
+
+def test_end_to_end_research_dag_abstains_instead_of_exporting_bad_ink(storage,monkeypatch):
+    import zarr
+    from src.loader import Loader,request_spec
+    from src.plan import build
+    from src.autonomous import Queue
+    from src.worker import execute
+    zz,yy,xx=np.indices((128,32,32));array=zarr.array((zz+yy+xx).astype('uint8'),chunks=(16,16,16))
+    monkeypatch.setattr(Loader,'open_array',staticmethod(lambda s:array))
+    regions={}
+    for index,role in enumerate(('train','calibration','validation','negative')):
+        y,x=np.indices((12,12),dtype=float)
+        xyz=storage.path('meshes',role+'.npy');labels=storage.path('chunks',role+'.npy')
+        np.save(xyz,np.stack([x+10,y+10,np.ones_like(x)*(index*32+16)],-1))
+        np.save(labels,np.zeros((12,12)))
+        roi=request_spec('s3://vesuvius-challenge-open-data/dag.zarr','0',[index*32,0,0],[32,32,32],2.4)
+        regions[role]={'roi':roi,'surface_xyz':str(xyz),'labels':str(labels)}
+    q=Queue(storage);q.enqueue(build(storage,regions,'cpu',1)['tasks'])
+    for _ in range(24):
+        records={r['id']:r for r in q.records()};progress=False
+        for record in records.values():
+            if record['state']!='queued':continue
+            try:payload=q.resolve(record['task'],records)
+            except LookupError:continue
+            except ValueError:
+                record['state']='quarantined';q.save(record);progress=True;continue
+            try:
+                result=execute(storage,record['task']['action'],payload)
+                q.finish(record,{'status':'done','result':result})
+            except ValueError as exc:
+                q.finish(record,{'status':'error','code':'invalid','error':str(exc)})
+            progress=True
+        if not progress:break
+    records=q.records()
+    calibration=next(r for r in records if r['task'].get('name')=='calibrate')
+    assert calibration['state']=='quarantined' and calibration['result']['report']['status']=='abstain'
+    assert next(r for r in records if r['task'].get('name')=='research_export')['state']=='quarantined'
+    assert not list(storage.folder('submissions').glob('*.zip'))
+
+
+def test_surface_accuracy_requires_reference_and_respects_physical_scale():
+    from src.quality import surface_metrics
+    y,x=np.indices((4,4));reference=np.stack([x,y,np.zeros_like(x)],-1).astype(float)
+    predicted=reference.copy();predicted[...,2]+=1
+    report=surface_metrics(predicted,reference,(2.4,2.4,2.4))
+    assert report['chamfer_mean_um']==pytest.approx(2.4)
+    assert report['hausdorff_max_um']==pytest.approx(2.4)
+    with pytest.raises(ValueError):surface_metrics(np.empty((0,3)),reference)

unique_ext/__init__.py

@@ -13,7 +13,7 @@ from __future__ import annotations
 import os
 
 API_VERSION = 1          # contrat entre le job d'entraînement et ce paquet : le job refuse une autre valeur
-__version__ = "4.14.0"
+__version__ = "4.15.0"
 
 
 def enabled(name: str) -> bool: