Retirer ZeroGPU : le Space passe en CPU

Le quota GPU journalier par visiteur (2 a 5 min selon le compte) restait
un probleme structurel pour l'usage en classe, meme apres avoir calibre
les durees demandees sur des mesures reelles. Les mesures elles-memes
montraient que le temps d'entrainement sur ce jeu de donnees minuscule
est domine par un overhead fixe (chargement, tiny batches) plutot que
par le calcul GPU : multiplier les parametres du CNN par ~128x n'avait
fait varier le temps par epoque que de ~40%. Le CPU ne devrait donc pas
etre dramatiquement plus lent, et supprime completement le systeme de
quota par utilisateur.

Suppression des decorateurs @spaces.GPU et des fonctions de duree
dynamique associees (devenues inutiles), et de la dependance spaces.
Le changement de materiel du Space (ZeroGPU -> CPU basic) se fait cote
Settings HF, pas dans ce commit.

app.py

@@ -1,7 +1,6 @@
 import json
 
 import gradio as gr
-import spaces
 
 from backbone_utils import extract_all_features, get_cached_features
 from classical_ml_utils import train_classical_model
@@ -40,27 +39,6 @@ def refresh_gallery_callback(split_name, class_name, max_images):
 # Tab 2 — MLP (baseline)
 # ---------------------------------------------------------------------------
 
-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,
@@ -100,31 +78,6 @@ def train_mlp_callback(
 # Tab 3 — SimpleCNN
 # ---------------------------------------------------------------------------
 
-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,
@@ -168,7 +121,6 @@ def train_cnn_callback(
 # Tab 4 — Backbone + ML classique
 # ---------------------------------------------------------------------------
 
-@spaces.GPU(duration=60)
 def extract_features_callback():
     try:
         _, class_names, counts = extract_all_features()
@@ -254,14 +206,13 @@ def get_model_info_callback(model_name, request: gr.Request):
 
 def download_model_callback(model_name, request: gr.Request):
     if not model_name:
-        return gr.update(value=None, visible=False)
+        return None
     try:
-        return gr.update(value=saved_model_file_path(model_name, request.session_hash), visible=True)
+        return saved_model_file_path(model_name, request.session_hash)
     except FileNotFoundError:
-        return gr.update(value=None, visible=False)
+        return None
 
 
-@spaces.GPU(duration=120)
 def evaluate_callback(model_name, request: gr.Request):
     try:
         summary, report_df, cm_df, cm_path = evaluate_saved_model(model_name, request.session_hash)
@@ -270,7 +221,6 @@ def evaluate_callback(model_name, request: gr.Request):
         return {"Erreur": str(e)}, None, None, None
 
 
-@spaces.GPU(duration=60)
 def predict_callback(model_name, image, request: gr.Request):
     try:
         return predict_uploaded_image(model_name, image, request.session_hash)
@@ -278,7 +228,6 @@ def predict_callback(model_name, image, request: gr.Request):
         return f"Échec :\n{e}", None
 
 
-@spaces.GPU(duration=60)
 def random_test_callback(model_name, request: gr.Request):
     try:
         return test_random_sample(model_name, request.session_hash)
@@ -600,7 +549,11 @@ 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)
+                    download_btn = gr.Button("Préparer le fichier à télécharger")
+                    model_download = gr.File(
+                        label="Fichier du modèle (poids .pt ou pipeline .joblib) — cliquez sur "
+                        "« Préparer le fichier à télécharger » puis sur la flèche de téléchargement ci-dessous",
+                    )
 
                 with gr.Column():
                     evaluate_btn = gr.Button("Évaluer sur le jeu de test", variant="primary")
@@ -711,6 +664,10 @@ with gr.Blocks(title="Classification d'images microscopiques") as demo:
         fn=download_model_callback, inputs=model_selector, outputs=model_download
     )
 
+    download_btn.click(
+        fn=download_model_callback, inputs=model_selector, outputs=model_download
+    )
+
     evaluate_btn.click(
         fn=evaluate_callback,
         inputs=model_selector,

requirements.txt

@@ -2,7 +2,6 @@ torchvision
 datasets
 huggingface_hub
 pillow
-spaces
 scikit-learn
 pandas
 matplotlib