Update app.py

app.py

@@ -1,44 +1,111 @@
 import json
 
-import spaces
 import gradio as gr
+import spaces
 
-from train_utils import train_model, list_saved_models, model_meta_path
-from predict_utils import predict_uploaded_image, test_random_sample
+from data_utils import (
+    dataset_overview,
+    get_class_names,
+    get_images_for_gallery,
+)
+from train_utils import (
+    train_model,
+    list_saved_models,
+    model_meta_path,
+    evaluate_saved_model,
+)
+from predict_utils import (
+    predict_uploaded_image,
+    test_random_sample,
+)
+
+
+def load_dataset_overview_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"),
+        )
 
-@spaces.GPU(duration=120)
+    except Exception as e:
+        return (
+            {"Erreur": str(e)},
+            None,
+            gr.update(),
+        )
+
+
+def refresh_gallery_callback(split_name, class_name, max_images):
+    try:
+        gallery = get_images_for_gallery(
+            split_name=split_name,
+            class_name=class_name,
+            max_images=int(max_images),
+        )
+        return gallery
+    except Exception as e:
+        return [(None, f"Erreur : {str(e)}")]
+
+
+@spaces.GPU(duration=300)
 def train_callback(
-    conv1_channels,
-    conv2_channels,
-    kernel_size,
     dropout,
     fc_dim,
     learning_rate,
+    weight_decay,
     batch_size,
     epochs,
+    freeze_backbone,
     model_tag,
 ):
     try:
-        logs, history, summary, model_name = train_model(
-            int(conv1_channels),
-            int(conv2_channels),
-            int(kernel_size),
-            float(dropout),
-            int(fc_dim),
-            float(learning_rate),
-            int(batch_size),
-            int(epochs),
-            model_tag,
+        result = train_model(
+            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),
+            freeze_backbone=bool(freeze_backbone),
+            model_tag=model_tag,
         )
 
         models = list_saved_models()
-        selected = model_name if model_name in models else (models[0] if models else None)
+        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{str(e)}",
+            None,
+            None,
+            None,
+            None,
+            None,
+            gr.update(),
+        )
 
-        return logs, history, summary, gr.update(choices=models, value=selected)
 
+@spaces.GPU(duration=120)
+def evaluate_saved_model_callback(model_name):
+    try:
+        summary, report_df, cm_df, cm_path = evaluate_saved_model(model_name)
+        return summary, report_df, cm_df, cm_path
     except Exception as e:
-        return f"Échec de l’entraînement :\n{str(e)}", None, None, gr.update()
+        return {"Erreur": str(e)}, None, None, None
 
 
 @spaces.GPU(duration=60)
@@ -81,75 +148,182 @@ 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(
-        "Cette application permet d’entraîner un réseau de neurones convolutif simple "
-        "sur un jeu de données privé Hugging Face, puis de tester les modèles sauvegardés "
-        "sur une image importée ou sur un échantillon aléatoire."
+        "Application pédagogique pour explorer un jeu de données d’images microscopiques, "
+        "entraîner un modèle de classification et analyser ses performances."
     )
 
     with gr.Tabs():
-        with gr.Tab("Entraîner"):
+
+        with gr.Tab("1. Explorer le jeu de données"):
+            gr.Markdown("## Comprendre le jeu de données avant l’entraînement")
+
             with gr.Row():
-                with gr.Column():
-                    gr.Markdown("### Paramètres d’entraînement")
+                load_dataset_btn = gr.Button("Charger les informations du dataset", variant="primary")
 
-                    conv1_channels = gr.Slider(
-                        8, 64, value=16, step=8, label="Nombre de canaux - couche convolutionnelle 1"
-                    )
-                    conv2_channels = gr.Slider(
-                        16, 128, value=32, step=16, label="Nombre de canaux - couche convolutionnelle 2"
-                    )
-                    kernel_size = gr.Dropdown(
-                        choices=[3, 5], value=3, label="Taille du noyau"
-                    )
+            with gr.Row():
+                dataset_summary = gr.JSON(label="Résumé général du dataset")
+
+            with gr.Row():
+                class_distribution = gr.Dataframe(
+                    label="Distribution des images 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",
+                )
+                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",
+                )
+                refresh_gallery_btn = gr.Button("Afficher des exemples")
+
+            image_gallery = gr.Gallery(
+                label="Exemples d’images",
+                columns=4,
+                height=600,
+            )
+
+        with gr.Tab("2. Entraîner un modèle"):
+            gr.Markdown("## Entraînement avec ResNet18 pré-entraîné")
+            gr.Markdown(
+                "Le modèle utilise un backbone ResNet18 pré-entraîné sur ImageNet. "
+                "Pour limiter le surapprentissage sur un petit dataset, il est recommandé de commencer "
+                "avec le backbone gelé."
+            )
+
+            with gr.Row():
+                with gr.Column():
                     dropout = gr.Slider(
-                        0.0, 0.7, value=0.2, step=0.05, label="Dropout"
+                        0.0,
+                        0.8,
+                        value=0.5,
+                        step=0.05,
+                        label="Dropout",
                     )
-                    fc_dim = gr.Slider(
-                        32, 256, value=128, step=32, label="Dimension de la couche cachée fully-connected"
+                    fc_dim = gr.Dropdown(
+                        choices=[64, 128, 256, 512],
+                        value=256,
+                        label="Dimension de la couche cachée",
                     )
                     learning_rate = gr.Number(
-                        value=0.001, label="Taux d’apprentissage"
+                        value=0.0001,
+                        label="Taux d’apprentissage",
+                    )
+                    weight_decay = gr.Number(
+                        value=0.0001,
+                        label="Weight decay",
                     )
                     batch_size = gr.Dropdown(
-                        choices=[16, 32, 64, 128], value=32, label="Taille du batch"
+                        choices=[8, 16, 32, 64],
+                        value=16,
+                        label="Taille du batch",
                     )
                     epochs = gr.Slider(
-                        1, 20, value=5, step=1, label="Nombre d’époques"
+                        1,
+                        50,
+                        value=10,
+                        step=1,
+                        label="Nombre d’époques",
+                    )
+                    freeze_backbone = gr.Checkbox(
+                        value=True,
+                        label="Geler le backbone ResNet18",
                     )
                     model_tag = gr.Textbox(
                         label="Nom court du modèle",
-                        placeholder="ex. charbon_cnn_test"
+                        placeholder="ex. charbon_resnet18_test",
                     )
 
                     train_btn = gr.Button("Lancer l’entraînement", variant="primary")
 
                 with gr.Column():
-                    train_status = gr.Textbox(label="Journal d’entraînement", lines=18)
+                    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é d’entraînement")
+                    train_summary = gr.JSON(label="Résumé final")
+
+            gr.Markdown("## Résultats sur le test set")
 
-        with gr.Tab("Tester"):
             with gr.Row():
-                with gr.Column():
-                    gr.Markdown("### Modèle sauvegardé")
+                train_report = gr.Dataframe(
+                    label="Rapport de classification",
+                    interactive=False,
+                )
+
+            with gr.Row():
+                train_confusion_matrix = gr.Dataframe(
+                    label="Matrice de confusion",
+                    interactive=False,
+                )
 
+            with gr.Row():
+                train_confusion_matrix_image = gr.Image(
+                    label="Matrice de confusion - figure",
+                    type="filepath",
+                )
+
+        with gr.Tab("3. Tester et analyser un modèle"):
+            gr.Markdown("## Sélectionner un modèle sauvegardé")
+
+            with gr.Row():
+                with gr.Column():
                     model_selector = gr.Dropdown(
                         choices=initial_models,
                         value=initial_models[0] if initial_models else None,
-                        label="Sélectionner un modèle",
+                        label="Modèle sauvegardé",
                     )
                     refresh_btn = gr.Button("Actualiser la liste des modèles")
                     load_info_btn = gr.Button("Afficher les informations du modèle")
                     model_info = gr.JSON(label="Métadonnées du modèle")
 
                 with gr.Column():
-                    gr.Markdown("### Prédiction sur une image importée")
+                    evaluate_btn = gr.Button("Évaluer le modèle 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,
+                    )
+
+            with gr.Row():
+                eval_confusion_matrix = gr.Dataframe(
+                    label="Matrice de confusion",
+                    interactive=False,
+                )
 
+            with gr.Row():
+                eval_confusion_matrix_image = 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_probs = gr.Label(label="Probabilités par classe")
 
+            gr.Markdown("## Test sur un échantillon aléatoire du test set")
+
             with gr.Row():
                 random_test_btn = gr.Button("Tester un échantillon aléatoire")
 
@@ -158,20 +332,39 @@ with gr.Blocks(title="Classification d’images microscopiques") as demo:
                 random_sample_text = gr.Textbox(label="Résultat sur l’échantillon", lines=7)
                 random_sample_probs = gr.Label(label="Probabilités par classe")
 
+    load_dataset_btn.click(
+        fn=load_dataset_overview_callback,
+        inputs=None,
+        outputs=[dataset_summary, class_distribution, class_selector],
+    )
+
+    refresh_gallery_btn.click(
+        fn=refresh_gallery_callback,
+        inputs=[split_selector, class_selector, max_images],
+        outputs=image_gallery,
+    )
+
     train_btn.click(
         fn=train_callback,
         inputs=[
-            conv1_channels,
-            conv2_channels,
-            kernel_size,
             dropout,
             fc_dim,
             learning_rate,
+            weight_decay,
             batch_size,
             epochs,
+            freeze_backbone,
             model_tag,
         ],
-        outputs=[train_status, train_history, train_summary, model_selector],
+        outputs=[
+            train_status,
+            train_history,
+            train_summary,
+            train_report,
+            train_confusion_matrix,
+            train_confusion_matrix_image,
+            model_selector,
+        ],
     )
 
     refresh_btn.click(
@@ -186,6 +379,17 @@ with gr.Blocks(title="Classification d’images microscopiques") as demo:
         outputs=model_info,
     )
 
+    evaluate_btn.click(
+        fn=evaluate_saved_model_callback,
+        inputs=model_selector,
+        outputs=[
+            eval_summary,
+            eval_report,
+            eval_confusion_matrix,
+            eval_confusion_matrix_image,
+        ],
+    )
+
     predict_btn.click(
         fn=predict_uploaded_image_callback,
         inputs=[model_selector, upload_image],
@@ -200,4 +404,4 @@ with gr.Blocks(title="Classification d’images microscopiques") as demo:
 
 
 if __name__ == "__main__":
-    demo.launch()
+    demo.launch(ssr_mode=False)