Revenir a ZeroGPU pour toutes les fonctions : le mode hybride plante

Tentative de garder seulement train_cnn_callback sur @spaces.GPU et de
forcer torch.device("cpu") ailleurs (MLP, evaluation, prediction,
extraction de features) pour eviter de toucher au quota GPU sur ces
chemins. Ca plante en production : import spaces monkey-patche torch
pour que torch.cuda.is_available() reponde True partout (meme hors
decorateur), et un chemin bas niveau echappe a cette emulation des que
du vrai calcul (construction de modele, forward/backward) est declenche
hors du decorateur -> "CUDA error: no CUDA-capable device is detected"
malgre device=cpu explicite. L'exception est avalee par le try/except
du callback donc pas moyen d'avoir la trace complete sans instrumenter
davantage, ce qui ne vaut pas le detour pour un contournement qui reste
fragile de toute facon.

Retour a la configuration deja validee : les six fonctions (MLP, CNN,
extraction de features, evaluation, prediction, test aleatoire) sont a
nouveau decorees @spaces.GPU, avec les durees dynamiques calibrees pour
MLP et CNN conservees. Reste du meme avis que la calibration des durees
+ le resserrement des curseurs UI est la bonne facon de limiter la
pression sur le quota journalier, pas une bascule CPU partielle.

app.py

@@ -40,6 +40,27 @@ 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,
@@ -78,14 +99,6 @@ def train_mlp_callback(
 # ---------------------------------------------------------------------------
 # Tab 3 — SimpleCNN
 # ---------------------------------------------------------------------------
-# Seul le CNN reste sur ZeroGPU : entraîner un vrai CNN (convolutions, plusieurs
-# époques de backward) s'est révélé ~9x plus lent sur CPU basic (601s vs 65s
-# mesurés) alors que le MLP (~3.8x, 252s vs 66.6s) et tout ce qui n'est que de
-# l'inférence (extraction de features, évaluation, prédiction) restent
-# raisonnables sur CPU. Sur un Space matériel ZeroGPU, seules les fonctions
-# décorées @spaces.GPU empruntent un vrai GPU (et consomment le quota du
-# visiteur) ; tout le reste de ce fichier tourne sur le CPU du conteneur
-# sans jamais toucher au quota.
 
 def cnn_gpu_duration(
     num_conv_blocks, base_filters, kernel_size, use_batchnorm,
@@ -155,6 +168,7 @@ def train_cnn_callback(
 # Tab 4 — Backbone + ML classique
 # ---------------------------------------------------------------------------
 
+@spaces.GPU(duration=60)
 def extract_features_callback():
     try:
         _, class_names, counts = extract_all_features()
@@ -247,6 +261,7 @@ def download_model_callback(model_name, request: gr.Request):
         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)
@@ -255,6 +270,7 @@ 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)
@@ -262,6 +278,7 @@ 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)

backbone_utils.py

@@ -37,10 +37,7 @@ def extract_all_features(batch_size: int = 64):
 
     from data_utils import prepare_splits, get_class_names, HFDatasetWrapper, get_eval_transform
 
-    # extract_features_callback n'est pas décoré @spaces.GPU : forcer le CPU.
-    # Sur du matériel ZeroGPU, torch.cuda.is_available() répond True même
-    # hors décorateur (mode émulation), mais aucun GPU réel n'est alloué ici.
-    device = torch.device("cpu")
+    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
     backbone = load_backbone(device)
     backbone.eval()
 

predict_utils.py

@@ -6,7 +6,7 @@ from PIL import Image
 
 from config import CLASSICAL_MODEL_TYPES
 from data_utils import get_eval_transform, prepare_splits, get_class_names
-from train_utils import load_model, _load_meta
+from train_utils import load_model, get_runtime_device, _load_meta
 
 
 def _extract_feature(image: Image.Image, device: torch.device) -> np.ndarray:
@@ -28,9 +28,7 @@ def predict_uploaded_image(model_name: str, image: Image.Image, session_id: str)
     meta = _load_meta(model_name, session_id)
     model_type = meta["config"].get("model_type", "cnn")
     class_names = meta["config"]["class_names"]
-    # predict_callback n'est pas décoré @spaces.GPU : forcer le CPU (voir
-    # le commentaire dans train_mlp, train_utils.py).
-    device = torch.device("cpu")
+    device = get_runtime_device()
 
     if model_type in CLASSICAL_MODEL_TYPES:
         from classical_ml_utils import load_classical_pipeline
@@ -64,9 +62,7 @@ def test_random_sample(model_name: str, session_id: str):
     meta = _load_meta(model_name, session_id)
     model_type = meta["config"].get("model_type", "cnn")
     class_names = get_class_names()
-    # random_test_callback n'est pas décoré @spaces.GPU : forcer le CPU (voir
-    # le commentaire dans train_mlp, train_utils.py).
-    device = torch.device("cpu")
+    device = get_runtime_device()
 
     splits = prepare_splits()
     test_dataset = splits["test"]

train_utils.py

@@ -451,12 +451,7 @@ def train_mlp(
     epochs: int = 30,
     model_tag: str = "",
 ):
-    # Pas de @spaces.GPU sur ce chemin (voir train_cnn_callback) : sur du
-    # matériel ZeroGPU, torch.cuda.is_available() répond True même hors
-    # décorateur (mode émulation), mais aucun GPU réel n'est alloué ici —
-    # utiliser get_runtime_device() planterait avec "Low-level CUDA init
-    # reached". On force donc le CPU explicitement.
-    device = torch.device("cpu")
+    device = get_runtime_device()
     train_loader, val_loader, test_loader, class_names = make_loaders(batch_size)
     num_classes = len(class_names)
     input_size = 3 * IMAGE_SIZE * IMAGE_SIZE
@@ -573,9 +568,7 @@ def evaluate_saved_model(model_name: str, session_id: str):
 
 
 def _evaluate_neural(model_name: str, meta: dict, session_id: str):
-    # evaluate_callback n'est pas décoré @spaces.GPU : forcer le CPU (voir
-    # le commentaire dans train_mlp).
-    device = torch.device("cpu")
+    device = get_runtime_device()
     model, meta = load_model(model_name, device, session_id)
 
     batch_size = int(meta["config"].get("batch_size", 16))