Calibrer les durees ZeroGPU sur des mesures reelles et exposer le telechargement des modeles

Le duration= des decorateurs @spaces.GPU etait un plafond fixe (300s) quel
que soit l'entrainement demande, alors que ZeroGPU reserve la duree
declaree (pas le temps reellement mesure) sur le quota journalier de la
personne qui clique, pas sur celui du proprietaire du Space. Pour un
compte gratuit (300s/jour), un seul entrainement MLP ou CNN epuisait donc
tout le quota du jour.

MLP et CNN utilisent maintenant une duree dynamique calibree sur des
mesures reelles (66.6s / 140.8s pour le MLP, 65.3s / 153.9s pour le CNN
selon les hyperparametres), plafonnee a 180s pour rester nettement sous
le quota journalier gratuit. Les curseurs d'architecture les plus extremes
(hidden_dim=1024, 5 couches/blocs, filtres=128) sont retires de l'UI :
les mesures montrent que le nombre de parametres surestime tres largement
le cout reel sur ce jeu de donnees minuscule, dont le temps est domine par
un overhead fixe plutot que par les FLOPs du modele.

Ajout d'un composant de telechargement (poids .pt ou pipeline .joblib)
pour le modele selectionne dans l'onglet 5, absent jusqu'ici alors que
c'etait la seule facon de recuperer un modele entraine hors du Space.

app.py

@@ -11,6 +11,7 @@ from train_utils import (
     evaluate_saved_model,
     list_saved_models,
     model_meta_path,
+    saved_model_file_path,
     train_cnn,
     train_mlp,
 )
@@ -39,7 +40,27 @@ def refresh_gallery_callback(split_name, class_name, max_images):
 # Tab 2 — MLP (baseline)
 # ---------------------------------------------------------------------------
 
-@spaces.GPU(duration=300)
+def mlp_gpu_duration(
+    num_layers, hidden_dim, dropout,
+    learning_rate, weight_decay, batch_size, epochs,
+    model_tag,
+    request: gr.Request,
+):
+    # Calibré sur deux exécutions réelles :
+    #   2 couches, hidden_dim=256,  epochs=30 -> 66.6s  (2.22 s/époque)
+    #   5 couches, hidden_dim=1024, epochs=50 -> 140.8s (2.82 s/époque)
+    # Le jeu de données est minuscule (peu de pas par époque) : le temps est
+    # dominé par un overhead fixe, hidden_dim ne le fait varier que doucement
+    # (x4 sur hidden_dim -> seulement +27% par époque). On plafonne à 180s :
+    # nettement sous le quota journalier d'un compte gratuit (300s), pour
+    # qu'un seul entraînement au pire réglage ne consomme pas tout le quota
+    # du jour d'un·e étudiant·e.
+    per_epoch = 2.22 + 0.0008 * max(0, int(hidden_dim) - 256)
+    estimated = 15 + per_epoch * int(epochs)
+    return min(180, max(45, int(estimated * 1.4)))
+
+
+@spaces.GPU(duration=mlp_gpu_duration)
 def train_mlp_callback(
     num_layers, hidden_dim, dropout,
     learning_rate, weight_decay, batch_size, epochs,
@@ -79,7 +100,31 @@ def train_mlp_callback(
 # Tab 3 — SimpleCNN
 # ---------------------------------------------------------------------------
 
-@spaces.GPU(duration=300)
+def cnn_gpu_duration(
+    num_conv_blocks, base_filters, kernel_size, use_batchnorm,
+    dropout, fc_dim,
+    learning_rate, weight_decay, batch_size, epochs,
+    model_tag,
+    request: gr.Request,
+):
+    # Calibré sur deux exécutions réelles :
+    #   3 blocs, filtres=32,  noyau=3, epochs=30 -> 65.3s  (2.18 s/époque)
+    #   5 blocs, filtres=128, noyau=5, epochs=50 -> 153.9s (3.08 s/époque)
+    # Le nombre de paramètres varie de ~130x entre ces deux essais mais le temps
+    # par époque seulement de 40% : sur ce jeu de données minuscule, le coût est
+    # dominé par un overhead fixe (chargement/augmentation), pas par les FLOPs
+    # du réseau — le nombre de paramètres surestimerait donc très largement.
+    # On interpole plutôt sur un score d'architecture simple. Plafond 180s :
+    # nettement sous le quota journalier d'un compte gratuit (300s).
+    score = int(num_conv_blocks) * int(base_filters) * (int(kernel_size) / 3)
+    baseline_score, worst_score = 96.0, 1066.7
+    frac = max(0.0, min(1.0, (score - baseline_score) / (worst_score - baseline_score)))
+    per_epoch = 2.18 + 0.9 * frac
+    estimated = 15 + per_epoch * int(epochs)
+    return min(180, max(45, int(estimated * 1.4)))
+
+
+@spaces.GPU(duration=cnn_gpu_duration)
 def train_cnn_callback(
     num_conv_blocks, base_filters, kernel_size, use_batchnorm,
     dropout, fc_dim,
@@ -207,6 +252,15 @@ def get_model_info_callback(model_name, request: gr.Request):
         return {"message": "Métadonnées introuvables."}
 
 
+def download_model_callback(model_name, request: gr.Request):
+    if not model_name:
+        return gr.update(value=None, visible=False)
+    try:
+        return gr.update(value=saved_model_file_path(model_name, request.session_hash), visible=True)
+    except FileNotFoundError:
+        return gr.update(value=None, visible=False)
+
+
 @spaces.GPU(duration=120)
 def evaluate_callback(model_name, request: gr.Request):
     try:
@@ -309,11 +363,11 @@ with gr.Blocks(title="Classification d'images microscopiques") as demo:
                 with gr.Column():
                     gr.Markdown("#### Architecture du MLP")
                     mlp_num_layers = gr.Slider(
-                        minimum=1, maximum=5, value=2, step=1,
+                        minimum=1, maximum=4, value=2, step=1,
                         label="Nombre de couches cachées",
                     )
                     mlp_hidden_dim = gr.Dropdown(
-                        choices=[64, 128, 256, 512, 1024], value=256,
+                        choices=[64, 128, 256, 512], value=256,
                         label="Neurones par couche cachée",
                     )
 
@@ -370,12 +424,12 @@ with gr.Blocks(title="Classification d'images microscopiques") as demo:
                 with gr.Column():
                     gr.Markdown("#### Architecture du CNN")
                     num_conv_blocks = gr.Slider(
-                        minimum=2, maximum=5, value=3, step=1,
+                        minimum=2, maximum=4, value=3, step=1,
                         label="Blocs convolutionnels",
                         info="Chaque bloc enchaîne Conv2d → BatchNorm → ReLU → MaxPool. Plus de blocs = réseau plus profond.",
                     )
                     base_filters = gr.Dropdown(
-                        choices=[16, 32, 64, 128], value=32,
+                        choices=[16, 32, 64], value=32,
                         label="Filtres du premier bloc",
                         info="Le nombre de filtres double à chaque bloc. 32 → 64 → 128...",
                     )
@@ -546,6 +600,7 @@ with gr.Blocks(title="Classification d'images microscopiques") as demo:
                     refresh_btn = gr.Button("Actualiser la liste")
                     load_info_btn = gr.Button("Afficher les informations du modèle")
                     model_info = gr.JSON(label="Métadonnées du modèle")
+                    model_download = gr.File(label="Télécharger le modèle sélectionné", visible=False)
 
                 with gr.Column():
                     evaluate_btn = gr.Button("Évaluer sur le jeu de test", variant="primary")
@@ -652,6 +707,10 @@ with gr.Blocks(title="Classification d'images microscopiques") as demo:
         fn=get_model_info_callback, inputs=model_selector, outputs=model_info
     )
 
+    model_selector.change(
+        fn=download_model_callback, inputs=model_selector, outputs=model_download
+    )
+
     evaluate_btn.click(
         fn=evaluate_callback,
         inputs=model_selector,

train_utils.py

@@ -8,6 +8,7 @@ import torch
 import torch.nn as nn
 import torch.optim as optim
 
+from classical_ml_utils import classifier_path
 from config import DATASET_DISPLAY_NAME, CLASSICAL_MODEL_TYPES, IMAGE_SIZE, session_model_dir, session_meta_dir
 from data_utils import make_loaders
 from metrics_utils import compute_classification_metrics, save_confusion_matrix_figure, save_loss_curve_figure
@@ -41,6 +42,16 @@ def get_runtime_device() -> torch.device:
     return torch.device("cuda" if torch.cuda.is_available() else "cpu")
 
 
+def saved_model_file_path(model_name: str, session_id: str) -> str:
+    """Chemin du fichier de poids téléchargeable — .joblib pour les
+    classifieurs ML classiques, .pt pour les modèles neuronaux."""
+    with open(model_meta_path(model_name, session_id), "r", encoding="utf-8") as f:
+        model_type = json.load(f)["config"]["model_type"]
+    if model_type in CLASSICAL_MODEL_TYPES:
+        return classifier_path(model_name, session_id)
+    return model_weight_path(model_name, session_id)
+
+
 # ---------------------------------------------------------------------------
 # Save / load
 # ---------------------------------------------------------------------------