Restructurer le parcours pédagogique : CNN de zéro puis backbone + ML classique

app.py

@@ -12,7 +12,6 @@ from train_utils import (
     list_saved_models,
     model_meta_path,
     train_cnn,
-    train_fc_head,
 )
 
 # ---------------------------------------------------------------------------
@@ -36,16 +35,56 @@ def refresh_gallery_callback(split_name, class_name, max_images):
 
 
 # ---------------------------------------------------------------------------
-# Tab 2 — ML classique
+# Tab 2 — SimpleCNN
+# ---------------------------------------------------------------------------
+
+@spaces.GPU(duration=300)
+def train_cnn_callback(
+    num_conv_blocks, base_filters, kernel_size, use_batchnorm,
+    dropout, fc_dim,
+    learning_rate, weight_decay, batch_size, epochs,
+    model_tag,
+):
+    try:
+        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
+        return (
+            result["logs"],
+            result["history"],
+            result["summary"],
+            result["classification_report"],
+            result["confusion_matrix"],
+            result["confusion_matrix_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()
+
+
+# ---------------------------------------------------------------------------
+# Tab 3 — Backbone + ML classique
 # ---------------------------------------------------------------------------
 
 @spaces.GPU(duration=60)
 def extract_features_callback():
     try:
         _, class_names, counts = extract_all_features()
-        lines = [f"Extraction terminée  ({len(class_names)} classes)"]
+        lines = [f"Extraction terminée — {len(class_names)} classes détectées"]
         for split, n in counts.items():
-            lines.append(f"  {split} : {n} images")
+            lines.append(f"  • {split} : {n} images → {n} vecteurs de 512 dimensions")
         return "\n".join(lines)
     except Exception as e:
         return f"Erreur lors de l'extraction :\n{e}"
@@ -68,7 +107,10 @@ def train_classical_callback(
     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()
+            return (
+                {"Erreur": "Veuillez d'abord extraire les caractéristiques (bouton ci-dessus)."},
+                None, None, None, gr.update(),
+            )
 
         params = {}
         if clf_type == "SVM":
@@ -88,7 +130,6 @@ def train_classical_callback(
 
         models = list_saved_models()
         selected = result["model_name"] if result["model_name"] in models else None
-
         return (
             result["summary"],
             result["classification_report"],
@@ -101,67 +142,7 @@ def train_classical_callback(
 
 
 # ---------------------------------------------------------------------------
-# 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=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,
-    model_tag,
-):
-    try:
-        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
-
-        return (
-            result["logs"],
-            result["history"],
-            result["summary"],
-            result["classification_report"],
-            result["confusion_matrix"],
-            result["confusion_matrix_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()
-
-
-# ---------------------------------------------------------------------------
-# Tab 4 — Tester et prédire
+# Tab 4 — Tester et analyser
 # ---------------------------------------------------------------------------
 
 def refresh_models_callback():
@@ -211,28 +192,41 @@ def random_test_callback(model_name):
 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")
     gr.Markdown(
-        "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."
+        "Ce parcours pédagogique suit une progression en trois étapes : "
+        "**exploration des données**, **entraînement d'un CNN 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."
     )
 
     with gr.Tabs():
 
         # ------------------------------------------------------------------ #
-        # Tab 1
+        # Tab 1 — Explorer le dataset
         # ------------------------------------------------------------------ #
         with gr.Tab("1. Explorer le jeu de données"):
-            gr.Markdown("## Comprendre le jeu de données avant l'entraînement")
+            gr.Markdown("## Comprendre le problème avant de modéliser")
+            gr.Markdown(
+                "Avant de choisir un modèle, il est essentiel de comprendre la structure du jeu de données. "
+                "Combien de classes ? Combien d'images par classe ? Les classes sont-elles équilibrées ? "
+                "Ces questions conditionnent directement les choix de modélisation."
+            )
 
             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 par split et par classe", interactive=False
+                label="Distribution des images par split et par classe", interactive=False
             )
 
-            gr.Markdown("## Visualisation des images")
+            gr.Markdown(
+                "## Visualiser les images\n"
+                "Parcourez des exemples d'images pour vous familiariser avec les données. "
+                "Notez que les images microscopiques de charbons de bois peuvent être "
+                "visuellement très similaires d'une espèce à l'autre — ce qui rend la tâche difficile."
+            )
             with gr.Row():
                 split_selector = gr.Dropdown(
                     choices=["train", "validation", "test"], value="train", label="Split"
@@ -246,57 +240,179 @@ with gr.Blocks(title="Classification d'images microscopiques") as demo:
             image_gallery = gr.Gallery(label="Exemples d'images", columns=4, height=600)
 
         # ------------------------------------------------------------------ #
-        # Tab 2
+        # Tab 2 — SimpleCNN de zéro
         # ------------------------------------------------------------------ #
-        with gr.Tab("2. ML classique sur caractéristiques"):
+        with gr.Tab("2. CNN entraîné de zéro"):
+            gr.Markdown("## Entraîner un réseau convolutif sans connaissances préalables")
             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."
+                "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"
+                "**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"
+                "Jouez avec les paramètres d'architecture et d'entraînement pour observer leur effet "
+                "sur les performances. Essayez notamment d'augmenter la complexité du réseau "
+                "et observez ce qui se passe."
             )
 
-            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)
+            with gr.Row():
+                with gr.Column():
+                    gr.Markdown("#### Architecture du CNN")
+                    num_conv_blocks = gr.Slider(
+                        minimum=2, maximum=5, value=3, step=1,
+                        label="Blocs convolutionnels",
+                        info="Chaque bloc enchaîne Conv2d → BatchNorm → ReLU → MaxPool. Plus de blocs = réseau plus profond.",
+                    )
+                    base_filters = gr.Dropdown(
+                        choices=[16, 32, 64, 128], value=32,
+                        label="Filtres du premier bloc",
+                        info="Le nombre de filtres double à chaque bloc. 32 → 64 → 128...",
+                    )
+                    kernel_size = gr.Dropdown(
+                        choices=[3, 5], value=3,
+                        label="Taille du noyau de convolution",
+                        info="3×3 capte les détails fins, 5×5 capte des structures plus larges.",
+                    )
+                    use_batchnorm = gr.Checkbox(
+                        value=True, label="Normalisation par lots (BatchNorm)",
+                        info="Stabilise l'entraînement et accélère la convergence.",
+                    )
+
+                    gr.Markdown("#### Hyperparamètres d'entraînement")
+                    cnn_dropout = gr.Slider(
+                        minimum=0.0, maximum=0.8, value=0.4, step=0.05,
+                        label="Dropout",
+                        info="Désactive aléatoirement des neurones pour limiter le surapprentissage.",
+                    )
+                    cnn_fc_dim = gr.Dropdown(
+                        choices=[64, 128, 256, 512], value=256,
+                        label="Dimension de la couche cachée",
+                    )
+                    cnn_lr = gr.Number(value=1e-3, label="Taux d'apprentissage")
+                    cnn_wd = gr.Number(value=1e-4, label="Weight decay (régularisation L2)")
+                    cnn_bs = gr.Dropdown(choices=[8, 16, 32, 64], value=16, label="Taille du batch")
+                    cnn_epochs = gr.Slider(
+                        minimum=1, maximum=50, value=30, step=1, label="Nombre d'époques"
+                    )
+                    cnn_tag = gr.Textbox(
+                        label="Nom du modèle", placeholder="ex. cnn_3blocs_32filtres"
+                    )
+                    train_cnn_btn = gr.Button("Lancer l'entraînement", variant="primary")
+
+                with gr.Column():
+                    cnn_logs = gr.Textbox(label="Journal d'entraînement", lines=20)
+                    cnn_history = gr.JSON(label="Historique époque par époque")
+                    cnn_summary = gr.JSON(label="Résumé final")
+
+            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
+        # ------------------------------------------------------------------ #
+        with gr.Tab("3. 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"
+                "### 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"
+                "### 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, "
+                "interprétables, et ne nécessitent pas de GPU. "
+                "Comparez leurs résultats avec ceux obtenus à l'étape précédente."
+            )
+
+            gr.Markdown("## Étape 1 — Extraction des caractéristiques")
+            gr.Markdown(
+                "Passez toutes les images du jeu de données dans le backbone. "
+                "Chaque image est convertie en un vecteur de 512 valeurs. "
+                "Cette opération est réalisée une seule fois et mise en cache."
+            )
+            extract_btn = gr.Button(
+                "Extraire les caractéristiques (backbone gelé)", variant="primary"
+            )
+            extract_status = gr.Textbox(label="Statut", lines=5, interactive=False)
 
-            gr.Markdown("## Étape 2 — Entraîner un classifieur")
+            gr.Markdown("## Étape 2 — Entraîner un classifieur sur les caractéristiques")
+            gr.Markdown(
+                "Choisissez un algorithme et ajustez ses paramètres. "
+                "L'entraînement est quasi-instantané car il opère sur des vecteurs, "
+                "sans jamais manipuler les images brutes ni utiliser le GPU."
+            )
 
             with gr.Row():
                 with gr.Column():
                     clf_type = gr.Radio(
                         choices=["SVM", "Régression logistique", "k-NN", "Forêt aléatoire", "LDA"],
                         value="SVM",
-                        label="Algorithme",
+                        label="Algorithme de classification",
                     )
 
                     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")
+                        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")
-                        logreg_c = gr.Number(value=1.0, label="C (régularisation)")
+                        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")
-                        knn_k = gr.Slider(minimum=1, maximum=20, value=5, step=1, label="k (voisins)")
+                        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"
+                            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")
-                        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)")
+                        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")
+                        lda_solver = gr.Dropdown(
+                            choices=["svd", "lsqr", "eigen"], value="svd", label="Solveur"
+                        )
 
-                    ml_model_tag = gr.Textbox(label="Nom court du modèle", placeholder="ex. svm_rbf")
+                    ml_tag = gr.Textbox(
+                        label="Nom du modèle", placeholder="ex. svm_rbf_C1"
+                    )
                     train_classical_btn = gr.Button("Entraîner le classifieur", variant="primary")
 
                 with gr.Column():
@@ -307,58 +423,15 @@ with gr.Blocks(title="Classification d'images microscopiques") as demo:
             ml_cm_img = gr.Image(label="Matrice de confusion — figure", type="filepath")
 
         # ------------------------------------------------------------------ #
-        # Tab 3
-        # ------------------------------------------------------------------ #
-        with gr.Tab("3. Modèles neuronaux"):
-            gr.Markdown("## Architecture")
-
-            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."
-                        ),
-                    )
-
-                    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")
-
-                    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_neural_btn = gr.Button("Lancer l'entraînement", variant="primary")
-
-                with gr.Column():
-                    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")
-            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
+        # Tab 4 — Tester et analyser
         # ------------------------------------------------------------------ #
         with gr.Tab("4. Tester et analyser"):
-            gr.Markdown("## Sélectionner un modèle sauvegardé")
+            gr.Markdown("## Comparer et évaluer les modèles")
             gr.Markdown(
-                "_Tous les types de modèles apparaissent ici : classifieurs ML, têtes FC et CNN._"
+                "Tous les modèles entraînés dans les onglets précédents apparaissent ici — "
+                "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é."
             )
 
             with gr.Row():
@@ -366,14 +439,14 @@ with gr.Blocks(title="Classification d'images microscopiques") as demo:
                     model_selector = gr.Dropdown(
                         choices=initial_models,
                         value=initial_models[0] if initial_models else None,
-                        label="Modèle",
+                        label="Modèle sauvegardé",
                     )
                     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")
+                    model_info = gr.JSON(label="Métadonnées du modèle")
 
                 with gr.Column():
-                    evaluate_btn = gr.Button("Évaluer sur le test set", variant="primary")
+                    evaluate_btn = gr.Button("Évaluer sur le jeu de test", variant="primary")
                     eval_summary = gr.JSON(label="Résumé des métriques")
 
             eval_report = gr.Dataframe(label="Rapport de classification", interactive=False)
@@ -381,18 +454,26 @@ with gr.Blocks(title="Classification d'images microscopiques") as demo:
             eval_cm_img = gr.Image(label="Matrice de confusion — figure", type="filepath")
 
             gr.Markdown("## Prédiction sur une image importée")
+            gr.Markdown(
+                "Importez une image microscopique de charbon de bois et observez "
+                "comment les différents modèles la classifient."
+            )
             with gr.Row():
                 with gr.Column():
-                    upload_image = gr.Image(type="pil", label="Importer une image")
+                    upload_image = gr.Image(type="pil", label="Image à classer")
                     predict_btn = gr.Button("Prédire la classe", variant="primary")
                 with gr.Column():
-                    predict_text = gr.Textbox(label="Résultat", lines=7)
+                    predict_text = gr.Textbox(label="Résultat de la prédiction", 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")
+            gr.Markdown("## Test sur un échantillon aléatoire du jeu de test")
+            gr.Markdown(
+                "Tirez une image au hasard dans le jeu de test et vérifiez si le modèle "
+                "sélectionné la classe correctement."
+            )
+            random_test_btn = gr.Button("Tirer un échantillon aléatoire")
             with gr.Row():
-                random_img = gr.Image(type="pil", label="Image test")
+                random_img = gr.Image(type="pil", label="Image tirée")
                 random_text = gr.Textbox(label="Résultat", lines=7)
                 random_probs = gr.Label(label="Probabilités par classe")
 
@@ -412,6 +493,21 @@ with gr.Blocks(title="Classification d'images microscopiques") as demo:
         outputs=image_gallery,
     )
 
+    train_cnn_btn.click(
+        fn=train_cnn_callback,
+        inputs=[
+            num_conv_blocks, base_filters, kernel_size, use_batchnorm,
+            cnn_dropout, cnn_fc_dim,
+            cnn_lr, cnn_wd, cnn_bs, cnn_epochs,
+            cnn_tag,
+        ],
+        outputs=[
+            cnn_logs, cnn_history, cnn_summary,
+            cnn_report, cnn_cm, cnn_cm_img,
+            model_selector,
+        ],
+    )
+
     extract_btn.click(fn=extract_features_callback, inputs=None, outputs=extract_status)
 
     clf_type.change(
@@ -429,36 +525,16 @@ with gr.Blocks(title="Classification d'images microscopiques") as demo:
             knn_k, knn_metric,
             rf_n_estimators, rf_max_depth,
             lda_solver,
-            ml_model_tag,
+            ml_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=[
-            neural_logs, neural_history, neural_summary,
-            neural_report, neural_cm, neural_cm_img,
-            model_selector,
-        ],
-    )
-
     refresh_btn.click(fn=refresh_models_callback, inputs=None, outputs=model_selector)
 
-    load_info_btn.click(fn=get_model_info_callback, 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_callback,