Restructurer l'app : backbone préentraîné + ML classique + FC head + CNN de zéro

- Ajout backbone_utils.py : chargement du backbone ResNet18 depuis HF, extraction
de features 512-dim avec cache mémoire
- Ajout classical_ml_utils.py : SVM / LogReg / k-NN / RF / LDA sur les features
extraites (pipeline sklearn avec StandardScaler + joblib)
- Refactorisation train_utils.py : train_fc_head (tête FC seule, ~200Ko sauvegardés)
et train_cnn (SimpleCNN de zéro) ; evaluate_saved_model unifié pour tous les types
- Mise à jour model.py : BackboneWithFC (backbone gelé + tête FC) + SimpleCNN conservé
- Mise à jour predict_utils.py : dispatch automatique selon model_type
- Mise à jour app.py : 4 onglets (dataset / ML classique / neuronaux / test-prédiction)
- Ajout config.py : HF_BACKBONE_REPO, CLASSICAL_MODEL_TYPES
- Ajout .gitignore : exclut data/, backbone/, saved_models/, __pycache__/
- Ajout finetune_backbone.py : script local pour entraîner le backbone sur les données

.gitignore

@@ -0,0 +1,8 @@
+data/
+backbone/
+saved_models/
+saved_models_meta/
+saved_figures/
+__pycache__/
+*.pyc
+.DS_Store

app.py

@@ -3,90 +3,145 @@ import json
 import gradio as gr
 import spaces
 
-from data_utils import (
-    dataset_overview,
-    get_class_names,
-    get_images_for_gallery,
-)
+from backbone_utils import extract_all_features, get_cached_features
+from classical_ml_utils import train_classical_model
+from data_utils import dataset_overview, get_class_names, get_images_for_gallery
+from predict_utils import predict_uploaded_image, test_random_sample
 from train_utils import (
-    train_model,
+    evaluate_saved_model,
     list_saved_models,
     model_meta_path,
-    evaluate_saved_model,
-)
-from predict_utils import (
-    predict_uploaded_image,
-    test_random_sample,
+    train_cnn,
+    train_fc_head,
 )
 
+# ---------------------------------------------------------------------------
+# Tab 1 — Dataset
+# ---------------------------------------------------------------------------
 
-def load_dataset_overview_callback():
+def load_dataset_callback():
     try:
         summary, distribution_df = dataset_overview()
         class_names = ["Toutes les classes"] + get_class_names()
+        return summary, distribution_df, gr.update(choices=class_names, value="Toutes les classes")
+    except Exception as e:
+        return {"Erreur": str(e)}, None, gr.update()
 
-        return (
-            summary,
-            distribution_df,
-            gr.update(choices=class_names, value="Toutes les classes"),
-        )
 
+def refresh_gallery_callback(split_name, class_name, max_images):
+    try:
+        return get_images_for_gallery(split_name, class_name, int(max_images))
     except Exception as e:
-        return (
-            {"Erreur": str(e)},
-            None,
-            gr.update(),
-        )
+        return [(None, f"Erreur : {e}")]
 
 
-def refresh_gallery_callback(split_name, class_name, max_images):
+# ---------------------------------------------------------------------------
+# Tab 2 — ML classique
+# ---------------------------------------------------------------------------
+
+def extract_features_callback():
     try:
-        gallery = get_images_for_gallery(
-            split_name=split_name,
-            class_name=class_name,
-            max_images=int(max_images),
+        _, class_names, counts = extract_all_features()
+        lines = [f"Extraction terminée  ({len(class_names)} classes)"]
+        for split, n in counts.items():
+            lines.append(f"  {split} : {n} images")
+        return "\n".join(lines)
+    except Exception as e:
+        return f"Erreur lors de l'extraction :\n{e}"
+
+
+def on_clf_type_change(clf_type):
+    show = lambda t: gr.update(visible=(clf_type == t))
+    return show("SVM"), show("Régression logistique"), show("k-NN"), show("Forêt aléatoire"), show("LDA")
+
+
+def train_classical_callback(
+    clf_type,
+    svm_c, svm_kernel, svm_gamma,
+    logreg_c, logreg_max_iter,
+    knn_k, knn_metric,
+    rf_n_estimators, rf_max_depth,
+    lda_solver,
+    model_tag,
+):
+    try:
+        features_cache = get_cached_features()
+        if features_cache is None:
+            return {"Erreur": "Veuillez d'abord extraire les caractéristiques (bouton ci-dessus)."}, None, None, None, gr.update()
+
+        params = {}
+        if clf_type == "SVM":
+            params = {"C": float(svm_c), "kernel": svm_kernel, "gamma": svm_gamma}
+        elif clf_type == "Régression logistique":
+            params = {"C": float(logreg_c), "max_iter": int(logreg_max_iter)}
+        elif clf_type == "k-NN":
+            params = {"n_neighbors": int(knn_k), "metric": knn_metric}
+        elif clf_type == "Forêt aléatoire":
+            depth = int(rf_max_depth) if rf_max_depth and int(rf_max_depth) > 0 else None
+            params = {"n_estimators": int(rf_n_estimators), "max_depth": depth}
+        elif clf_type == "LDA":
+            params = {"solver": lda_solver}
+
+        class_names = get_class_names()
+        result = train_classical_model(clf_type, features_cache, class_names, model_tag, **params)
+
+        models = list_saved_models()
+        selected = result["model_name"] if result["model_name"] in models else None
+
+        return (
+            result["summary"],
+            result["classification_report"],
+            result["confusion_matrix"],
+            result["confusion_matrix_path"],
+            gr.update(choices=models, value=selected),
         )
-        return gallery
     except Exception as e:
-        return [(None, f"Erreur : {str(e)}")]
+        return {"Erreur": str(e)}, None, None, None, gr.update()
 
 
-def on_model_type_change(model_type):
-    is_cnn = (model_type == "CNN simple")
-    default_lr = 0.001 if is_cnn else 0.0001
+# ---------------------------------------------------------------------------
+# Tab 3 — Modèles neuronaux
+# ---------------------------------------------------------------------------
+
+def on_neural_type_change(model_type):
+    is_cnn = (model_type == "CNN de zéro")
+    default_lr = 1e-3 if is_cnn else 1e-4
     return gr.update(visible=is_cnn), gr.update(value=default_lr)
 
 
-@spaces.GPU(duration=200)
-def train_callback(
+@spaces.GPU(duration=300)
+def train_neural_callback(
     model_type,
-    num_conv_blocks,
-    base_filters,
-    kernel_size,
-    use_batchnorm,
-    dropout,
-    fc_dim,
-    learning_rate,
-    weight_decay,
-    batch_size,
-    epochs,
+    num_conv_blocks, base_filters, kernel_size, use_batchnorm,
+    dropout, fc_dim,
+    learning_rate, weight_decay, batch_size, epochs,
     model_tag,
 ):
     try:
-        result = train_model(
-            model_type="cnn" if model_type == "CNN simple" else "resnet18",
-            num_conv_blocks=int(num_conv_blocks),
-            base_filters=int(base_filters),
-            kernel_size=int(kernel_size),
-            use_batchnorm=bool(use_batchnorm),
-            dropout=float(dropout),
-            fc_dim=int(fc_dim),
-            learning_rate=float(learning_rate),
-            weight_decay=float(weight_decay),
-            batch_size=int(batch_size),
-            epochs=int(epochs),
-            model_tag=model_tag,
-        )
+        if model_type == "FC sur backbone préentraîné":
+            result = train_fc_head(
+                dropout=float(dropout),
+                fc_dim=int(fc_dim),
+                learning_rate=float(learning_rate),
+                weight_decay=float(weight_decay),
+                batch_size=int(batch_size),
+                epochs=int(epochs),
+                model_tag=model_tag,
+            )
+        else:
+            result = train_cnn(
+                num_conv_blocks=int(num_conv_blocks),
+                base_filters=int(base_filters),
+                kernel_size=int(kernel_size),
+                use_batchnorm=bool(use_batchnorm),
+                dropout=float(dropout),
+                fc_dim=int(fc_dim),
+                learning_rate=float(learning_rate),
+                weight_decay=float(weight_decay),
+                batch_size=int(batch_size),
+                epochs=int(epochs),
+                model_tag=model_tag,
+            )
 
         models = list_saved_models()
         selected = result["model_name"] if result["model_name"] in models else None
@@ -100,21 +155,31 @@ def train_callback(
             result["confusion_matrix_path"],
             gr.update(choices=models, value=selected),
         )
-
     except Exception as e:
-        return (
-            f"Échec de l’entraînement :\n{str(e)}",
-            None,
-            None,
-            None,
-            None,
-            None,
-            gr.update(),
-        )
+        return f"Échec de l'entraînement :\n{e}", None, None, None, None, None, gr.update()
+
+
+# ---------------------------------------------------------------------------
+# Tab 4 — Tester et prédire
+# ---------------------------------------------------------------------------
+
+def refresh_models_callback():
+    models = list_saved_models()
+    return gr.update(choices=models, value=models[0] if models else None)
+
+
+def get_model_info_callback(model_name):
+    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:
+            return json.load(f)
+    except FileNotFoundError:
+        return {"message": "Métadonnées introuvables."}
 
 
 @spaces.GPU(duration=120)
-def evaluate_saved_model_callback(model_name):
+def evaluate_callback(model_name):
     try:
         summary, report_df, cm_df, cm_path = evaluate_saved_model(model_name)
         return summary, report_df, cm_df, cm_path
@@ -123,269 +188,219 @@ def evaluate_saved_model_callback(model_name):
 
 
 @spaces.GPU(duration=60)
-def predict_uploaded_image_callback(model_name, image):
+def predict_callback(model_name, image):
     try:
         return predict_uploaded_image(model_name, image)
     except Exception as e:
-        return f"Échec de la prédiction :\n{str(e)}", None
+        return f"Échec :\n{e}", None
 
 
 @spaces.GPU(duration=60)
-def test_random_sample_callback(model_name):
+def random_test_callback(model_name):
     try:
         return test_random_sample(model_name)
     except Exception as e:
-        return None, f"Échec du test aléatoire :\n{str(e)}", None
-
-
-def refresh_models_dropdown():
-    models = list_saved_models()
-    return gr.update(choices=models, value=models[0] if models else None)
+        return None, f"Échec :\n{e}", None
 
 
-def get_model_info(model_name: str):
-    if not model_name:
-        return {"message": "Aucun modèle sélectionné."}
-
-    meta_file = model_meta_path(model_name)
-
-    try:
-        with open(meta_file, "r", encoding="utf-8") as f:
-            return json.load(f)
-    except FileNotFoundError:
-        return {"message": "Métadonnées introuvables."}
-
+# ---------------------------------------------------------------------------
+# 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")
+with gr.Blocks(title="Classification d'images microscopiques") as demo:
+    gr.Markdown("# Classification d'images microscopiques de charbons de bois")
     gr.Markdown(
-        "Application pédagogique pour explorer un jeu de données d’images microscopiques, "
-        "entraîner un modèle de classification et analyser ses performances."
+        "Application pédagogique : explorez le jeu de données, entraînez des classifieurs "
+        "traditionnels ou neuronaux sur les caractéristiques extraites par un backbone "
+        "ResNet18 préentraîné, puis analysez et comparez les résultats."
     )
 
     with gr.Tabs():
 
+        # ------------------------------------------------------------------ #
+        # Tab 1
+        # ------------------------------------------------------------------ #
         with gr.Tab("1. Explorer le jeu de données"):
-            gr.Markdown("## Comprendre le jeu de données avant l’entraînement")
-
-            load_dataset_btn = gr.Button(
-                "Charger les informations du dataset",
-                variant="primary",
-            )
-
-            dataset_summary = gr.JSON(label="Résumé général du dataset")
+            gr.Markdown("## Comprendre le jeu de données avant l'entraînement")
 
+            load_dataset_btn = gr.Button("Charger les informations du dataset", variant="primary")
+            dataset_summary = gr.JSON(label="Résumé général")
             class_distribution = gr.Dataframe(
-                label="Distribution des images par split et par classe",
-                interactive=False,
+                label="Distribution par split et par classe", interactive=False
             )
 
             gr.Markdown("## Visualisation des images")
-
             with gr.Row():
                 split_selector = gr.Dropdown(
-                    choices=["train", "validation", "test"],
-                    value="train",
-                    label="Split",
+                    choices=["train", "validation", "test"], value="train", label="Split"
                 )
                 class_selector = gr.Dropdown(
-                    choices=["Toutes les classes"],
-                    value="Toutes les classes",
-                    label="Classe",
-                )
-                max_images = gr.Slider(
-                    minimum=4,
-                    maximum=48,
-                    value=24,
-                    step=4,
-                    label="Nombre d’images à afficher",
+                    choices=["Toutes les classes"], value="Toutes les classes", label="Classe"
                 )
+                max_images = gr.Slider(minimum=4, maximum=48, value=24, step=4, label="Nombre d'images")
 
             refresh_gallery_btn = gr.Button("Afficher des exemples")
-
-            image_gallery = gr.Gallery(
-                label="Exemples d’images",
-                columns=4,
-                height=600,
+            image_gallery = gr.Gallery(label="Exemples d'images", columns=4, height=600)
+
+        # ------------------------------------------------------------------ #
+        # Tab 2
+        # ------------------------------------------------------------------ #
+        with gr.Tab("2. ML classique sur caractéristiques"):
+            gr.Markdown(
+                "## Étape 1 — Extraction des caractéristiques\n"
+                "Le backbone ResNet18 préentraîné sur les charbons extrait un vecteur de "
+                "512 dimensions par image. Cette étape s'exécute sur CPU et ne nécessite "
+                "aucun GPU."
             )
 
-        with gr.Tab("2. Entraîner un modèle"):
-            gr.Markdown("## Choix du modèle et entraînement")
+            extract_btn = gr.Button("Extraire les caractéristiques (backbone gelé)", variant="primary")
+            extract_status = gr.Textbox(label="Statut de l'extraction", lines=4, interactive=False)
+
+            gr.Markdown("## Étape 2 — Entraîner un classifieur")
 
             with gr.Row():
                 with gr.Column():
-                    model_type = gr.Radio(
-                        choices=["CNN simple", "ResNet18"],
-                        value="CNN simple",
-                        label="Architecture",
-                        info=(
-                            "CNN simple : entraîné de zéro, paramètres configurables. "
-                            "ResNet18 : pré-entraîné ImageNet, fine-tuning layer4 + classifieur."
-                        ),
+                    clf_type = gr.Radio(
+                        choices=["SVM", "Régression logistique", "k-NN", "Forêt aléatoire", "LDA"],
+                        value="SVM",
+                        label="Algorithme",
                     )
 
-                    with gr.Column(visible=True) as cnn_params_col:
-                        gr.Markdown("#### Paramètres CNN")
-                        num_conv_blocks = gr.Slider(
-                            minimum=2,
-                            maximum=5,
-                            value=3,
-                            step=1,
-                            label="Nombre de blocs convolutionnels",
-                            info="Chaque bloc enchaîne Conv2d → (BN) → ReLU → MaxPool2d.",
+                    with gr.Column(visible=True) as svm_col:
+                        gr.Markdown("#### Paramètres SVM")
+                        svm_c = gr.Number(value=1.0, label="C (régularisation)")
+                        svm_kernel = gr.Dropdown(choices=["rbf", "linear", "poly"], value="rbf", label="Noyau")
+                        svm_gamma = gr.Dropdown(choices=["scale", "auto"], value="scale", label="Gamma")
+
+                    with gr.Column(visible=False) as logreg_col:
+                        gr.Markdown("#### Paramètres Régression logistique")
+                        logreg_c = gr.Number(value=1.0, label="C (régularisation)")
+                        logreg_max_iter = gr.Number(value=1000, label="Itérations max")
+
+                    with gr.Column(visible=False) as knn_col:
+                        gr.Markdown("#### Paramètres k-NN")
+                        knn_k = gr.Slider(minimum=1, maximum=20, value=5, step=1, label="k (voisins)")
+                        knn_metric = gr.Dropdown(
+                            choices=["euclidean", "cosine", "manhattan"], value="euclidean", label="Métrique"
                         )
 
-                        base_filters = gr.Dropdown(
-                            choices=[16, 32, 64, 128],
-                            value=32,
-                            label="Filtres du premier bloc (doublent à chaque bloc)",
-                        )
-
-                        kernel_size = gr.Dropdown(
-                            choices=[3, 5],
-                            value=3,
-                            label="Taille du noyau de convolution",
-                        )
+                    with gr.Column(visible=False) as rf_col:
+                        gr.Markdown("#### Paramètres Forêt aléatoire")
+                        rf_n_estimators = gr.Slider(minimum=10, maximum=500, value=100, step=10, label="Nombre d'arbres")
+                        rf_max_depth = gr.Number(value=0, label="Profondeur max (0 = illimitée)")
 
-                        use_batchnorm = gr.Checkbox(
-                            value=True,
-                            label="Normalisation par lots (BatchNorm)",
-                        )
+                    with gr.Column(visible=False) as lda_col:
+                        gr.Markdown("#### Paramètres LDA")
+                        lda_solver = gr.Dropdown(choices=["svd", "lsqr", "eigen"], value="svd", label="Solveur")
 
-                    gr.Markdown("#### Hyperparamètres d’entraînement")
+                    ml_model_tag = gr.Textbox(label="Nom court du modèle", placeholder="ex. svm_rbf")
+                    train_classical_btn = gr.Button("Entraîner le classifieur", variant="primary")
 
-                    dropout = gr.Slider(
-                        minimum=0.0,
-                        maximum=0.8,
-                        value=0.4,
-                        step=0.05,
-                        label="Dropout",
-                    )
-
-                    fc_dim = gr.Dropdown(
-                        choices=[64, 128, 256, 512],
-                        value=256,
-                        label="Dimension de la couche cachée (classifieur)",
-                    )
+                with gr.Column():
+                    ml_summary = gr.JSON(label="Résumé des métriques")
 
-                    learning_rate = gr.Number(
-                        value=0.001,
-                        label="Taux d’apprentissage",
-                    )
+            ml_report = gr.Dataframe(label="Rapport de classification", interactive=False)
+            ml_cm = gr.Dataframe(label="Matrice de confusion", interactive=False)
+            ml_cm_img = gr.Image(label="Matrice de confusion — figure", type="filepath")
 
-                    weight_decay = gr.Number(
-                        value=0.0001,
-                        label="Weight decay",
-                    )
+        # ------------------------------------------------------------------ #
+        # Tab 3
+        # ------------------------------------------------------------------ #
+        with gr.Tab("3. Modèles neuronaux"):
+            gr.Markdown("## Architecture")
 
-                    batch_size = gr.Dropdown(
-                        choices=[8, 16, 32, 64],
-                        value=16,
-                        label="Taille du batch",
+            with gr.Row():
+                with gr.Column():
+                    neural_type = gr.Radio(
+                        choices=["FC sur backbone préentraîné", "CNN de zéro"],
+                        value="FC sur backbone préentraîné",
+                        label="Type de modèle",
+                        info=(
+                            "FC sur backbone : backbone gelé, seule la tête FC est entraînée — rapide, peu de GPU. "
+                            "CNN de zéro : réseau convolutif entraîné entièrement depuis rien — référence sans transfert."
+                        ),
                     )
 
-                    epochs = gr.Slider(
-                        minimum=1,
-                        maximum=50,
-                        value=30,
-                        step=1,
-                        label="Nombre d’époques",
-                    )
+                    with gr.Column(visible=False) as cnn_arch_col:
+                        gr.Markdown("#### Architecture CNN")
+                        num_conv_blocks = gr.Slider(minimum=2, maximum=5, value=3, step=1, label="Blocs convolutionnels")
+                        base_filters = gr.Dropdown(choices=[16, 32, 64, 128], value=32, label="Filtres du premier bloc")
+                        kernel_size = gr.Dropdown(choices=[3, 5], value=3, label="Taille du noyau")
+                        use_batchnorm = gr.Checkbox(value=True, label="BatchNorm")
 
-                    model_tag = gr.Textbox(
-                        label="Nom court du modèle",
-                        placeholder="ex. cnn_3blocs ou resnet18_ft",
-                    )
+                    gr.Markdown("#### Hyperparamètres d'entraînement")
+                    n_dropout = gr.Slider(minimum=0.0, maximum=0.8, value=0.4, step=0.05, label="Dropout")
+                    n_fc_dim = gr.Dropdown(choices=[64, 128, 256, 512], value=256, label="Dimension couche cachée")
+                    n_lr = gr.Number(value=1e-4, label="Taux d'apprentissage")
+                    n_wd = gr.Number(value=1e-4, label="Weight decay")
+                    n_bs = gr.Dropdown(choices=[8, 16, 32, 64], value=16, label="Taille du batch")
+                    n_epochs = gr.Slider(minimum=1, maximum=50, value=20, step=1, label="Époques")
+                    n_tag = gr.Textbox(label="Nom court du modèle", placeholder="ex. fc_head_v1")
 
-                    train_btn = gr.Button("Lancer l’entraînement", variant="primary")
+                    train_neural_btn = gr.Button("Lancer l'entraînement", variant="primary")
 
                 with gr.Column():
-                    train_status = gr.Textbox(
-                        label="Journal d’entraînement",
-                        lines=18,
-                    )
-                    train_history = gr.JSON(label="Historique d’entraînement")
-                    train_summary = gr.JSON(label="Résumé final")
+                    neural_logs = gr.Textbox(label="Journal d'entraînement", lines=20)
+                    neural_history = gr.JSON(label="Historique")
+                    neural_summary = gr.JSON(label="Résumé final")
 
             gr.Markdown("## Résultats sur le test set")
-
-            train_report = gr.Dataframe(
-                label="Rapport de classification",
-                interactive=False,
-            )
-
-            train_confusion_matrix = gr.Dataframe(
-                label="Matrice de confusion",
-                interactive=False,
-            )
-
-            train_confusion_matrix_image = gr.Image(
-                label="Matrice de confusion - figure",
-                type="filepath",
-            )
-
-        with gr.Tab("3. Tester et analyser un modèle"):
+            neural_report = gr.Dataframe(label="Rapport de classification", interactive=False)
+            neural_cm = gr.Dataframe(label="Matrice de confusion", interactive=False)
+            neural_cm_img = gr.Image(label="Matrice de confusion — figure", type="filepath")
+
+        # ------------------------------------------------------------------ #
+        # Tab 4
+        # ------------------------------------------------------------------ #
+        with gr.Tab("4. Tester et analyser"):
             gr.Markdown("## Sélectionner un modèle sauvegardé")
+            gr.Markdown(
+                "_Tous les types de modèles apparaissent ici : classifieurs ML, têtes FC et CNN._"
+            )
 
             with gr.Row():
                 with gr.Column():
                     model_selector = gr.Dropdown(
                         choices=initial_models,
                         value=initial_models[0] if initial_models else None,
-                        label="Modèle sauvegardé",
+                        label="Modèle",
                     )
-
-                    refresh_btn = gr.Button("Actualiser la liste des modèles")
+                    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_info = gr.JSON(label="Métadonnées")
 
                 with gr.Column():
-                    evaluate_btn = gr.Button(
-                        "Évaluer le modèle sur le test set",
-                        variant="primary",
-                    )
+                    evaluate_btn = gr.Button("Évaluer sur le test set", variant="primary")
                     eval_summary = gr.JSON(label="Résumé des métriques")
 
-            eval_report = gr.Dataframe(
-                label="Rapport de classification",
-                interactive=False,
-            )
-
-            eval_confusion_matrix = gr.Dataframe(
-                label="Matrice de confusion",
-                interactive=False,
-            )
-
-            eval_confusion_matrix_image = gr.Image(
-                label="Matrice de confusion - figure",
-                type="filepath",
-            )
+            eval_report = gr.Dataframe(label="Rapport de classification", interactive=False)
+            eval_cm = gr.Dataframe(label="Matrice de confusion", interactive=False)
+            eval_cm_img = gr.Image(label="Matrice de confusion — figure", type="filepath")
 
             gr.Markdown("## Prédiction sur une image importée")
-
             with gr.Row():
                 with gr.Column():
                     upload_image = gr.Image(type="pil", label="Importer une image")
                     predict_btn = gr.Button("Prédire la classe", variant="primary")
-
                 with gr.Column():
-                    predict_text = gr.Textbox(label="Résultat de la prédiction", lines=7)
+                    predict_text = gr.Textbox(label="Résultat", lines=7)
                     predict_probs = gr.Label(label="Probabilités par classe")
 
             gr.Markdown("## Test sur un échantillon aléatoire du test set")
-
             random_test_btn = gr.Button("Tester un échantillon aléatoire")
-
             with gr.Row():
-                random_sample_image = gr.Image(type="pil", label="Image test aléatoire")
-                random_sample_text = gr.Textbox(label="Résultat sur l’échantillon", lines=7)
-                random_sample_probs = gr.Label(label="Probabilités par classe")
+                random_img = gr.Image(type="pil", label="Image test")
+                random_text = gr.Textbox(label="Résultat", lines=7)
+                random_probs = gr.Label(label="Probabilités par classe")
+
+    # ---------------------------------------------------------------------- #
+    # Event wiring
+    # ---------------------------------------------------------------------- #
 
     load_dataset_btn.click(
-        fn=load_dataset_overview_callback,
+        fn=load_dataset_callback,
         inputs=None,
         outputs=[dataset_summary, class_distribution, class_selector],
     )
@@ -396,74 +411,72 @@ with gr.Blocks(title="Classification d’images microscopiques") as demo:
         outputs=image_gallery,
     )
 
-    model_type.change(
-        fn=on_model_type_change,
-        inputs=model_type,
-        outputs=[cnn_params_col, learning_rate],
+    extract_btn.click(fn=extract_features_callback, inputs=None, outputs=extract_status)
+
+    clf_type.change(
+        fn=on_clf_type_change,
+        inputs=clf_type,
+        outputs=[svm_col, logreg_col, knn_col, rf_col, lda_col],
     )
 
-    train_btn.click(
-        fn=train_callback,
+    train_classical_btn.click(
+        fn=train_classical_callback,
         inputs=[
-            model_type,
-            num_conv_blocks,
-            base_filters,
-            kernel_size,
-            use_batchnorm,
-            dropout,
-            fc_dim,
-            learning_rate,
-            weight_decay,
-            batch_size,
-            epochs,
-            model_tag,
+            clf_type,
+            svm_c, svm_kernel, svm_gamma,
+            logreg_c, logreg_max_iter,
+            knn_k, knn_metric,
+            rf_n_estimators, rf_max_depth,
+            lda_solver,
+            ml_model_tag,
+        ],
+        outputs=[ml_summary, ml_report, ml_cm, ml_cm_img, model_selector],
+    )
+
+    neural_type.change(
+        fn=on_neural_type_change,
+        inputs=neural_type,
+        outputs=[cnn_arch_col, n_lr],
+    )
+
+    train_neural_btn.click(
+        fn=train_neural_callback,
+        inputs=[
+            neural_type,
+            num_conv_blocks, base_filters, kernel_size, use_batchnorm,
+            n_dropout, n_fc_dim,
+            n_lr, n_wd, n_bs, n_epochs,
+            n_tag,
         ],
         outputs=[
-            train_status,
-            train_history,
-            train_summary,
-            train_report,
-            train_confusion_matrix,
-            train_confusion_matrix_image,
+            neural_logs, neural_history, neural_summary,
+            neural_report, neural_cm, neural_cm_img,
             model_selector,
         ],
     )
 
-    refresh_btn.click(
-        fn=refresh_models_dropdown,
-        inputs=None,
-        outputs=model_selector,
-    )
+    refresh_btn.click(fn=refresh_models_callback, inputs=None, outputs=model_selector)
 
-    load_info_btn.click(
-        fn=get_model_info,
-        inputs=model_selector,
-        outputs=model_info,
-    )
+    load_info_btn.click(fn=get_model_info_callback, inputs=model_selector, outputs=model_info)
 
     evaluate_btn.click(
-        fn=evaluate_saved_model_callback,
+        fn=evaluate_callback,
         inputs=model_selector,
-        outputs=[
-            eval_summary,
-            eval_report,
-            eval_confusion_matrix,
-            eval_confusion_matrix_image,
-        ],
+        outputs=[eval_summary, eval_report, eval_cm, eval_cm_img],
     )
 
     predict_btn.click(
-        fn=predict_uploaded_image_callback,
+        fn=predict_callback,
         inputs=[model_selector, upload_image],
         outputs=[predict_text, predict_probs],
     )
 
     random_test_btn.click(
-        fn=test_random_sample_callback,
+        fn=random_test_callback,
         inputs=model_selector,
-        outputs=[random_sample_image, random_sample_text, random_sample_probs],
+        outputs=[random_img, random_text, random_probs],
     )
 
 
 if __name__ == "__main__":
-    demo.launch(ssr_mode=False)
+    demo.launch(ssr_mode=False)

backbone_utils.py

@@ -0,0 +1,81 @@
+import numpy as np
+import torch
+import torch.nn as nn
+from huggingface_hub import hf_hub_download
+from torch.utils.data import DataLoader
+from torchvision import models
+
+from config import HF_BACKBONE_REPO, HF_TOKEN
+
+_BACKBONE = None
+_FEATURES_CACHE = None
+
+
+def load_backbone(device: torch.device) -> nn.Module:
+    global _BACKBONE
+
+    if _BACKBONE is not None:
+        return _BACKBONE.to(device)
+
+    if not HF_BACKBONE_REPO:
+        raise RuntimeError(
+            "HF_BACKBONE_REPO n'est pas configuré. "
+            "Ajoutez-le dans les Secrets du Space Hugging Face."
+        )
+
+    pt_path = hf_hub_download(
+        repo_id=HF_BACKBONE_REPO,
+        filename="resnet18_charcoal_backbone.pt",
+        token=HF_TOKEN,
+        repo_type="model",
+    )
+
+    backbone = models.resnet18()
+    backbone.fc = nn.Identity()
+    backbone.load_state_dict(torch.load(pt_path, map_location="cpu"))
+
+    for p in backbone.parameters():
+        p.requires_grad = False
+
+    _BACKBONE = backbone
+    return _BACKBONE.to(device)
+
+
+def extract_all_features(batch_size: int = 64):
+    global _FEATURES_CACHE
+
+    from data_utils import prepare_splits, get_class_names, HFDatasetWrapper, get_eval_transform
+
+    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+    backbone = load_backbone(device)
+    backbone.eval()
+
+    splits = prepare_splits()
+    class_names = get_class_names()
+
+    cache = {}
+    counts = {}
+
+    for split_name, split_data in splits.items():
+        dataset = HFDatasetWrapper(split_data, get_eval_transform())
+        loader = DataLoader(dataset, batch_size=batch_size, shuffle=False)
+
+        X_parts, y_parts = [], []
+        with torch.no_grad():
+            for images, labels in loader:
+                features = backbone(images.to(device))
+                X_parts.append(features.cpu().numpy())
+                y_parts.append(labels.numpy())
+
+        cache[split_name] = {
+            "X": np.concatenate(X_parts, axis=0),
+            "y": np.concatenate(y_parts, axis=0),
+        }
+        counts[split_name] = len(cache[split_name]["y"])
+
+    _FEATURES_CACHE = cache
+    return cache, class_names, counts
+
+
+def get_cached_features():
+    return _FEATURES_CACHE

classical_ml_utils.py

@@ -0,0 +1,140 @@
+import json
+import os
+from datetime import datetime
+from typing import List
+
+import joblib
+from sklearn.discriminant_analysis import LinearDiscriminantAnalysis
+from sklearn.ensemble import RandomForestClassifier
+from sklearn.linear_model import LogisticRegression
+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
+from metrics_utils import compute_classification_metrics, save_confusion_matrix_figure
+
+CLF_TYPE_MAP = {
+    "SVM": "svm",
+    "Régression logistique": "logreg",
+    "k-NN": "knn",
+    "Forêt aléatoire": "rf",
+    "LDA": "lda",
+}
+
+
+def classifier_path(model_name: str) -> str:
+    return os.path.join(MODEL_DIR, f"{model_name}.joblib")
+
+
+def meta_path(model_name: str) -> str:
+    return os.path.join(META_DIR, f"{model_name}.json")
+
+
+def build_pipeline(clf_type: str, **params) -> Pipeline:
+    key = CLF_TYPE_MAP.get(clf_type, clf_type)
+
+    if key == "svm":
+        clf = SVC(
+            C=params.get("C", 1.0),
+            kernel=params.get("kernel", "rbf"),
+            gamma=params.get("gamma", "scale"),
+            probability=True,
+            random_state=42,
+        )
+    elif key == "logreg":
+        clf = LogisticRegression(
+            C=params.get("C", 1.0),
+            max_iter=params.get("max_iter", 1000),
+            random_state=42,
+        )
+    elif key == "knn":
+        clf = KNeighborsClassifier(
+            n_neighbors=params.get("n_neighbors", 5),
+            metric=params.get("metric", "euclidean"),
+        )
+    elif key == "rf":
+        max_depth = params.get("max_depth") or None
+        clf = RandomForestClassifier(
+            n_estimators=params.get("n_estimators", 100),
+            max_depth=max_depth,
+            random_state=42,
+            n_jobs=-1,
+        )
+    elif key == "lda":
+        clf = LinearDiscriminantAnalysis(solver=params.get("solver", "svd"))
+    else:
+        raise ValueError(f"Classifieur inconnu : {clf_type}")
+
+    return Pipeline([("scaler", StandardScaler()), ("clf", clf)])
+
+
+def train_classical_model(
+    clf_type: str,
+    features_cache: dict,
+    class_names: List[str],
+    model_tag: str = "",
+    **params,
+):
+    X_train = features_cache["train"]["X"]
+    y_train = features_cache["train"]["y"]
+    X_test = features_cache["test"]["X"]
+    y_test = features_cache["test"]["y"]
+
+    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)
+
+    timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+    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))
+    cm_path = save_confusion_matrix_figure(metrics["confusion_matrix"], model_name)
+
+    config_dict = {
+        "model_type": CLF_TYPE_MAP.get(clf_type, clf_type),
+        "clf_type_label": clf_type,
+        "class_names": class_names,
+        "num_classes": len(class_names),
+        **{k: v for k, v in params.items() if v is not None},
+    }
+
+    training_summary = {
+        "test_accuracy": metrics["accuracy"],
+        "test_f1_macro": metrics["f1_macro"],
+        "test_f1_weighted": metrics["f1_weighted"],
+        "train_samples": int(len(X_train)),
+        "test_samples": int(len(X_test)),
+    }
+
+    with open(meta_path(model_name), "w", encoding="utf-8") as f:
+        json.dump(
+            {
+                "model_name": model_name,
+                "config": config_dict,
+                "training_summary": training_summary,
+                "created_at": datetime.now().strftime("%Y-%m-%d %H:%M:%S"),
+            },
+            f,
+            indent=2,
+            ensure_ascii=False,
+        )
+
+    return {
+        "model_name": model_name,
+        "summary": training_summary,
+        "classification_report": metrics["classification_report"],
+        "confusion_matrix": metrics["confusion_matrix"],
+        "confusion_matrix_path": cm_path,
+    }
+
+
+def load_classical_pipeline(model_name: str) -> Pipeline:
+    path = classifier_path(model_name)
+    if not os.path.exists(path):
+        raise FileNotFoundError(f"Classifieur introuvable : {model_name}")
+    return joblib.load(path)

config.py

@@ -10,13 +10,13 @@ os.makedirs(MODEL_DIR, exist_ok=True)
 os.makedirs(META_DIR, exist_ok=True)
 os.makedirs(FIGURE_DIR, exist_ok=True)
 
-# Replace this with your real private dataset repo
 HF_DATASET_REPO = os.environ.get("HF_DATASET_REPO", "CircleStar/charcoal-microscopy")
-
-# Must be added in Hugging Face Space Settings → Secrets
+HF_BACKBONE_REPO = os.environ.get("HF_BACKBONE_REPO", "")
 HF_TOKEN = os.environ.get("HF_TOKEN")
 
 IMAGE_SIZE = 224
 RANDOM_SEED = 42
 
-DATASET_DISPLAY_NAME = "Images microscopiques de charbons de bois"
+DATASET_DISPLAY_NAME = "Images microscopiques de charbons de bois"
+
+CLASSICAL_MODEL_TYPES = frozenset({"svm", "logreg", "knn", "rf", "lda"})

data_utils.py

@@ -24,7 +24,7 @@ class HFDatasetWrapper(Dataset):
 
     def __len__(self):
         return len(self.dataset)
-
+·
     def __getitem__(self, idx):
         item = self.dataset[idx]
 

finetune_backbone.py

@@ -0,0 +1,245 @@
+"""
+finetune_backbone.py
+
+Fine-tune ResNet18 (ImageNet) on the local charcoal microscopy dataset.
+Goal: produce a domain-adapted backbone for students to use as a frozen
+feature extractor. The full dataset is used intentionally — this is a
+teaching artifact, not a research model with a held-out test split.
+
+Output (in backbone/):
+  resnet18_charcoal_backbone.pt  — backbone weights, FC replaced by Identity
+  backbone_meta.json             — class names, feature dim, training info
+
+Usage:
+  python finetune_backbone.py
+  python finetune_backbone.py --epochs 40 --batch-size 16
+"""
+
+import argparse
+import json
+import time
+from pathlib import Path
+
+import torch
+import torch.nn as nn
+import torch.optim as optim
+from PIL import Image
+from torch.utils.data import DataLoader, Dataset
+from torchvision import models, transforms
+
+# ---------------------------------------------------------------------------
+# Paths
+# ---------------------------------------------------------------------------
+ROOT = Path(__file__).parent
+DATA_DIR = ROOT / "data"
+OUTPUT_DIR = ROOT / "backbone"
+OUTPUT_DIR.mkdir(exist_ok=True)
+
+# ---------------------------------------------------------------------------
+# Defaults
+# ---------------------------------------------------------------------------
+IMAGE_SIZE = 224
+SEED = 42
+
+WARMUP_EPOCHS = 10       # backbone frozen, only FC trained
+WARMUP_LR = 1e-3
+
+FINETUNE_EPOCHS = 40     # all layers unfrozen, small LR
+FINETUNE_LR = 5e-5
+WEIGHT_DECAY = 1e-4
+
+
+# ---------------------------------------------------------------------------
+# Dataset
+# ---------------------------------------------------------------------------
+class CharcoalDataset(Dataset):
+    """Flat ImageFolder-style dataset that handles .tif files."""
+
+    EXTENSIONS = {".tif", ".tiff", ".jpg", ".jpeg", ".png"}
+
+    def __init__(self, root: Path, transform=None):
+        self.transform = transform
+        self.classes = sorted(
+            d.name for d in root.iterdir()
+            if d.is_dir() and not d.name.startswith(".")
+        )
+        self.class_to_idx = {c: i for i, c in enumerate(self.classes)}
+
+        self.samples = []
+        for cls in self.classes:
+            for p in sorted((root / cls).iterdir()):
+                if p.suffix.lower() in self.EXTENSIONS:
+                    self.samples.append((p, self.class_to_idx[cls]))
+
+    def __len__(self):
+        return len(self.samples)
+
+    def __getitem__(self, idx):
+        path, label = self.samples[idx]
+        image = Image.open(path).convert("RGB")
+        if self.transform:
+            image = self.transform(image)
+        return image, label
+
+
+def make_transform():
+    # Aggressive augmentation: microscopy images have no canonical orientation
+    # and vary in staining intensity.
+    return transforms.Compose([
+        transforms.Resize((IMAGE_SIZE, IMAGE_SIZE)),
+        transforms.RandomHorizontalFlip(),
+        transforms.RandomVerticalFlip(),
+        transforms.RandomRotation(180),
+        transforms.ColorJitter(brightness=0.3, contrast=0.3, saturation=0.2),
+        transforms.RandomAffine(degrees=0, translate=(0.1, 0.1), scale=(0.85, 1.15)),
+        transforms.ToTensor(),
+        transforms.Normalize(mean=(0.485, 0.456, 0.406), std=(0.229, 0.224, 0.225)),
+    ])
+
+
+# ---------------------------------------------------------------------------
+# Training helpers
+# ---------------------------------------------------------------------------
+def run_epoch(model, loader, criterion, optimizer, device):
+    model.train()
+    total_loss, correct, total = 0.0, 0, 0
+
+    for images, labels in loader:
+        images, labels = images.to(device), labels.to(device)
+
+        optimizer.zero_grad()
+        outputs = model(images)
+        loss = criterion(outputs, labels)
+        loss.backward()
+        torch.nn.utils.clip_grad_norm_(model.parameters(), max_norm=1.0)
+        optimizer.step()
+
+        total_loss += loss.item() * images.size(0)
+        correct += (outputs.argmax(1) == labels).sum().item()
+        total += labels.size(0)
+
+    return total_loss / total, correct / total
+
+
+# ---------------------------------------------------------------------------
+# Main
+# ---------------------------------------------------------------------------
+def main():
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--warmup-epochs", type=int, default=WARMUP_EPOCHS)
+    parser.add_argument("--finetune-epochs", type=int, default=FINETUNE_EPOCHS)
+    parser.add_argument("--batch-size", type=int, default=8)
+    parser.add_argument("--warmup-lr", type=float, default=WARMUP_LR)
+    parser.add_argument("--finetune-lr", type=float, default=FINETUNE_LR)
+    args = parser.parse_args()
+
+    torch.manual_seed(SEED)
+    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+    print(f"Device : {device}")
+
+    dataset = CharcoalDataset(DATA_DIR, transform=make_transform())
+    num_classes = len(dataset.classes)
+    print(f"Classes : {num_classes}  |  Images : {len(dataset)}")
+    print(f"  {', '.join(dataset.classes)}\n")
+
+    loader = DataLoader(
+        dataset,
+        batch_size=args.batch_size,
+        shuffle=True,
+        num_workers=0,       # 0 = safe on Windows
+        pin_memory=(device.type == "cuda"),
+    )
+
+    # -----------------------------------------------------------------------
+    # Build model
+    # -----------------------------------------------------------------------
+    model = models.resnet18(weights=models.ResNet18_Weights.DEFAULT)
+    model.fc = nn.Linear(model.fc.in_features, num_classes)
+    model.to(device)
+
+    # Label smoothing helps regularise with tiny datasets
+    criterion = nn.CrossEntropyLoss(label_smoothing=0.1)
+
+    # -----------------------------------------------------------------------
+    # Phase 1 — warm-up: freeze backbone, train FC only
+    # -----------------------------------------------------------------------
+    print(f"=== Phase 1 : warm-up  ({args.warmup_epochs} epochs, backbone frozen) ===")
+    for p in model.parameters():
+        p.requires_grad = False
+    for p in model.fc.parameters():
+        p.requires_grad = True
+
+    optimizer = optim.AdamW(model.fc.parameters(), lr=args.warmup_lr, weight_decay=WEIGHT_DECAY)
+
+    for epoch in range(1, args.warmup_epochs + 1):
+        loss, acc = run_epoch(model, loader, criterion, optimizer, device)
+        print(f"  [{epoch:>3}/{args.warmup_epochs}]  loss={loss:.4f}  acc={acc:.4f}")
+
+    # -----------------------------------------------------------------------
+    # Phase 2 — full fine-tune: unfreeze all layers
+    # -----------------------------------------------------------------------
+    print(f"\n=== Phase 2 : fine-tune ({args.finetune_epochs} epochs, all layers) ===")
+    for p in model.parameters():
+        p.requires_grad = True
+
+    optimizer = optim.AdamW(
+        model.parameters(), lr=args.finetune_lr, weight_decay=WEIGHT_DECAY
+    )
+    scheduler = optim.lr_scheduler.CosineAnnealingLR(
+        optimizer, T_max=args.finetune_epochs, eta_min=args.finetune_lr * 0.05
+    )
+
+    best_acc = 0.0
+    best_state = None
+    t0 = time.time()
+
+    for epoch in range(1, args.finetune_epochs + 1):
+        loss, acc = run_epoch(model, loader, criterion, optimizer, device)
+        scheduler.step()
+        lr = optimizer.param_groups[0]["lr"]
+        print(f"  [{epoch:>3}/{args.finetune_epochs}]  loss={loss:.4f}  acc={acc:.4f}  lr={lr:.2e}")
+
+        if acc > best_acc:
+            best_acc = acc
+            best_state = {k: v.detach().cpu().clone() for k, v in model.state_dict().items()}
+
+    elapsed = time.time() - t0
+    print(f"\nTemps phase 2 : {elapsed:.0f}s  |  Meilleure accuracy entraînement : {best_acc:.4f}")
+
+    # -----------------------------------------------------------------------
+    # Save backbone (FC replaced by Identity — outputs 512-dim feature vector)
+    # -----------------------------------------------------------------------
+    model.load_state_dict(best_state)
+
+    backbone = models.resnet18()
+    backbone.fc = nn.Identity()
+
+    # Transfer all weights except fc (which is now Identity with no parameters)
+    backbone_state = {k: v for k, v in best_state.items() if not k.startswith("fc.")}
+    backbone.load_state_dict(backbone_state, strict=False)
+
+    backbone_path = OUTPUT_DIR / "resnet18_charcoal_backbone.pt"
+    torch.save(backbone.state_dict(), backbone_path)
+    print(f"Backbone sauvegardé : {backbone_path}")
+
+    # -----------------------------------------------------------------------
+    # Save metadata
+    # -----------------------------------------------------------------------
+    meta = {
+        "classes": dataset.classes,
+        "num_classes": num_classes,
+        "image_size": IMAGE_SIZE,
+        "feature_dim": 512,
+        "warmup_epochs": args.warmup_epochs,
+        "finetune_epochs": args.finetune_epochs,
+        "best_train_acc": round(float(best_acc), 4),
+        "device": str(device),
+    }
+    meta_path = OUTPUT_DIR / "backbone_meta.json"
+    with open(meta_path, "w", encoding="utf-8") as f:
+        json.dump(meta, f, indent=2, ensure_ascii=False)
+    print(f"Métadonnées sauvegardées : {meta_path}")
+
+
+if __name__ == "__main__":
+    main()

model.py

@@ -1,33 +1,22 @@
 import torch.nn as nn
-from torchvision import models
 
 
-class ResNet18Classifier(nn.Module):
-    def __init__(self, num_classes: int, dropout: float = 0.4, fc_dim: int = 256):
-        super().__init__()
-
-        weights = models.ResNet18_Weights.DEFAULT
-        self.backbone = models.resnet18(weights=weights)
-        in_features = self.backbone.fc.in_features
-
-        # Gel de tout le réseau sauf layer4 et classifieur
-        for param in self.backbone.parameters():
-            param.requires_grad = False
-        for param in self.backbone.layer4.parameters():
-            param.requires_grad = True
+class BackboneWithFC(nn.Module):
+    """Frozen ResNet18 backbone + trainable FC classifier head."""
 
-        self.backbone.fc = nn.Sequential(
+    def __init__(self, backbone: nn.Module, num_classes: int, dropout: float = 0.4, fc_dim: int = 256):
+        super().__init__()
+        self.backbone = backbone
+        self.classifier = nn.Sequential(
             nn.Dropout(dropout),
-            nn.Linear(in_features, fc_dim),
-            nn.ReLU(),
+            nn.Linear(512, fc_dim),
+            nn.ReLU(inplace=True),
             nn.Dropout(dropout),
             nn.Linear(fc_dim, num_classes),
         )
-        for param in self.backbone.fc.parameters():
-            param.requires_grad = True
 
     def forward(self, x):
-        return self.backbone(x)
+        return self.classifier(self.backbone(x))
 
 
 class SimpleCNN(nn.Module):
@@ -48,7 +37,6 @@ class SimpleCNN(nn.Module):
         in_channels = 3
 
         for i in range(num_conv_blocks):
-            # Les filtres doublent à chaque bloc, plafonnés à 512
             out_channels = min(base_filters * (2 ** i), 512)
             layers.append(nn.Conv2d(in_channels, out_channels, kernel_size, padding=padding))
             if use_batchnorm:
@@ -58,7 +46,6 @@ class SimpleCNN(nn.Module):
             in_channels = out_channels
 
         self.features = nn.Sequential(*layers)
-        # Pooling global : indépendant de la taille spatiale d'entrée
         self.pool = nn.AdaptiveAvgPool2d(1)
 
         self.classifier = nn.Sequential(
@@ -70,7 +57,5 @@ class SimpleCNN(nn.Module):
         )
 
     def forward(self, x):
-        x = self.features(x)
-        x = self.pool(x)
-        x = x.flatten(1)
-        return self.classifier(x)
+        x = self.pool(self.features(x))
+        return self.classifier(x.flatten(1))

predict_utils.py

@@ -1,41 +1,56 @@
 import random
 
+import numpy as np
 import torch
 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, get_runtime_device
+from train_utils import load_model, get_runtime_device, _load_meta
+
+
+def _extract_feature(image: Image.Image, device: torch.device) -> np.ndarray:
+    from backbone_utils import load_backbone
+    backbone = load_backbone(device)
+    backbone.eval()
+    tensor = get_eval_transform()(image.convert("RGB")).unsqueeze(0).to(device)
+    with torch.no_grad():
+        feat = backbone(tensor)
+    return feat.cpu().numpy()
 
 
 def predict_uploaded_image(model_name: str, image: Image.Image):
     if not model_name:
         return "Veuillez sélectionner un modèle.", None
-
     if image is None:
         return "Veuillez importer une image.", None
 
-    device = get_runtime_device()
-    model, meta = load_model(model_name, device)
-
+    meta = _load_meta(model_name)
+    model_type = meta["config"].get("model_type", "cnn")
     class_names = meta["config"]["class_names"]
-    transform = get_eval_transform()
-
-    image = image.convert("RGB")
-    tensor = transform(image).unsqueeze(0).to(device)
+    device = get_runtime_device()
 
-    with torch.no_grad():
-        logits = model(tensor)
-        probs = torch.softmax(logits, dim=1).squeeze(0).cpu().tolist()
-        pred_idx = int(torch.argmax(logits, dim=1).item())
+    if model_type in CLASSICAL_MODEL_TYPES:
+        from classical_ml_utils import load_classical_pipeline
+        pipeline = load_classical_pipeline(model_name)
+        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)
+        tensor = get_eval_transform()(image.convert("RGB")).unsqueeze(0).to(device)
+        with torch.no_grad():
+            logits = model(tensor)
+            probs = torch.softmax(logits, dim=1).squeeze(0).cpu().tolist()
+            pred_idx = int(torch.argmax(logits, dim=1).item())
 
     result_text = (
         f"Prédiction : {class_names[pred_idx]}\n"
         f"Confiance : {max(probs):.4f}\n\n"
         f"Modèle : {model_name}\n"
-        f"Jeu de données : {meta['config']['dataset_name']}\n"
-        f"Appareil utilisé : {device}"
+        f"Type : {model_type}\n"
+        f"Appareil : {device}"
     )
-
     prob_dict = {class_names[i]: float(probs[i]) for i in range(len(class_names))}
     return result_text, prob_dict
 
@@ -44,40 +59,44 @@ def test_random_sample(model_name: str):
     if not model_name:
         return None, "Veuillez sélectionner un modèle.", None
 
+    meta = _load_meta(model_name)
+    model_type = meta["config"].get("model_type", "cnn")
+    class_names = get_class_names()
     device = get_runtime_device()
-    model, meta = load_model(model_name, device)
 
     splits = prepare_splits()
-    class_names = get_class_names()
     test_dataset = splits["test"]
 
     idx = random.randint(0, len(test_dataset) - 1)
     item = test_dataset[idx]
-
     image = item["image"]
     if not isinstance(image, Image.Image):
         image = Image.open(image)
-
     image = image.convert("RGB")
-
-    label = int(item["label"])
-    label_name = class_names[label]
-
-    transform = get_eval_transform()
-    tensor = transform(image).unsqueeze(0).to(device)
-
-    with torch.no_grad():
-        logits = model(tensor)
-        probs = torch.softmax(logits, dim=1).squeeze(0).cpu().tolist()
-        pred_idx = int(torch.argmax(logits, dim=1).item())
-
+    label_name = class_names[int(item["label"])]
+
+    if model_type in CLASSICAL_MODEL_TYPES:
+        from classical_ml_utils import load_classical_pipeline
+        pipeline = load_classical_pipeline(model_name)
+        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)
+        tensor = get_eval_transform()(image).unsqueeze(0).to(device)
+        with torch.no_grad():
+            logits = model(tensor)
+            probs = torch.softmax(logits, dim=1).squeeze(0).cpu().tolist()
+            pred_idx = int(torch.argmax(logits, dim=1).item())
+
+    model_class_names = meta["config"]["class_names"]
     result_text = (
         f"Échantillon test aléatoire\n"
         f"Vérité terrain : {label_name}\n"
-        f"Prédiction : {class_names[pred_idx]}\n"
-        f"Confiance : {max(probs):.4f}\n"
-        f"Appareil utilisé : {device}"
+        f"Prédiction    : {model_class_names[pred_idx]}\n"
+        f"Confiance     : {max(probs):.4f}\n"
+        f"Type modèle   : {model_type}\n"
+        f"Appareil      : {device}"
     )
-
-    prob_dict = {class_names[i]: float(probs[i]) for i in range(len(class_names))}
-    return image, result_text, prob_dict
+    prob_dict = {model_class_names[i]: float(probs[i]) for i in range(len(model_class_names))}
+    return image, result_text, prob_dict

train_utils.py

@@ -8,16 +8,24 @@ import torch
 import torch.nn as nn
 import torch.optim as optim
 
-from config import MODEL_DIR, META_DIR, DATASET_DISPLAY_NAME
+from config import MODEL_DIR, META_DIR, DATASET_DISPLAY_NAME, CLASSICAL_MODEL_TYPES
 from data_utils import make_loaders
 from metrics_utils import compute_classification_metrics, save_confusion_matrix_figure
-from model import SimpleCNN, ResNet18Classifier
+from model import SimpleCNN, BackboneWithFC
 
 
+# ---------------------------------------------------------------------------
+# Path helpers
+# ---------------------------------------------------------------------------
+
 def model_weight_path(model_name: str) -> str:
     return os.path.join(MODEL_DIR, 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) -> str:
     return os.path.join(META_DIR, f"{model_name}.json")
 
@@ -34,43 +42,54 @@ def get_runtime_device() -> torch.device:
     return torch.device("cuda" if torch.cuda.is_available() else "cpu")
 
 
+# ---------------------------------------------------------------------------
+# Save / load
+# ---------------------------------------------------------------------------
+
 def save_model(model: nn.Module, model_name: str, config: dict, training_summary: dict):
-    cpu_state_dict = {k: v.detach().cpu() for k, v in model.state_dict().items()}
-    torch.save(cpu_state_dict, model_weight_path(model_name))
+    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()}
 
-    payload = {
-        "model_name": model_name,
-        "config": config,
-        "training_summary": training_summary,
-        "created_at": datetime.now().strftime("%Y-%m-%d %H:%M:%S"),
-    }
+    torch.save(state_dict, model_weight_path(model_name))
 
     with open(model_meta_path(model_name), "w", encoding="utf-8") as f:
-        json.dump(payload, f, indent=2, ensure_ascii=False)
-
-
-def load_model(model_name: str, device: torch.device) -> Tuple[nn.Module, dict]:
-    meta_file = model_meta_path(model_name)
-    weight_file = model_weight_path(model_name)
+        json.dump(
+            {
+                "model_name": model_name,
+                "config": config,
+                "training_summary": training_summary,
+                "created_at": datetime.now().strftime("%Y-%m-%d %H:%M:%S"),
+            },
+            f,
+            indent=2,
+            ensure_ascii=False,
+        )
 
-    if not os.path.exists(meta_file):
-        raise FileNotFoundError(f"Métadonnées introuvables pour le modèle : {model_name}")
 
-    if not os.path.exists(weight_file):
-        raise FileNotFoundError(f"Poids introuvables pour le modèle : {model_name}")
+def _load_meta(model_name: str) -> dict:
+    path = model_meta_path(model_name)
+    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)
 
-    with open(meta_file, "r", encoding="utf-8") as f:
-        meta = json.load(f)
 
+def load_model(model_name: str, device: torch.device) -> Tuple[nn.Module, dict]:
+    meta = _load_meta(model_name)
     cfg = meta["config"]
-
-    if cfg.get("model_type", "cnn") == "resnet18":
-        model = ResNet18Classifier(
-            num_classes=cfg["num_classes"],
-            dropout=cfg.get("dropout", 0.4),
-            fc_dim=cfg.get("fc_dim", 256),
+    model_type = cfg.get("model_type", "cnn")
+
+    if model_type == "fc_head":
+        from backbone_utils import load_backbone
+        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")
         )
-    else:
+
+    elif model_type == "cnn":
         model = SimpleCNN(
             num_classes=cfg["num_classes"],
             num_conv_blocks=cfg.get("num_conv_blocks", 3),
@@ -80,206 +99,264 @@ 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"))
+
+    else:
+        raise ValueError(f"load_model n'accepte pas le type '{model_type}'. Utilisez load_classical_pipeline pour les modèles ML classiques.")
 
-    state_dict = torch.load(weight_file, map_location="cpu")
-    model.load_state_dict(state_dict)
     model.to(device)
     model.eval()
-
     return model, meta
 
 
+# ---------------------------------------------------------------------------
+# Training helpers
+# ---------------------------------------------------------------------------
+
 def evaluate_loss_acc(model, loader, criterion, device):
     model.eval()
-
-    total_loss = 0.0
-    total = 0
-    correct = 0
+    total_loss, total, correct = 0.0, 0, 0
 
     with torch.no_grad():
         for images, labels in loader:
             images, labels = images.to(device), labels.to(device)
-
             outputs = model(images)
             loss = criterion(outputs, labels)
-
             total_loss += loss.item() * images.size(0)
-            preds = outputs.argmax(dim=1)
-
-            correct += (preds == labels).sum().item()
+            correct += (outputs.argmax(1) == labels).sum().item()
             total += labels.size(0)
 
-    avg_loss = total_loss / total if total else 0.0
-    acc = correct / total if total else 0.0
-
-    return avg_loss, acc
+    return (total_loss / total if total else 0.0), (correct / total if total else 0.0)
 
 
 def collect_predictions(model, loader, device):
     model.eval()
-
-    y_true = []
-    y_pred = []
+    y_true, y_pred = [], []
 
     with torch.no_grad():
         for images, labels in loader:
-            images = images.to(device)
-
-            outputs = model(images)
-            preds = outputs.argmax(dim=1).detach().cpu().tolist()
-
-            y_pred.extend(preds)
+            outputs = model(images.to(device))
+            y_pred.extend(outputs.argmax(1).detach().cpu().tolist())
             y_true.extend(labels.tolist())
 
     return y_true, y_pred
 
 
-def train_model(
-    model_type: str = "cnn",
-    num_conv_blocks: int = 3,
-    base_filters: int = 32,
-    kernel_size: int = 3,
-    use_batchnorm: bool = True,
-    dropout: float = 0.4,
-    fc_dim: int = 256,
-    learning_rate: float = 0.001,
-    weight_decay: float = 0.0001,
-    batch_size: int = 16,
-    epochs: int = 30,
-    model_tag: str = "",
-):
-    device = get_runtime_device()
-
-    train_loader, val_loader, test_loader, class_names = make_loaders(batch_size)
-    num_classes = len(class_names)
-
-    if model_type == "resnet18":
-        model = ResNet18Classifier(
-            num_classes=num_classes,
-            dropout=dropout,
-            fc_dim=fc_dim,
-        ).to(device)
-    else:
-        model = SimpleCNN(
-            num_classes=num_classes,
-            num_conv_blocks=num_conv_blocks,
-            base_filters=base_filters,
-            kernel_size=kernel_size,
-            use_batchnorm=use_batchnorm,
-            dropout=dropout,
-            fc_dim=fc_dim,
-        ).to(device)
-
-    trainable_params = sum(p.numel() for p in model.parameters() if p.requires_grad)
-    total_params = sum(p.numel() for p in model.parameters())
-
-    criterion = nn.CrossEntropyLoss()
-
-    optimizer = optim.AdamW(
-        filter(lambda p: p.requires_grad, model.parameters()),
-        lr=learning_rate,
-        weight_decay=weight_decay,
-    )
-
-    # Réduit le LR de moitié si val_loss ne s'améliore pas pendant 8 époques
-    # patience élevée car le val set est très petit (bruit important)
-    scheduler = optim.lr_scheduler.ReduceLROnPlateau(
-        optimizer,
-        mode="min",
-        factor=0.5,
-        patience=8,
-        min_lr=learning_rate * 0.2,
-    )
-
+def _training_loop(model, train_loader, val_loader, criterion, optimizer, scheduler, epochs, device):
     history = []
     logs = []
-    start_time = time.time()
-
     best_val_loss = float("inf")
-    best_state_dict = None
+    best_state = None
 
     for epoch in range(1, epochs + 1):
         model.train()
-
-        running_loss = 0.0
-        total = 0
-        correct = 0
+        running_loss, total, correct = 0.0, 0, 0
 
         for images, labels in train_loader:
             images, labels = images.to(device), labels.to(device)
-
             optimizer.zero_grad()
             outputs = model(images)
-
             loss = criterion(outputs, labels)
             loss.backward()
-
-            # Important: prevents unstable fine-tuning / exploding gradients
             torch.nn.utils.clip_grad_norm_(model.parameters(), max_norm=1.0)
-
             optimizer.step()
 
             running_loss += loss.item() * images.size(0)
-
-            preds = outputs.argmax(dim=1)
-            correct += (preds == labels).sum().item()
+            correct += (outputs.argmax(1) == labels).sum().item()
             total += labels.size(0)
 
         train_loss = running_loss / total if total else 0.0
         train_acc = correct / total if total else 0.0
-
         val_loss, val_acc = evaluate_loss_acc(model, val_loader, criterion, device)
         scheduler.step(val_loss)
         current_lr = optimizer.param_groups[0]["lr"]
 
         if val_loss < best_val_loss:
             best_val_loss = val_loss
-            best_state_dict = {
-                k: v.detach().cpu().clone()
-                for k, v in model.state_dict().items()
-            }
+            best_state = {k: v.detach().cpu().clone() for k, v in model.state_dict().items()}
 
-        row = {
+        history.append({
             "epoch": epoch,
             "train_loss": round(train_loss, 4),
             "train_acc": round(train_acc, 4),
             "val_loss": round(val_loss, 4),
             "val_acc": round(val_acc, 4),
-        }
-
-        history.append(row)
-
+        })
         logs.append(
             f"Époque {epoch}/{epochs} | "
-            f"perte entraînement={train_loss:.4f}, précision entraînement={train_acc:.4f}, "
-            f"perte validation={val_loss:.4f}, précision validation={val_acc:.4f}, "
-            f"lr={current_lr:.6f}"
+            f"perte train={train_loss:.4f} acc train={train_acc:.4f} | "
+            f"perte val={val_loss:.4f} acc val={val_acc:.4f} | "
+            f"lr={current_lr:.2e}"
         )
 
-    if best_state_dict is not None:
-        model.load_state_dict(best_state_dict)
+    return history, logs, best_state, best_val_loss
 
+
+# ---------------------------------------------------------------------------
+# Train FC head on frozen backbone
+# ---------------------------------------------------------------------------
+
+def train_fc_head(
+    dropout: float = 0.4,
+    fc_dim: int = 256,
+    learning_rate: float = 1e-4,
+    weight_decay: float = 1e-4,
+    batch_size: int = 16,
+    epochs: int = 20,
+    model_tag: str = "",
+):
+    from backbone_utils import load_backbone
+
+    device = get_runtime_device()
+    train_loader, val_loader, test_loader, class_names = make_loaders(batch_size)
+    num_classes = len(class_names)
+
+    backbone = load_backbone(device)
+
+    model = BackboneWithFC(backbone, num_classes, dropout, fc_dim).to(device)
+
+    trainable_params = sum(p.numel() for p in model.classifier.parameters())
+    total_params = sum(p.numel() for p in model.parameters())
+
+    criterion = nn.CrossEntropyLoss()
+    optimizer = optim.AdamW(model.classifier.parameters(), lr=learning_rate, weight_decay=weight_decay)
+    scheduler = optim.lr_scheduler.ReduceLROnPlateau(
+        optimizer, mode="min", factor=0.5, patience=5, min_lr=learning_rate * 0.1
+    )
+
+    t0 = time.time()
+    history, logs, best_state, best_val_loss = _training_loop(
+        model, train_loader, val_loader, criterion, optimizer, scheduler, epochs, device
+    )
+
+    model.load_state_dict(best_state)
     test_loss, test_acc = evaluate_loss_acc(model, test_loader, criterion, device)
     y_true, y_pred = collect_predictions(model, test_loader, device)
-
     metrics = compute_classification_metrics(y_true, y_pred, class_names)
+    elapsed = time.time() - t0
 
-    elapsed = time.time() - start_time
+    timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+    safe_tag = model_tag.strip().replace(" ", "_") if model_tag.strip() else "fc_head"
+    model_name = f"{safe_tag}_{timestamp}"
+
+    cm_path = save_confusion_matrix_figure(metrics["confusion_matrix"], model_name)
+
+    config = {
+        "dataset_name": DATASET_DISPLAY_NAME,
+        "model_type": "fc_head",
+        "architecture": f"ResNet18 backbone (gelé) + FC({fc_dim})",
+        "num_classes": num_classes,
+        "class_names": class_names,
+        "dropout": dropout,
+        "fc_dim": fc_dim,
+        "learning_rate": learning_rate,
+        "weight_decay": weight_decay,
+        "batch_size": batch_size,
+        "epochs": epochs,
+    }
+
+    training_summary = {
+        "final_train_loss": history[-1]["train_loss"] if history else None,
+        "final_train_acc": history[-1]["train_acc"] if history else None,
+        "best_val_loss": round(best_val_loss, 4),
+        "final_val_loss": history[-1]["val_loss"] if history else None,
+        "final_val_acc": history[-1]["val_acc"] if history else None,
+        "test_cross_entropy_loss": round(test_loss, 4),
+        "test_accuracy": round(test_acc, 4),
+        "test_f1_macro": metrics["f1_macro"],
+        "test_f1_weighted": metrics["f1_weighted"],
+        "elapsed_seconds": round(elapsed, 2),
+        "device": str(device),
+        "total_params": total_params,
+        "trainable_params": trainable_params,
+    }
+
+    save_model(model, model_name, config, training_summary)
+
+    logs += [
+        "",
+        "Entraînement terminé.",
+        f"Modèle sauvegardé : {model_name}",
+        f"Architecture : {config['architecture']}",
+        f"Paramètres entraînables : {trainable_params} / {total_params}",
+        f"Perte test : {test_loss:.4f}  |  Accuracy test : {test_acc:.4f}",
+        f"F1 macro : {metrics['f1_macro']:.4f}  |  F1 pondéré : {metrics['f1_weighted']:.4f}",
+        f"Temps : {elapsed:.1f}s  |  Appareil : {device}",
+    ]
+
+    return {
+        "logs": "\n".join(logs),
+        "history": history,
+        "summary": training_summary,
+        "model_name": model_name,
+        "classification_report": metrics["classification_report"],
+        "confusion_matrix": metrics["confusion_matrix"],
+        "confusion_matrix_path": cm_path,
+    }
+
+
+# ---------------------------------------------------------------------------
+# Train SimpleCNN from scratch
+# ---------------------------------------------------------------------------
+
+def train_cnn(
+    num_conv_blocks: int = 3,
+    base_filters: int = 32,
+    kernel_size: int = 3,
+    use_batchnorm: bool = True,
+    dropout: float = 0.4,
+    fc_dim: int = 256,
+    learning_rate: float = 1e-3,
+    weight_decay: float = 1e-4,
+    batch_size: int = 16,
+    epochs: int = 30,
+    model_tag: str = "",
+):
+    device = get_runtime_device()
+    train_loader, val_loader, test_loader, class_names = make_loaders(batch_size)
+    num_classes = len(class_names)
+
+    model = SimpleCNN(
+        num_classes=num_classes,
+        num_conv_blocks=num_conv_blocks,
+        base_filters=base_filters,
+        kernel_size=kernel_size,
+        use_batchnorm=use_batchnorm,
+        dropout=dropout,
+        fc_dim=fc_dim,
+    ).to(device)
+
+    trainable_params = sum(p.numel() for p in model.parameters() if p.requires_grad)
+    total_params = sum(p.numel() for p in model.parameters())
+
+    criterion = nn.CrossEntropyLoss()
+    optimizer = optim.AdamW(model.parameters(), lr=learning_rate, weight_decay=weight_decay)
+    scheduler = optim.lr_scheduler.ReduceLROnPlateau(
+        optimizer, mode="min", factor=0.5, patience=8, min_lr=learning_rate * 0.2
+    )
+
+    t0 = time.time()
+    history, logs, best_state, best_val_loss = _training_loop(
+        model, train_loader, val_loader, criterion, optimizer, scheduler, epochs, device
+    )
+
+    model.load_state_dict(best_state)
+    test_loss, test_acc = evaluate_loss_acc(model, test_loader, criterion, device)
+    y_true, y_pred = collect_predictions(model, test_loader, device)
+    metrics = compute_classification_metrics(y_true, y_pred, class_names)
+    elapsed = time.time() - t0
 
     timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
-    safe_tag = model_tag.strip().replace(" ", "_") if model_tag.strip() else "charcoal_resnet18"
+    safe_tag = model_tag.strip().replace(" ", "_") if model_tag.strip() else "cnn"
     model_name = f"{safe_tag}_{timestamp}"
 
     cm_path = save_confusion_matrix_figure(metrics["confusion_matrix"], model_name)
 
-    if model_type == "resnet18":
-        architecture = "ResNet18 pré-entraîné (layer4 + classifieur)"
-    else:
-        architecture = f"CNN simple ({num_conv_blocks} blocs, filtres={base_filters}, noyau={kernel_size}x{kernel_size})"
+    architecture = f"CNN simple ({num_conv_blocks} blocs, filtres={base_filters}, noyau={kernel_size}×{kernel_size})"
 
     config = {
         "dataset_name": DATASET_DISPLAY_NAME,
-        "model_type": model_type,
+        "model_type": "cnn",
         "architecture": architecture,
         "num_classes": num_classes,
         "class_names": class_names,
@@ -313,18 +390,16 @@ def train_model(
 
     save_model(model, model_name, config, training_summary)
 
-    logs.append("")
-    logs.append("Entraînement terminé.")
-    logs.append(f"Modèle sauvegardé : {model_name}")
-    logs.append(f"Appareil utilisé : {device}")
-    logs.append(f"Architecture : {architecture}")
-    logs.append(f"Nombre total de paramètres : {total_params}")
-    logs.append(f"Paramètres entraînables : {trainable_params}")
-    logs.append(f"Perte test cross-entropy : {test_loss:.4f}")
-    logs.append(f"Accuracy test : {test_acc:.4f}")
-    logs.append(f"F1 macro test : {metrics['f1_macro']:.4f}")
-    logs.append(f"F1 pondéré test : {metrics['f1_weighted']:.4f}")
-    logs.append(f"Temps écoulé : {elapsed:.1f}s")
+    logs += [
+        "",
+        "Entraînement terminé.",
+        f"Modèle sauvegardé : {model_name}",
+        f"Architecture : {architecture}",
+        f"Paramètres : {total_params}",
+        f"Perte test : {test_loss:.4f}  |  Accuracy test : {test_acc:.4f}",
+        f"F1 macro : {metrics['f1_macro']:.4f}  |  F1 pondéré : {metrics['f1_weighted']:.4f}",
+        f"Temps : {elapsed:.1f}s  |  Appareil : {device}",
+    ]
 
     return {
         "logs": "\n".join(logs),
@@ -337,10 +412,24 @@ def train_model(
     }
 
 
+# ---------------------------------------------------------------------------
+# Evaluate any saved model
+# ---------------------------------------------------------------------------
+
 def evaluate_saved_model(model_name: str):
     if not model_name:
         raise ValueError("Aucun modèle sélectionné.")
 
+    meta = _load_meta(model_name)
+    model_type = meta["config"].get("model_type", "cnn")
+
+    if model_type in CLASSICAL_MODEL_TYPES:
+        return _evaluate_classical(model_name, meta)
+    else:
+        return _evaluate_neural(model_name, meta)
+
+
+def _evaluate_neural(model_name: str, meta: dict):
     device = get_runtime_device()
     model, meta = load_model(model_name, device)
 
@@ -348,19 +437,51 @@ def evaluate_saved_model(model_name: str):
     _, _, test_loader, class_names = make_loaders(batch_size)
 
     criterion = nn.CrossEntropyLoss()
-
     test_loss, test_acc = evaluate_loss_acc(model, test_loader, criterion, device)
     y_true, y_pred = collect_predictions(model, test_loader, device)
 
     metrics = compute_classification_metrics(y_true, y_pred, class_names)
     cm_path = save_confusion_matrix_figure(metrics["confusion_matrix"], model_name)
 
-    summary = {
-        "test_cross_entropy_loss": round(test_loss, 4),
-        "test_accuracy": round(test_acc, 4),
-        "test_f1_macro": metrics["f1_macro"],
-        "test_f1_weighted": metrics["f1_weighted"],
-        "device": str(device),
-    }
+    return (
+        {
+            "test_cross_entropy_loss": round(test_loss, 4),
+            "test_accuracy": round(test_acc, 4),
+            "test_f1_macro": metrics["f1_macro"],
+            "test_f1_weighted": metrics["f1_weighted"],
+            "device": str(device),
+        },
+        metrics["classification_report"],
+        metrics["confusion_matrix"],
+        cm_path,
+    )
+
+
+def _evaluate_classical(model_name: str, meta: dict):
+    from backbone_utils import get_cached_features, extract_all_features
+    from classical_ml_utils import load_classical_pipeline
+
+    features_cache = get_cached_features()
+    if features_cache is None:
+        features_cache, _, _ = extract_all_features()
 
-    return summary, metrics["classification_report"], metrics["confusion_matrix"], cm_path
+    class_names = meta["config"]["class_names"]
+    pipeline = load_classical_pipeline(model_name)
+
+    X_test = features_cache["test"]["X"]
+    y_test = features_cache["test"]["y"]
+    y_pred = pipeline.predict(X_test)
+
+    metrics = compute_classification_metrics(y_test.tolist(), y_pred.tolist(), class_names)
+    cm_path = save_confusion_matrix_figure(metrics["confusion_matrix"], model_name)
+
+    return (
+        {
+            "test_accuracy": metrics["accuracy"],
+            "test_f1_macro": metrics["f1_macro"],
+            "test_f1_weighted": metrics["f1_weighted"],
+        },
+        metrics["classification_report"],
+        metrics["confusion_matrix"],
+        cm_path,
+    )