Ajouter ResNet18 (layer4 + classifieur) comme option de modèle

- model.py : classe ResNet18Classifier restaurée (layer4 + tête FC)
- train_utils.py : paramètre model_type, instanciation et config selon le choix
- app.py : radio CNN simple / ResNet18, panneau CNN masquable,
lr ajusté automatiquement selon le modèle sélectionné

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

app.py

@@ -51,8 +51,15 @@ def refresh_gallery_callback(split_name, class_name, max_images):
         return [(None, f"Erreur : {str(e)}")]
 
 
+def on_model_type_change(model_type):
+    is_cnn = (model_type == "CNN simple")
+    default_lr = 0.001 if is_cnn else 0.0001
+    return gr.update(visible=is_cnn), gr.update(value=default_lr)
+
+
 @spaces.GPU(duration=200)
 def train_callback(
+    model_type,
     num_conv_blocks,
     base_filters,
     kernel_size,
@@ -67,6 +74,7 @@ def train_callback(
 ):
     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),
@@ -205,39 +213,49 @@ with gr.Blocks(title="Classification d’images microscopiques") as demo:
             )
 
         with gr.Tab("2. Entraîner un modèle"):
-            gr.Markdown("## Entraînement d’un CNN simple (entraîné de zéro)")
-            gr.Markdown(
-                "Configurez librement l’architecture du CNN : nombre de blocs convolutionnels, "
-                "nombre de filtres, taille du noyau, etc. Tous les paramètres sont entraînables."
-            )
+            gr.Markdown("## Choix du modèle et entraînement")
 
             with gr.Row():
                 with gr.Column():
-                    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.",
-                    )
-
-                    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",
+                    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."
+                        ),
                     )
 
-                    use_batchnorm = gr.Checkbox(
-                        value=True,
-                        label="Normalisation par lots (BatchNorm)",
-                    )
+                    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.",
+                        )
+
+                        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",
+                        )
+
+                        use_batchnorm = gr.Checkbox(
+                            value=True,
+                            label="Normalisation par lots (BatchNorm)",
+                        )
+
+                    gr.Markdown("#### Hyperparamètres d’entraînement")
 
                     dropout = gr.Slider(
                         minimum=0.0,
@@ -279,7 +297,7 @@ with gr.Blocks(title="Classification d’images microscopiques") as demo:
 
                     model_tag = gr.Textbox(
                         label="Nom court du modèle",
-                        placeholder="ex. cnn_3blocs_32filtres",
+                        placeholder="ex. cnn_3blocs ou resnet18_ft",
                     )
 
                     train_btn = gr.Button("Lancer l’entraînement", variant="primary")
@@ -378,9 +396,16 @@ 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],
+    )
+
     train_btn.click(
         fn=train_callback,
         inputs=[
+            model_type,
             num_conv_blocks,
             base_filters,
             kernel_size,

model.py

@@ -1,4 +1,33 @@
 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
+
+        self.backbone.fc = nn.Sequential(
+            nn.Dropout(dropout),
+            nn.Linear(in_features, fc_dim),
+            nn.ReLU(),
+            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)
 
 
 class SimpleCNN(nn.Module):

train_utils.py

@@ -11,7 +11,7 @@ import torch.optim as optim
 from config import MODEL_DIR, META_DIR, DATASET_DISPLAY_NAME
 from data_utils import make_loaders
 from metrics_utils import compute_classification_metrics, save_confusion_matrix_figure
-from model import SimpleCNN
+from model import SimpleCNN, ResNet18Classifier
 
 
 def model_weight_path(model_name: str) -> str:
@@ -64,15 +64,22 @@ def load_model(model_name: str, device: torch.device) -> Tuple[nn.Module, dict]:
 
     cfg = meta["config"]
 
-    model = SimpleCNN(
-        num_classes=cfg["num_classes"],
-        num_conv_blocks=cfg.get("num_conv_blocks", 3),
-        base_filters=cfg.get("base_filters", 32),
-        kernel_size=cfg.get("kernel_size", 3),
-        use_batchnorm=cfg.get("use_batchnorm", True),
-        dropout=cfg.get("dropout", 0.4),
-        fc_dim=cfg.get("fc_dim", 256),
-    )
+    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),
+        )
+    else:
+        model = SimpleCNN(
+            num_classes=cfg["num_classes"],
+            num_conv_blocks=cfg.get("num_conv_blocks", 3),
+            base_filters=cfg.get("base_filters", 32),
+            kernel_size=cfg.get("kernel_size", 3),
+            use_batchnorm=cfg.get("use_batchnorm", True),
+            dropout=cfg.get("dropout", 0.4),
+            fc_dim=cfg.get("fc_dim", 256),
+        )
 
     state_dict = torch.load(weight_file, map_location="cpu")
     model.load_state_dict(state_dict)
@@ -128,6 +135,7 @@ def collect_predictions(model, loader, device):
 
 
 def train_model(
+    model_type: str = "cnn",
     num_conv_blocks: int = 3,
     base_filters: int = 32,
     kernel_size: int = 3,
@@ -145,15 +153,22 @@ def train_model(
     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)
+    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())
@@ -257,9 +272,15 @@ def train_model(
 
     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})"
+
     config = {
         "dataset_name": DATASET_DISPLAY_NAME,
-        "architecture": "CNN simple entraîné de zéro",
+        "model_type": model_type,
+        "architecture": architecture,
         "num_classes": num_classes,
         "class_names": class_names,
         "num_conv_blocks": num_conv_blocks,
@@ -296,7 +317,7 @@ def train_model(
     logs.append("Entraînement terminé.")
     logs.append(f"Modèle sauvegardé : {model_name}")
     logs.append(f"Appareil utilisé : {device}")
-    logs.append(f"Architecture : {num_conv_blocks} blocs conv, filtres de base={base_filters}, noyau={kernel_size}x{kernel_size}, BatchNorm={use_batchnorm}")
+    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}")