Ajouter MLP baseline, courbes de perte, CV et backbone ImageNet brut

Suite aux retours de Marco sur la conception du QCM :
- Tab MLP (baseline) avant le CNN pour montrer que le surapprentissage
persiste quel que soit le choix d'hyperparametres (nombre de couches,
neurones par couche), motivant le passage au CNN
- Courbes de perte train/validation par epoque (MLP et CNN)
- Backbone ResNet18 remplace par les poids ImageNet d'origine, sans
fine-tuning sur le dataset (retire la dependance a HF_BACKBONE_REPO)
- Chaque algorithme classique (SVM, LogReg, k-NN, RF) n'expose plus
qu'un seul hyperparametre ; LDA retire
- Option de validation croisee (CV stratifiee, fallback si classe trop
petite) affichant score CV et score test cote a cote

app.py

@@ -12,6 +12,7 @@ from train_utils import (
     list_saved_models,
     model_meta_path,
     train_cnn,
+    train_mlp,
 )
 
 # ---------------------------------------------------------------------------
@@ -35,7 +36,44 @@ def refresh_gallery_callback(split_name, class_name, max_images):
 
 
 # ---------------------------------------------------------------------------
-# Tab 2 — SimpleCNN
+# Tab 2 — MLP (baseline)
+# ---------------------------------------------------------------------------
+
+@spaces.GPU(duration=300)
+def train_mlp_callback(
+    num_layers, hidden_dim, dropout,
+    learning_rate, weight_decay, batch_size, epochs,
+    model_tag,
+):
+    try:
+        result = train_mlp(
+            num_layers=int(num_layers),
+            hidden_dim=int(hidden_dim),
+            dropout=float(dropout),
+            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
+        return (
+            result["logs"],
+            result["history"],
+            result["summary"],
+            result["classification_report"],
+            result["confusion_matrix"],
+            result["confusion_matrix_path"],
+            result["loss_curve_path"],
+            gr.update(choices=models, value=selected),
+        )
+    except Exception as e:
+        return f"Échec de l'entraînement :\n{e}", None, None, None, None, None, None, gr.update()
+
+
+# ---------------------------------------------------------------------------
+# Tab 3 — SimpleCNN
 # ---------------------------------------------------------------------------
 
 @spaces.GPU(duration=300)
@@ -68,14 +106,15 @@ def train_cnn_callback(
             result["classification_report"],
             result["confusion_matrix"],
             result["confusion_matrix_path"],
+            result["loss_curve_path"],
             gr.update(choices=models, value=selected),
         )
     except Exception as e:
-        return f"Échec de l'entraînement :\n{e}", None, None, None, None, None, gr.update()
+        return f"Échec de l'entraînement :\n{e}", None, None, None, None, None, None, gr.update()
 
 
 # ---------------------------------------------------------------------------
-# Tab 3 — Backbone + ML classique
+# Tab 4 — Backbone + ML classique
 # ---------------------------------------------------------------------------
 
 @spaces.GPU(duration=60)
@@ -92,16 +131,16 @@ def extract_features_callback():
 
 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")
+    return show("SVM"), show("Régression logistique"), show("k-NN"), show("Forêt aléatoire")
 
 
 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,
+    svm_c,
+    logreg_c,
+    knn_k,
+    rf_n_estimators,
+    use_cv,
     model_tag,
 ):
     try:
@@ -114,19 +153,18 @@ def train_classical_callback(
 
         params = {}
         if clf_type == "SVM":
-            params = {"C": float(svm_c), "kernel": svm_kernel, "gamma": svm_gamma}
+            params = {"C": float(svm_c)}
         elif clf_type == "Régression logistique":
-            params = {"C": float(logreg_c), "max_iter": int(logreg_max_iter)}
+            params = {"C": float(logreg_c)}
         elif clf_type == "k-NN":
-            params = {"n_neighbors": int(knn_k), "metric": knn_metric}
+            params = {"n_neighbors": int(knn_k)}
         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}
+            params = {"n_estimators": int(rf_n_estimators)}
 
         class_names = get_class_names()
-        result = train_classical_model(clf_type, features_cache, class_names, model_tag, **params)
+        result = train_classical_model(
+            clf_type, features_cache, class_names, model_tag, use_cv=bool(use_cv), **params
+        )
 
         models = list_saved_models()
         selected = result["model_name"] if result["model_name"] in models else None
@@ -142,7 +180,7 @@ def train_classical_callback(
 
 
 # ---------------------------------------------------------------------------
-# Tab 4 — Tester et analyser
+# Tab 5 — Tester et analyser
 # ---------------------------------------------------------------------------
 
 def refresh_models_callback():
@@ -195,11 +233,11 @@ with gr.Blocks(title="Classification d'images microscopiques") as demo:
 
     gr.Markdown("# Classification d'images microscopiques de charbons de bois")
     gr.Markdown(
-        "Ce parcours pédagogique suit une progression en trois étapes : "
-        "**exploration des données**, **entraînement d'un CNN de zéro**, "
+        "Ce parcours pédagogique suit une progression en quatre étapes : "
+        "**exploration des données**, **MLP de référence**, **CNN entraîné de zéro**, "
         "puis **exploitation d'un backbone préentraîné avec des algorithmes classiques**. "
-        "L'objectif est de comprendre pourquoi l'apprentissage par transfert est si puissant, "
-        "surtout quand les données sont rares."
+        "L'objectif est de comprendre pourquoi la structure convolutive et l'apprentissage par "
+        "transfert sont si puissants, surtout quand les données sont rares."
     )
 
     with gr.Tabs():
@@ -240,14 +278,79 @@ with gr.Blocks(title="Classification d'images microscopiques") as demo:
             image_gallery = gr.Gallery(label="Exemples d'images", columns=4, height=600)
 
         # ------------------------------------------------------------------ #
-        # Tab 2 — SimpleCNN de zéro
+        # Tab 2 — MLP (modèle de référence)
+        # ------------------------------------------------------------------ #
+        with gr.Tab("2. MLP (modèle de référence)"):
+            gr.Markdown("## Un premier réseau de neurones : le perceptron multicouche")
+            gr.Markdown(
+                "Avant d'introduire un CNN, commençons par le modèle le plus simple : un **MLP** "
+                "(perceptron multicouche), entièrement connecté. Chaque image est aplatie en un long "
+                "vecteur de pixels — le réseau ne sait donc rien de la structure spatiale de l'image "
+                "(voisinage des pixels, formes, textures locales).\n\n"
+                "**Contexte du problème :** notre jeu de données contient 39 espèces, "
+                "avec seulement 8 images par espèce en moyenne, réparties en train / validation / test.\n\n"
+                "**Ce que cet exercice doit montrer :** observez les courbes de perte train vs validation. "
+                "À partir de quelle époque la courbe de validation cesse de s'améliorer (ou remonte) "
+                "pendant que la perte d'entraînement continue de baisser ? C'est le signe du surapprentissage. "
+                "Essayez de faire varier le nombre de couches et le nombre de neurones par couche : "
+                "vous constaterez que le surapprentissage apparaît quel que soit le choix — "
+                "un MLP n'exploite pas la structure de l'image et ne peut pas s'en affranchir. "
+                "C'est cette limite qui motive le passage au CNN."
+            )
+
+            with gr.Row():
+                with gr.Column():
+                    gr.Markdown("#### Architecture du MLP")
+                    mlp_num_layers = gr.Slider(
+                        minimum=1, maximum=5, value=2, step=1,
+                        label="Nombre de couches cachées",
+                    )
+                    mlp_hidden_dim = gr.Dropdown(
+                        choices=[64, 128, 256, 512, 1024], value=256,
+                        label="Neurones par couche cachée",
+                    )
+
+                    gr.Markdown("#### Hyperparamètres d'entraînement")
+                    mlp_dropout = gr.Slider(
+                        minimum=0.0, maximum=0.8, value=0.4, step=0.05,
+                        label="Dropout",
+                    )
+                    mlp_lr = gr.Number(value=1e-3, label="Taux d'apprentissage")
+                    mlp_wd = gr.Number(value=1e-4, label="Weight decay (régularisation L2)")
+                    mlp_bs = gr.Dropdown(choices=[8, 16, 32, 64], value=16, label="Taille du batch")
+                    mlp_epochs = gr.Slider(
+                        minimum=1, maximum=50, value=30, step=1, label="Nombre d'époques"
+                    )
+                    mlp_tag = gr.Textbox(
+                        label="Nom du modèle", placeholder="ex. mlp_2couches_256"
+                    )
+                    train_mlp_btn = gr.Button("Lancer l'entraînement", variant="primary")
+
+                with gr.Column():
+                    mlp_logs = gr.Textbox(label="Journal d'entraînement", lines=20)
+                    mlp_history = gr.JSON(label="Historique époque par époque")
+                    mlp_summary = gr.JSON(label="Résumé final")
+
+            gr.Markdown("## Courbes de perte (train vs validation)")
+            mlp_loss_curve = gr.Image(label="Perte par époque", type="filepath")
+
+            gr.Markdown("## Résultats sur le jeu de test")
+            mlp_report = gr.Dataframe(label="Rapport de classification", interactive=False)
+            mlp_cm = gr.Dataframe(label="Matrice de confusion", interactive=False)
+            mlp_cm_img = gr.Image(label="Matrice de confusion — figure", type="filepath")
+
+        # ------------------------------------------------------------------ #
+        # Tab 3 — SimpleCNN de zéro
         # ------------------------------------------------------------------ #
-        with gr.Tab("2. CNN entraîné de zéro"):
+        with gr.Tab("3. CNN entraîné de zéro"):
             gr.Markdown("## Entraîner un réseau convolutif sans connaissances préalables")
             gr.Markdown(
-                "La première approche naturelle est de construire un réseau de neurones convolutif (CNN) "
-                "et de l'entraîner directement sur nos données de charbons de bois. "
-                "Ce réseau part de paramètres aléatoires : il ne sait rien des images au départ.\n\n"
+                "Le MLP de l'onglet précédent surapprend quels que soient les hyperparamètres choisis : "
+                "il ne peut pas exploiter la structure spatiale des images. Construisons maintenant un "
+                "réseau de neurones convolutif (CNN), conçu pour capter des motifs locaux (contours, "
+                "textures) grâce aux filtres de convolution, et entraînons-le directement sur nos données "
+                "de charbons de bois. Ce réseau part de paramètres aléatoires : il ne sait rien des images "
+                "au départ.\n\n"
                 "**Contexte du problème :** notre jeu de données contient 39 espèces, "
                 "avec seulement 8 images par espèce en moyenne. "
                 "C'est extrêmement peu pour apprendre à distinguer 39 classes visuellement similaires.\n\n"
@@ -305,36 +408,43 @@ with gr.Blocks(title="Classification d'images microscopiques") as demo:
                     cnn_history = gr.JSON(label="Historique époque par époque")
                     cnn_summary = gr.JSON(label="Résumé final")
 
+            gr.Markdown("## Courbes de perte (train vs validation)")
+            cnn_loss_curve = gr.Image(label="Perte par époque", type="filepath")
+
             gr.Markdown("## Résultats sur le jeu de test")
             cnn_report = gr.Dataframe(label="Rapport de classification", interactive=False)
             cnn_cm = gr.Dataframe(label="Matrice de confusion", interactive=False)
             cnn_cm_img = gr.Image(label="Matrice de confusion — figure", type="filepath")
 
         # ------------------------------------------------------------------ #
-        # Tab 3 — Backbone préentraîné + ML classique
+        # Tab 4 — Backbone préentraîné + ML classique
         # ------------------------------------------------------------------ #
-        with gr.Tab("3. Backbone préentraîné + ML classique"):
+        with gr.Tab("4. Backbone préentraîné + ML classique"):
             gr.Markdown("## Exploiter les connaissances d'un modèle préentraîné")
             gr.Markdown(
-                "Face aux limites observées avec le CNN de zéro, une stratégie radicalement différente "
-                "consiste à réutiliser un réseau déjà entraîné, et à s'appuyer sur les représentations "
-                "qu'il a apprises.\n\n"
+                "Face aux limites observées avec le MLP et le CNN de zéro (peu de données, beaucoup de "
+                "classes), une stratégie radicalement différente consiste à réutiliser un réseau déjà "
+                "entraîné sur d'autres images, et à s'appuyer sur les représentations qu'il a apprises.\n\n"
                 "### Qu'est-ce qu'un backbone ?\n"
                 "Un **backbone** est un réseau convolutif dont on retire la couche de classification finale. "
                 "Il agit comme un extracteur de caractéristiques : pour chaque image en entrée, "
                 "il produit un vecteur de nombres (ici **512 dimensions**) qui encode le contenu visuel "
                 "de l'image de façon compacte et abstraite.\n\n"
                 "### Quel backbone utilisons-nous ici ?\n"
-                "Nous utilisons un **ResNet18 affiné sur notre jeu de données de charbons de bois**. "
-                "Ce modèle a d'abord été préentraîné sur ImageNet (1,2 million d'images, 1 000 classes), "
-                "puis ses poids ont été ajustés sur nos images microscopiques. "
-                "Il a donc appris à reconnaître les structures visuelles propres aux charbons de bois.\n\n"
+                "Nous utilisons un **ResNet18 avec ses poids ImageNet d'origine, sans aucun fine-tuning** "
+                "sur nos images de charbons de bois. Ce modèle a été préentraîné sur ImageNet "
+                "(1,2 million d'images, 1 000 classes) — il n'a jamais vu une image de charbon de bois. "
+                "L'objectif est d'observer si des représentations apprises sur des images naturelles "
+                "génériques transfèrent malgré tout à un domaine très différent (microscopie).\n\n"
                 "### Pourquoi des algorithmes classiques ensuite ?\n"
                 "Une fois les images transformées en vecteurs de 512 dimensions, "
                 "n'importe quel algorithme de classification classique peut être appliqué. "
-                "Ces algorithmes (SVM, régression logistique, k-NN…) sont rapides à entraîner, "
+                "Ces algorithmes (SVM, régression logistique, k-NN, forêt aléatoire) sont rapides à entraîner, "
                 "interprétables, et ne nécessitent pas de GPU. "
-                "Comparez leurs résultats avec ceux obtenus à l'étape précédente."
+                "Pour chaque algorithme, un seul hyperparamètre est ajustable — les autres réglages "
+                "sont fixés pour rester comparables. Une option de validation croisée permet en plus "
+                "d'estimer la stabilité du score sur le train set. "
+                "Comparez leurs résultats avec ceux obtenus aux étapes précédentes (MLP, CNN)."
             )
 
             gr.Markdown("## Étape 1 — Extraction des caractéristiques")
@@ -358,60 +468,44 @@ with gr.Blocks(title="Classification d'images microscopiques") as demo:
             with gr.Row():
                 with gr.Column():
                     clf_type = gr.Radio(
-                        choices=["SVM", "Régression logistique", "k-NN", "Forêt aléatoire", "LDA"],
+                        choices=["SVM", "Régression logistique", "k-NN", "Forêt aléatoire"],
                         value="SVM",
                         label="Algorithme de classification",
                     )
 
                     with gr.Column(visible=True) as svm_col:
-                        gr.Markdown("#### Paramètres SVM")
+                        gr.Markdown("#### Paramètre SVM (noyau RBF, gamma='scale' fixés)")
                         svm_c = gr.Number(
                             value=1.0, label="C — force de régularisation",
                             info="Une valeur faible regularise davantage (marges plus larges).",
                         )
-                        svm_kernel = gr.Dropdown(
-                            choices=["rbf", "linear", "poly"], value="rbf",
-                            label="Noyau",
-                            info="RBF est généralement le meilleur point de départ.",
-                        )
-                        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")
+                        gr.Markdown("#### Paramètre Régression logistique (max_iter=1000 fixé)")
                         logreg_c = gr.Number(value=1.0, label="C — force de 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")
+                        gr.Markdown("#### Paramètre k-NN (distance euclidienne fixée)")
                         knn_k = gr.Slider(
                             minimum=1, maximum=20, value=5, step=1,
                             label="k — nombre de voisins",
                             info="k=1 mémorise les données, k élevé généralise davantage.",
                         )
-                        knn_metric = gr.Dropdown(
-                            choices=["euclidean", "cosine", "manhattan"],
-                            value="euclidean", label="Métrique de distance",
-                        )
 
                     with gr.Column(visible=False) as rf_col:
-                        gr.Markdown("#### Paramètres Forêt aléatoire")
+                        gr.Markdown("#### Paramètre Forêt aléatoire (profondeur illimitée fixée)")
                         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)"
-                        )
 
-                    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"
-                        )
+                    cv_checkbox = gr.Checkbox(
+                        value=False,
+                        label="Activer la validation croisée sur le train set",
+                        info="Ajoute un score F1 macro moyenné sur plusieurs folds, en plus du score sur le jeu de test.",
+                    )
 
                     ml_tag = gr.Textbox(
-                        label="Nom du modèle", placeholder="ex. svm_rbf_C1"
+                        label="Nom du modèle", placeholder="ex. svm_C1"
                     )
                     train_classical_btn = gr.Button("Entraîner le classifieur", variant="primary")
 
@@ -423,13 +517,13 @@ with gr.Blocks(title="Classification d'images microscopiques") as demo:
             ml_cm_img = gr.Image(label="Matrice de confusion — figure", type="filepath")
 
         # ------------------------------------------------------------------ #
-        # Tab 4 — Tester et analyser
+        # Tab 5 — Tester et analyser
         # ------------------------------------------------------------------ #
-        with gr.Tab("4. Tester et analyser"):
+        with gr.Tab("5. Tester et analyser"):
             gr.Markdown("## Comparer et évaluer les modèles")
             gr.Markdown(
                 "Tous les modèles entraînés dans les onglets précédents apparaissent ici — "
-                "CNN de zéro comme classifieurs ML. "
+                "MLP, CNN de zéro comme classifieurs ML. "
                 "Évaluez-les sur le jeu de test, prédisez la classe d'une image importée, "
                 "et tirez vos conclusions sur l'apport du backbone préentraîné."
             )
@@ -493,6 +587,20 @@ with gr.Blocks(title="Classification d'images microscopiques") as demo:
         outputs=image_gallery,
     )
 
+    train_mlp_btn.click(
+        fn=train_mlp_callback,
+        inputs=[
+            mlp_num_layers, mlp_hidden_dim, mlp_dropout,
+            mlp_lr, mlp_wd, mlp_bs, mlp_epochs,
+            mlp_tag,
+        ],
+        outputs=[
+            mlp_logs, mlp_history, mlp_summary,
+            mlp_report, mlp_cm, mlp_cm_img, mlp_loss_curve,
+            model_selector,
+        ],
+    )
+
     train_cnn_btn.click(
         fn=train_cnn_callback,
         inputs=[
@@ -503,7 +611,7 @@ with gr.Blocks(title="Classification d'images microscopiques") as demo:
         ],
         outputs=[
             cnn_logs, cnn_history, cnn_summary,
-            cnn_report, cnn_cm, cnn_cm_img,
+            cnn_report, cnn_cm, cnn_cm_img, cnn_loss_curve,
             model_selector,
         ],
     )
@@ -513,18 +621,18 @@ with gr.Blocks(title="Classification d'images microscopiques") as demo:
     clf_type.change(
         fn=on_clf_type_change,
         inputs=clf_type,
-        outputs=[svm_col, logreg_col, knn_col, rf_col, lda_col],
+        outputs=[svm_col, logreg_col, knn_col, rf_col],
     )
 
     train_classical_btn.click(
         fn=train_classical_callback,
         inputs=[
             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,
+            svm_c,
+            logreg_c,
+            knn_k,
+            rf_n_estimators,
+            cv_checkbox,
             ml_tag,
         ],
         outputs=[ml_summary, ml_report, ml_cm, ml_cm_img, model_selector],

backbone_utils.py

@@ -3,12 +3,9 @@ import os
 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
 
@@ -17,21 +14,16 @@ _DISK_CACHE_PATH = "/tmp/charcoal_features.npz"
 
 
 def load_backbone(device: torch.device) -> nn.Module:
+    """ResNet18 avec les poids ImageNet d'origine, sans fine-tuning sur le
+    dataset de charbons de bois — utilisé tel quel comme extracteur de
+    caractéristiques pour illustrer le transfer learning "brut"."""
     global _BACKBONE
 
     if _BACKBONE is not None:
         return _BACKBONE.to(device)
 
-    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 = models.resnet18(weights=models.ResNet18_Weights.IMAGENET1K_V1)
     backbone.fc = nn.Identity()
-    backbone.load_state_dict(torch.load(pt_path, map_location="cpu"))
 
     for p in backbone.parameters():
         p.requires_grad = False

classical_ml_utils.py

@@ -1,18 +1,19 @@
 import json
 import os
+from collections import Counter
 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.model_selection import StratifiedKFold, cross_val_score
 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 config import MODEL_DIR, META_DIR, CV_FOLDS
 from metrics_utils import compute_classification_metrics, save_confusion_matrix_figure
 
 CLF_TYPE_MAP = {
@@ -20,7 +21,6 @@ CLF_TYPE_MAP = {
     "Régression logistique": "logreg",
     "k-NN": "knn",
     "Forêt aléatoire": "rf",
-    "LDA": "lda",
 }
 
 
@@ -55,26 +55,41 @@ def build_pipeline(clf_type: str, **params) -> Pipeline:
             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,
+            max_depth=None,
             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 _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)."""
+    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 {
+        "cv_folds": folds,
+        "cv_f1_macro_mean": round(float(scores.mean()), 4),
+        "cv_f1_macro_std": round(float(scores.std()), 4),
+    }
+
+
 def train_classical_model(
     clf_type: str,
     features_cache: dict,
     class_names: List[str],
     model_tag: str = "",
+    use_cv: bool = False,
     **params,
 ):
     X_train = features_cache["train"]["X"]
@@ -82,6 +97,8 @@ 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
+
     pipeline = build_pipeline(clf_type, **params)
     pipeline.fit(X_train, y_train)
 
@@ -109,6 +126,7 @@ def train_classical_model(
         "test_f1_weighted": metrics["f1_weighted"],
         "train_samples": int(len(X_train)),
         "test_samples": int(len(X_test)),
+        **(cv_metrics or {}),
     }
 
     with open(meta_path(model_name), "w", encoding="utf-8") as f:

config.py

@@ -11,7 +11,6 @@ os.makedirs(META_DIR, exist_ok=True)
 os.makedirs(FIGURE_DIR, exist_ok=True)
 
 HF_DATASET_REPO = os.environ.get("HF_DATASET_REPO", "CircleStar/charcoal-microscopy")
-HF_BACKBONE_REPO = os.environ.get("HF_BACKBONE_REPO", "CircleStar/charcoal-resnet18-backbone")
 HF_TOKEN = os.environ.get("HF_TOKEN")
 
 IMAGE_SIZE = 224
@@ -19,4 +18,5 @@ RANDOM_SEED = 42
 
 DATASET_DISPLAY_NAME = "Images microscopiques de charbons de bois"
 
-CLASSICAL_MODEL_TYPES = frozenset({"svm", "logreg", "knn", "rf", "lda"})
+CLASSICAL_MODEL_TYPES = frozenset({"svm", "logreg", "knn", "rf"})
+CV_FOLDS = 3

finetune_backbone.py

@@ -1,6 +1,10 @@
 """
 finetune_backbone.py
 
+NOT USED by the current app — backbone_utils.load_backbone() now loads plain
+ImageNet ResNet18 weights directly (no fine-tuning), per the pedagogical
+redesign. Kept for reference in case a domain-adapted backbone is reinstated.
+
 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

metrics_utils.py

@@ -77,4 +77,26 @@ def save_confusion_matrix_figure(cm_df: pd.DataFrame, model_name: str) -> str:
     plt.savefig(fig_path, dpi=200)
     plt.close()
 
+    return fig_path
+
+
+def save_loss_curve_figure(history: List[dict], model_name: str) -> str:
+    fig_path = os.path.join(FIGURE_DIR, f"{model_name}_loss_curve.png")
+
+    epochs = [h["epoch"] for h in history]
+    train_loss = [h["train_loss"] for h in history]
+    val_loss = [h["val_loss"] for h in history]
+
+    plt.figure(figsize=(8, 5))
+    plt.plot(epochs, train_loss, label="Train", marker="o", markersize=3)
+    plt.plot(epochs, val_loss, label="Validation", marker="o", markersize=3)
+    plt.xlabel("Époque")
+    plt.ylabel("Perte (loss)")
+    plt.title("Courbes de perte — train vs validation")
+    plt.legend()
+    plt.grid(alpha=0.3)
+    plt.tight_layout()
+    plt.savefig(fig_path, dpi=150)
+    plt.close()
+
     return fig_path

model.py

@@ -19,6 +19,35 @@ class BackboneWithFC(nn.Module):
         return self.classifier(self.backbone(x))
 
 
+class MLP(nn.Module):
+    """Baseline entièrement connecté : montre les limites d'un MLP sur des images
+    (aucune structure spatiale exploitée) avant d'introduire le CNN."""
+
+    def __init__(
+        self,
+        num_classes: int,
+        input_size: int,
+        num_layers: int = 2,
+        hidden_dim: int = 256,
+        dropout: float = 0.4,
+    ):
+        super().__init__()
+
+        layers = [nn.Flatten()]
+        in_dim = input_size
+        for _ in range(num_layers):
+            layers.append(nn.Linear(in_dim, hidden_dim))
+            layers.append(nn.ReLU(inplace=True))
+            layers.append(nn.Dropout(dropout))
+            in_dim = hidden_dim
+        layers.append(nn.Linear(in_dim, num_classes))
+
+        self.net = nn.Sequential(*layers)
+
+    def forward(self, x):
+        return self.net(x)
+
+
 class SimpleCNN(nn.Module):
     def __init__(
         self,

train_utils.py

@@ -8,10 +8,10 @@ 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
+from config import MODEL_DIR, META_DIR, DATASET_DISPLAY_NAME, CLASSICAL_MODEL_TYPES, IMAGE_SIZE
 from data_utils import make_loaders
-from metrics_utils import compute_classification_metrics, save_confusion_matrix_figure
-from model import SimpleCNN, BackboneWithFC
+from metrics_utils import compute_classification_metrics, save_confusion_matrix_figure, save_loss_curve_figure
+from model import SimpleCNN, BackboneWithFC, MLP
 
 
 # ---------------------------------------------------------------------------
@@ -101,6 +101,16 @@ def load_model(model_name: str, device: torch.device) -> Tuple[nn.Module, dict]:
         )
         model.load_state_dict(torch.load(model_weight_path(model_name), map_location="cpu"))
 
+    elif model_type == "mlp":
+        model = MLP(
+            num_classes=cfg["num_classes"],
+            input_size=cfg.get("input_size", 3 * IMAGE_SIZE * IMAGE_SIZE),
+            num_layers=cfg.get("num_layers", 2),
+            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"))
+
     else:
         raise ValueError(f"load_model n'accepte pas le type '{model_type}'. Utilisez load_classical_pipeline pour les modèles ML classiques.")
 
@@ -351,6 +361,7 @@ def train_cnn(
     model_name = f"{safe_tag}_{timestamp}"
 
     cm_path = save_confusion_matrix_figure(metrics["confusion_matrix"], model_name)
+    loss_curve_path = save_loss_curve_figure(history, model_name)
 
     architecture = f"CNN simple ({num_conv_blocks} blocs, filtres={base_filters}, noyau={kernel_size}×{kernel_size})"
 
@@ -409,6 +420,120 @@ def train_cnn(
         "classification_report": metrics["classification_report"],
         "confusion_matrix": metrics["confusion_matrix"],
         "confusion_matrix_path": cm_path,
+        "loss_curve_path": loss_curve_path,
+    }
+
+
+# ---------------------------------------------------------------------------
+# Train MLP from scratch (baseline avant le CNN)
+# ---------------------------------------------------------------------------
+
+def train_mlp(
+    num_layers: int = 2,
+    hidden_dim: int = 256,
+    dropout: float = 0.4,
+    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)
+    input_size = 3 * IMAGE_SIZE * IMAGE_SIZE
+
+    model = MLP(
+        num_classes=num_classes,
+        input_size=input_size,
+        num_layers=num_layers,
+        hidden_dim=hidden_dim,
+        dropout=dropout,
+    ).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 "mlp"
+    model_name = f"{safe_tag}_{timestamp}"
+
+    cm_path = save_confusion_matrix_figure(metrics["confusion_matrix"], model_name)
+    loss_curve_path = save_loss_curve_figure(history, model_name)
+
+    architecture = f"MLP ({num_layers} couches cachées de {hidden_dim} neurones)"
+
+    config = {
+        "dataset_name": DATASET_DISPLAY_NAME,
+        "model_type": "mlp",
+        "architecture": architecture,
+        "num_classes": num_classes,
+        "class_names": class_names,
+        "input_size": input_size,
+        "num_layers": num_layers,
+        "hidden_dim": hidden_dim,
+        "dropout": dropout,
+        "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 : {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),
+        "history": history,
+        "summary": training_summary,
+        "model_name": model_name,
+        "classification_report": metrics["classification_report"],
+        "confusion_matrix": metrics["confusion_matrix"],
+        "confusion_matrix_path": cm_path,
+        "loss_curve_path": loss_curve_path,
     }