Isoler le stockage des modeles par session et corriger le role de la CV

Chaque session de navigateur (session_hash Gradio) a maintenant son
propre sous-repertoire dans saved_models/ et saved_models_meta/, pour
qu'un(e) etudiant(e) ne voie plus les modeles entraines par un(e) autre
sur le meme Space partage.

Pour les classifieurs ML classiques, la validation croisee effectue
desormais une vraie recherche par grille (GridSearchCV) sur
l'hyperparametre expose dans l'UI au lieu de se contenter de noter la
valeur choisie a la main : elle selectionne le meilleur candidat, et
c'est ce modele-la qui est sauvegarde et evalue.

.gitignore

@@ -6,3 +6,4 @@ saved_figures/
 __pycache__/
 *.pyc
 .DS_Store
+test_api.py

app.py

@@ -44,9 +44,12 @@ def train_mlp_callback(
     num_layers, hidden_dim, dropout,
     learning_rate, weight_decay, batch_size, epochs,
     model_tag,
+    request: gr.Request,
 ):
     try:
+        session_id = request.session_hash
         result = train_mlp(
+            session_id=session_id,
             num_layers=int(num_layers),
             hidden_dim=int(hidden_dim),
             dropout=float(dropout),
@@ -56,7 +59,7 @@ def train_mlp_callback(
             epochs=int(epochs),
             model_tag=model_tag,
         )
-        models = list_saved_models()
+        models = list_saved_models(session_id)
         selected = result["model_name"] if result["model_name"] in models else None
         return (
             result["logs"],
@@ -82,9 +85,12 @@ def train_cnn_callback(
     dropout, fc_dim,
     learning_rate, weight_decay, batch_size, epochs,
     model_tag,
+    request: gr.Request,
 ):
     try:
+        session_id = request.session_hash
         result = train_cnn(
+            session_id=session_id,
             num_conv_blocks=int(num_conv_blocks),
             base_filters=int(base_filters),
             kernel_size=int(kernel_size),
@@ -97,7 +103,7 @@ def train_cnn_callback(
             epochs=int(epochs),
             model_tag=model_tag,
         )
-        models = list_saved_models()
+        models = list_saved_models(session_id)
         selected = result["model_name"] if result["model_name"] in models else None
         return (
             result["logs"],
@@ -142,8 +148,10 @@ def train_classical_callback(
     rf_n_estimators,
     use_cv,
     model_tag,
+    request: gr.Request,
 ):
     try:
+        session_id = request.session_hash
         features_cache = get_cached_features()
         if features_cache is None:
             return (
@@ -163,10 +171,11 @@ def train_classical_callback(
 
         class_names = get_class_names()
         result = train_classical_model(
-            clf_type, features_cache, class_names, model_tag, use_cv=bool(use_cv), **params
+            clf_type, features_cache, class_names, session_id,
+            model_tag=model_tag, use_cv=bool(use_cv), **params
         )
 
-        models = list_saved_models()
+        models = list_saved_models(session_id)
         selected = result["model_name"] if result["model_name"] in models else None
         return (
             result["summary"],
@@ -183,42 +192,42 @@ def train_classical_callback(
 # Tab 5 — Tester et analyser
 # ---------------------------------------------------------------------------
 
-def refresh_models_callback():
-    models = list_saved_models()
+def refresh_models_callback(request: gr.Request):
+    models = list_saved_models(request.session_hash)
     return gr.update(choices=models, value=models[0] if models else None)
 
 
-def get_model_info_callback(model_name):
+def get_model_info_callback(model_name, request: gr.Request):
     if not model_name:
         return {"message": "Aucun modèle sélectionné."}
     try:
-        with open(model_meta_path(model_name), "r", encoding="utf-8") as f:
+        with open(model_meta_path(model_name, request.session_hash), "r", encoding="utf-8") as f:
             return json.load(f)
     except FileNotFoundError:
         return {"message": "Métadonnées introuvables."}
 
 
 @spaces.GPU(duration=120)
-def evaluate_callback(model_name):
+def evaluate_callback(model_name, request: gr.Request):
     try:
-        summary, report_df, cm_df, cm_path = evaluate_saved_model(model_name)
+        summary, report_df, cm_df, cm_path = evaluate_saved_model(model_name, request.session_hash)
         return summary, report_df, cm_df, cm_path
     except Exception as e:
         return {"Erreur": str(e)}, None, None, None
 
 
 @spaces.GPU(duration=60)
-def predict_callback(model_name, image):
+def predict_callback(model_name, image, request: gr.Request):
     try:
-        return predict_uploaded_image(model_name, image)
+        return predict_uploaded_image(model_name, image, request.session_hash)
     except Exception as e:
         return f"Échec :\n{e}", None
 
 
 @spaces.GPU(duration=60)
-def random_test_callback(model_name):
+def random_test_callback(model_name, request: gr.Request):
     try:
-        return test_random_sample(model_name)
+        return test_random_sample(model_name, request.session_hash)
     except Exception as e:
         return None, f"Échec :\n{e}", None
 
@@ -227,8 +236,6 @@ def random_test_callback(model_name):
 # UI
 # ---------------------------------------------------------------------------
 
-initial_models = list_saved_models()
-
 with gr.Blocks(title="Classification d'images microscopiques") as demo:
 
     gr.Markdown("# Classification d'images microscopiques de charbons de bois")
@@ -531,9 +538,10 @@ with gr.Blocks(title="Classification d'images microscopiques") as demo:
             with gr.Row():
                 with gr.Column():
                     model_selector = gr.Dropdown(
-                        choices=initial_models,
-                        value=initial_models[0] if initial_models else None,
+                        choices=[],
+                        value=None,
                         label="Modèle sauvegardé",
+                        info="Liste propre à votre session — les modèles des autres étudiant·e·s ne sont pas visibles ici.",
                     )
                     refresh_btn = gr.Button("Actualiser la liste")
                     load_info_btn = gr.Button("Afficher les informations du modèle")
@@ -662,6 +670,10 @@ with gr.Blocks(title="Classification d'images microscopiques") as demo:
         outputs=[random_img, random_text, random_probs],
     )
 
+    # Peuple la liste des modèles au chargement de la page, à partir de la
+    # session du navigateur qui vient de se connecter (cf. refresh_models_callback).
+    demo.load(fn=refresh_models_callback, inputs=None, outputs=model_selector)
+
 
 if __name__ == "__main__":
     demo.launch(ssr_mode=False)

classical_ml_utils.py

@@ -7,13 +7,13 @@ from typing import List
 import joblib
 from sklearn.ensemble import RandomForestClassifier
 from sklearn.linear_model import LogisticRegression
-from sklearn.model_selection import StratifiedKFold, cross_val_score
+from sklearn.model_selection import GridSearchCV, StratifiedKFold
 from sklearn.neighbors import KNeighborsClassifier
 from sklearn.pipeline import Pipeline
 from sklearn.preprocessing import StandardScaler
 from sklearn.svm import SVC
 
-from config import MODEL_DIR, META_DIR, CV_FOLDS
+from config import CV_FOLDS, session_model_dir, session_meta_dir
 from metrics_utils import compute_classification_metrics, save_confusion_matrix_figure
 
 CLF_TYPE_MAP = {
@@ -23,13 +23,25 @@ CLF_TYPE_MAP = {
     "Forêt aléatoire": "rf",
 }
 
+# Grille de recherche par algorithme : le SEUL hyperparamètre exposé dans
+# l'UI est aussi celui balayé par la validation croisée — c'est ce balayage
+# (et non le score de stabilité d'une valeur choisie à la main) qui constitue
+# le véritable rôle pédagogique de la CV : sélectionner le meilleur
+# hyperparamètre plutôt que de simplement le deviner.
+PARAM_GRIDS = {
+    "svm": ("C", [0.01, 0.1, 1.0, 10.0, 100.0]),
+    "logreg": ("C", [0.01, 0.1, 1.0, 10.0, 100.0]),
+    "knn": ("n_neighbors", [1, 3, 5, 7, 9, 15]),
+    "rf": ("n_estimators", [50, 100, 200, 300]),
+}
+
 
-def classifier_path(model_name: str) -> str:
-    return os.path.join(MODEL_DIR, f"{model_name}.joblib")
+def classifier_path(model_name: str, session_id: str) -> str:
+    return os.path.join(session_model_dir(session_id), f"{model_name}.joblib")
 
 
-def meta_path(model_name: str) -> str:
-    return os.path.join(META_DIR, f"{model_name}.json")
+def meta_path(model_name: str, session_id: str) -> str:
+    return os.path.join(session_meta_dir(session_id), f"{model_name}.json")
 
 
 def build_pipeline(clf_type: str, **params) -> Pipeline:
@@ -67,27 +79,58 @@ def build_pipeline(clf_type: str, **params) -> Pipeline:
     return Pipeline([("scaler", StandardScaler()), ("clf", clf)])
 
 
-def _cross_validate(clf_type: str, X_train, y_train, **params) -> dict:
-    """CV stratifiée sur le train set. Réduit le nombre de folds si une classe
-    a moins d'échantillons que CV_FOLDS (dataset très réduit)."""
+def _grid_search_cv(clf_type: str, X_train, y_train, manual_value, **other_params):
+    """Recherche par grille en validation croisée : le véritable rôle de la CV
+    n'est pas de noter la valeur choisie à la main, mais de comparer plusieurs
+    valeurs candidates et de sélectionner celle qui généralise le mieux.
+    La valeur choisie manuellement par l'étudiant·e est incluse dans la
+    grille pour qu'il/elle puisse comparer son choix au choix retenu par CV.
+    """
+    key = CLF_TYPE_MAP.get(clf_type, clf_type)
+    hp_name, default_grid = PARAM_GRIDS[key]
+    candidates = sorted(set(default_grid) | ({manual_value} if manual_value is not None else set()))
+
     min_class_count = min(Counter(y_train.tolist()).values())
     folds = max(2, min(CV_FOLDS, min_class_count))
-
-    pipeline = build_pipeline(clf_type, **params)
     skf = StratifiedKFold(n_splits=folds, shuffle=True, random_state=42)
-    scores = cross_val_score(pipeline, X_train, y_train, cv=skf, scoring="f1_macro")
 
-    return {
+    pipeline = build_pipeline(clf_type, **{hp_name: candidates[0], **other_params})
+    param_grid = {f"clf__{hp_name}": candidates}
+
+    search = GridSearchCV(
+        pipeline, param_grid=param_grid, cv=skf, scoring="f1_macro", refit=True, n_jobs=-1
+    )
+    search.fit(X_train, y_train)
+
+    grid_results = []
+    for candidate_params, mean_score, std_score in zip(
+        search.cv_results_["params"],
+        search.cv_results_["mean_test_score"],
+        search.cv_results_["std_test_score"],
+    ):
+        grid_results.append({
+            hp_name: candidate_params[f"clf__{hp_name}"],
+            "cv_f1_macro_mean": round(float(mean_score), 4),
+            "cv_f1_macro_std": round(float(std_score), 4),
+        })
+    grid_results.sort(key=lambda r: r[hp_name])
+
+    cv_metrics = {
         "cv_folds": folds,
-        "cv_f1_macro_mean": round(float(scores.mean()), 4),
-        "cv_f1_macro_std": round(float(scores.std()), 4),
+        "hyperparameter_name": hp_name,
+        "manual_value": manual_value,
+        "cv_best_value": search.best_params_[f"clf__{hp_name}"],
+        "cv_best_f1_macro": round(float(search.best_score_), 4),
+        "cv_grid_results": grid_results,
     }
+    return cv_metrics, search.best_estimator_
 
 
 def train_classical_model(
     clf_type: str,
     features_cache: dict,
     class_names: List[str],
+    session_id: str,
     model_tag: str = "",
     use_cv: bool = False,
     **params,
@@ -97,10 +140,20 @@ def train_classical_model(
     X_test = features_cache["test"]["X"]
     y_test = features_cache["test"]["y"]
 
-    cv_metrics = _cross_validate(clf_type, X_train, y_train, **params) if use_cv else None
+    key = CLF_TYPE_MAP.get(clf_type, clf_type)
 
-    pipeline = build_pipeline(clf_type, **params)
-    pipeline.fit(X_train, y_train)
+    if use_cv:
+        hp_name, _ = PARAM_GRIDS[key]
+        manual_value = params.get(hp_name)
+        other_params = {k: v for k, v in params.items() if k != hp_name}
+        cv_metrics, pipeline = _grid_search_cv(clf_type, X_train, y_train, manual_value, **other_params)
+        # Le modèle sauvegardé utilise l'hyperparamètre sélectionné par CV,
+        # pas nécessairement celui choisi à la main dans l'UI.
+        params = {**params, hp_name: cv_metrics["cv_best_value"]}
+    else:
+        cv_metrics = None
+        pipeline = build_pipeline(clf_type, **params)
+        pipeline.fit(X_train, y_train)
 
     y_pred = pipeline.predict(X_test)
     metrics = compute_classification_metrics(y_test.tolist(), y_pred.tolist(), class_names)
@@ -109,7 +162,7 @@ def train_classical_model(
     safe_tag = model_tag.strip().replace(" ", "_") if model_tag.strip() else CLF_TYPE_MAP.get(clf_type, "clf")
     model_name = f"{safe_tag}_{timestamp}"
 
-    joblib.dump(pipeline, classifier_path(model_name))
+    joblib.dump(pipeline, classifier_path(model_name, session_id))
     cm_path = save_confusion_matrix_figure(metrics["confusion_matrix"], model_name)
 
     config_dict = {
@@ -129,7 +182,7 @@ def train_classical_model(
         **(cv_metrics or {}),
     }
 
-    with open(meta_path(model_name), "w", encoding="utf-8") as f:
+    with open(meta_path(model_name, session_id), "w", encoding="utf-8") as f:
         json.dump(
             {
                 "model_name": model_name,
@@ -151,8 +204,8 @@ def train_classical_model(
     }
 
 
-def load_classical_pipeline(model_name: str) -> Pipeline:
-    path = classifier_path(model_name)
+def load_classical_pipeline(model_name: str, session_id: str) -> Pipeline:
+    path = classifier_path(model_name, session_id)
     if not os.path.exists(path):
         raise FileNotFoundError(f"Classifieur introuvable : {model_name}")
     return joblib.load(path)

config.py

@@ -13,6 +13,29 @@ os.makedirs(FIGURE_DIR, exist_ok=True)
 HF_DATASET_REPO = os.environ.get("HF_DATASET_REPO", "CircleStar/charcoal-microscopy")
 HF_TOKEN = os.environ.get("HF_TOKEN")
 
+
+def _sanitize_session_id(session_id: str) -> str:
+    """Un session_hash Gradio est déjà un identifiant sûr, mais on filtre par
+    prudence pour ne jamais laisser un caractère de traversée de chemin
+    (../) atteindre os.path.join."""
+    safe = "".join(c for c in (session_id or "") if c.isalnum() or c in "-_")
+    return safe or "default"
+
+
+def session_model_dir(session_id: str) -> str:
+    """Répertoire des poids/pipelines pour UNE session de navigateur — isole
+    les modèles entraînés par un·e étudiant·e de ceux des autres, qui
+    partagent pourtant le même Space Gradio."""
+    d = os.path.join(MODEL_DIR, _sanitize_session_id(session_id))
+    os.makedirs(d, exist_ok=True)
+    return d
+
+
+def session_meta_dir(session_id: str) -> str:
+    d = os.path.join(META_DIR, _sanitize_session_id(session_id))
+    os.makedirs(d, exist_ok=True)
+    return d
+
 IMAGE_SIZE = 224
 RANDOM_SEED = 42
 

predict_utils.py

@@ -19,25 +19,25 @@ def _extract_feature(image: Image.Image, device: torch.device) -> np.ndarray:
     return feat.cpu().numpy()
 
 
-def predict_uploaded_image(model_name: str, image: Image.Image):
+def predict_uploaded_image(model_name: str, image: Image.Image, session_id: str):
     if not model_name:
         return "Veuillez sélectionner un modèle.", None
     if image is None:
         return "Veuillez importer une image.", None
 
-    meta = _load_meta(model_name)
+    meta = _load_meta(model_name, session_id)
     model_type = meta["config"].get("model_type", "cnn")
     class_names = meta["config"]["class_names"]
     device = get_runtime_device()
 
     if model_type in CLASSICAL_MODEL_TYPES:
         from classical_ml_utils import load_classical_pipeline
-        pipeline = load_classical_pipeline(model_name)
+        pipeline = load_classical_pipeline(model_name, session_id)
         feat = _extract_feature(image, device)
         probs = pipeline.predict_proba(feat)[0].tolist()
         pred_idx = int(np.argmax(probs))
     else:
-        model, _ = load_model(model_name, device)
+        model, _ = load_model(model_name, device, session_id)
         tensor = get_eval_transform()(image.convert("RGB")).unsqueeze(0).to(device)
         with torch.no_grad():
             logits = model(tensor)
@@ -55,11 +55,11 @@ def predict_uploaded_image(model_name: str, image: Image.Image):
     return result_text, prob_dict
 
 
-def test_random_sample(model_name: str):
+def test_random_sample(model_name: str, session_id: str):
     if not model_name:
         return None, "Veuillez sélectionner un modèle.", None
 
-    meta = _load_meta(model_name)
+    meta = _load_meta(model_name, session_id)
     model_type = meta["config"].get("model_type", "cnn")
     class_names = get_class_names()
     device = get_runtime_device()
@@ -77,12 +77,12 @@ def test_random_sample(model_name: str):
 
     if model_type in CLASSICAL_MODEL_TYPES:
         from classical_ml_utils import load_classical_pipeline
-        pipeline = load_classical_pipeline(model_name)
+        pipeline = load_classical_pipeline(model_name, session_id)
         feat = _extract_feature(image, device)
         probs = pipeline.predict_proba(feat)[0].tolist()
         pred_idx = int(np.argmax(probs))
     else:
-        model, _ = load_model(model_name, device)
+        model, _ = load_model(model_name, device, session_id)
         tensor = get_eval_transform()(image).unsqueeze(0).to(device)
         with torch.no_grad():
             logits = model(tensor)

train_utils.py

@@ -8,31 +8,30 @@ import torch
 import torch.nn as nn
 import torch.optim as optim
 
-from config import MODEL_DIR, META_DIR, DATASET_DISPLAY_NAME, CLASSICAL_MODEL_TYPES, IMAGE_SIZE
+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
 from model import SimpleCNN, BackboneWithFC, MLP
 
 
 # ---------------------------------------------------------------------------
-# Path helpers
+# Path helpers — tout est scopé par session_id (= session_hash Gradio, un par
+# navigateur/onglet) pour qu'un·e étudiant·e ne voie jamais les modèles d'un·e
+# autre alors que tous partagent le même Space.
 # ---------------------------------------------------------------------------
 
-def model_weight_path(model_name: str) -> str:
-    return os.path.join(MODEL_DIR, f"{model_name}.pt")
+def model_weight_path(model_name: str, session_id: str) -> str:
+    return os.path.join(session_model_dir(session_id), f"{model_name}.pt")
 
 
-def classifier_weight_path(model_name: str) -> str:
-    return os.path.join(MODEL_DIR, f"{model_name}.joblib")
+def model_meta_path(model_name: str, session_id: str) -> str:
+    return os.path.join(session_meta_dir(session_id), f"{model_name}.json")
 
 
-def model_meta_path(model_name: str) -> str:
-    return os.path.join(META_DIR, f"{model_name}.json")
-
-
-def list_saved_models() -> List[str]:
+def list_saved_models(session_id: str) -> List[str]:
+    meta_dir = session_meta_dir(session_id)
     names = []
-    for fn in os.listdir(META_DIR):
+    for fn in os.listdir(meta_dir):
         if fn.endswith(".json"):
             names.append(fn[:-5])
     return sorted(names, reverse=True)
@@ -46,15 +45,15 @@ def get_runtime_device() -> torch.device:
 # Save / load
 # ---------------------------------------------------------------------------
 
-def save_model(model: nn.Module, model_name: str, config: dict, training_summary: dict):
+def save_model(model: nn.Module, model_name: str, config: dict, training_summary: dict, session_id: str):
     if config["model_type"] == "fc_head":
         state_dict = {k: v.detach().cpu() for k, v in model.classifier.state_dict().items()}
     else:
         state_dict = {k: v.detach().cpu() for k, v in model.state_dict().items()}
 
-    torch.save(state_dict, model_weight_path(model_name))
+    torch.save(state_dict, model_weight_path(model_name, session_id))
 
-    with open(model_meta_path(model_name), "w", encoding="utf-8") as f:
+    with open(model_meta_path(model_name, session_id), "w", encoding="utf-8") as f:
         json.dump(
             {
                 "model_name": model_name,
@@ -68,16 +67,16 @@ def save_model(model: nn.Module, model_name: str, config: dict, training_summary
         )
 
 
-def _load_meta(model_name: str) -> dict:
-    path = model_meta_path(model_name)
+def _load_meta(model_name: str, session_id: str) -> dict:
+    path = model_meta_path(model_name, session_id)
     if not os.path.exists(path):
         raise FileNotFoundError(f"Métadonnées introuvables : {model_name}")
     with open(path, "r", encoding="utf-8") as f:
         return json.load(f)
 
 
-def load_model(model_name: str, device: torch.device) -> Tuple[nn.Module, dict]:
-    meta = _load_meta(model_name)
+def load_model(model_name: str, device: torch.device, session_id: str) -> Tuple[nn.Module, dict]:
+    meta = _load_meta(model_name, session_id)
     cfg = meta["config"]
     model_type = cfg.get("model_type", "cnn")
 
@@ -86,7 +85,7 @@ def load_model(model_name: str, device: torch.device) -> Tuple[nn.Module, dict]:
         backbone = load_backbone(device)
         model = BackboneWithFC(backbone, cfg["num_classes"], cfg.get("dropout", 0.4), cfg.get("fc_dim", 256))
         model.classifier.load_state_dict(
-            torch.load(model_weight_path(model_name), map_location="cpu")
+            torch.load(model_weight_path(model_name, session_id), map_location="cpu")
         )
 
     elif model_type == "cnn":
@@ -99,7 +98,7 @@ def load_model(model_name: str, device: torch.device) -> Tuple[nn.Module, dict]:
             dropout=cfg.get("dropout", 0.4),
             fc_dim=cfg.get("fc_dim", 256),
         )
-        model.load_state_dict(torch.load(model_weight_path(model_name), map_location="cpu"))
+        model.load_state_dict(torch.load(model_weight_path(model_name, session_id), map_location="cpu"))
 
     elif model_type == "mlp":
         model = MLP(
@@ -109,7 +108,7 @@ def load_model(model_name: str, device: torch.device) -> Tuple[nn.Module, dict]:
             hidden_dim=cfg.get("hidden_dim", 256),
             dropout=cfg.get("dropout", 0.4),
         )
-        model.load_state_dict(torch.load(model_weight_path(model_name), map_location="cpu"))
+        model.load_state_dict(torch.load(model_weight_path(model_name, session_id), map_location="cpu"))
 
     else:
         raise ValueError(f"load_model n'accepte pas le type '{model_type}'. Utilisez load_classical_pipeline pour les modèles ML classiques.")
@@ -207,6 +206,7 @@ def _training_loop(model, train_loader, val_loader, criterion, optimizer, schedu
 # ---------------------------------------------------------------------------
 
 def train_fc_head(
+    session_id: str,
     dropout: float = 0.4,
     fc_dim: int = 256,
     learning_rate: float = 1e-4,
@@ -281,7 +281,7 @@ def train_fc_head(
         "trainable_params": trainable_params,
     }
 
-    save_model(model, model_name, config, training_summary)
+    save_model(model, model_name, config, training_summary, session_id)
 
     logs += [
         "",
@@ -310,6 +310,7 @@ def train_fc_head(
 # ---------------------------------------------------------------------------
 
 def train_cnn(
+    session_id: str,
     num_conv_blocks: int = 3,
     base_filters: int = 32,
     kernel_size: int = 3,
@@ -399,7 +400,7 @@ def train_cnn(
         "trainable_params": trainable_params,
     }
 
-    save_model(model, model_name, config, training_summary)
+    save_model(model, model_name, config, training_summary, session_id)
 
     logs += [
         "",
@@ -429,6 +430,7 @@ def train_cnn(
 # ---------------------------------------------------------------------------
 
 def train_mlp(
+    session_id: str,
     num_layers: int = 2,
     hidden_dim: int = 256,
     dropout: float = 0.4,
@@ -512,7 +514,7 @@ def train_mlp(
         "trainable_params": trainable_params,
     }
 
-    save_model(model, model_name, config, training_summary)
+    save_model(model, model_name, config, training_summary, session_id)
 
     logs += [
         "",
@@ -541,22 +543,22 @@ def train_mlp(
 # Evaluate any saved model
 # ---------------------------------------------------------------------------
 
-def evaluate_saved_model(model_name: str):
+def evaluate_saved_model(model_name: str, session_id: str):
     if not model_name:
         raise ValueError("Aucun modèle sélectionné.")
 
-    meta = _load_meta(model_name)
+    meta = _load_meta(model_name, session_id)
     model_type = meta["config"].get("model_type", "cnn")
 
     if model_type in CLASSICAL_MODEL_TYPES:
-        return _evaluate_classical(model_name, meta)
+        return _evaluate_classical(model_name, meta, session_id)
     else:
-        return _evaluate_neural(model_name, meta)
+        return _evaluate_neural(model_name, meta, session_id)
 
 
-def _evaluate_neural(model_name: str, meta: dict):
+def _evaluate_neural(model_name: str, meta: dict, session_id: str):
     device = get_runtime_device()
-    model, meta = load_model(model_name, device)
+    model, meta = load_model(model_name, device, session_id)
 
     batch_size = int(meta["config"].get("batch_size", 16))
     _, _, test_loader, class_names = make_loaders(batch_size)
@@ -582,7 +584,7 @@ def _evaluate_neural(model_name: str, meta: dict):
     )
 
 
-def _evaluate_classical(model_name: str, meta: dict):
+def _evaluate_classical(model_name: str, meta: dict, session_id: str):
     from backbone_utils import get_cached_features, extract_all_features
     from classical_ml_utils import load_classical_pipeline
 
@@ -591,7 +593,7 @@ def _evaluate_classical(model_name: str, meta: dict):
         features_cache, _, _ = extract_all_features()
 
     class_names = meta["config"]["class_names"]
-    pipeline = load_classical_pipeline(model_name)
+    pipeline = load_classical_pipeline(model_name, session_id)
 
     X_test = features_cache["test"]["X"]
     y_test = features_cache["test"]["y"]