Remplacer ResNet18 par un CNN simple configurable

- model.py : nouvelle classe SimpleCNN (blocs Conv→BN→ReLU→MaxPool,
pooling global adaptatif, classifieur FC)
- train_utils.py : paramètres num_conv_blocks, base_filters, kernel_size,
use_batchnorm ; lr par défaut 0.001, batch 32
- app.py : interface mise à jour avec les nouveaux contrôles CNN

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

app.py

@@ -53,24 +53,30 @@ def refresh_gallery_callback(split_name, class_name, max_images):
 
 @spaces.GPU(duration=300)
 def train_callback(
+    num_conv_blocks,
+    base_filters,
+    kernel_size,
+    use_batchnorm,
     dropout,
     fc_dim,
     learning_rate,
     weight_decay,
     batch_size,
     epochs,
-    fine_tune_mode,
     model_tag,
 ):
     try:
         result = train_model(
+            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),
-            fine_tune_mode=str(fine_tune_mode),
             model_tag=model_tag,
         )
 
@@ -199,14 +205,40 @@ with gr.Blocks(title="Classification d’images microscopiques") as demo:
             )
 
         with gr.Tab("2. Entraîner un modèle"):
-            gr.Markdown("## Entraînement avec ResNet18 pré-entraîné")
+            gr.Markdown("## Entraînement d’un CNN simple (entraîné de zéro)")
             gr.Markdown(
-                "Paramètres par défaut recommandés : fine-tuning de la dernière couche convolutionnelle "
-                "du ResNet18, faible taux d’apprentissage, augmentation légère des données."
+                "Configurez librement l’architecture du CNN : nombre de blocs convolutionnels, "
+                "nombre de filtres, taille du noyau, etc. Tous les paramètres sont entraînables."
             )
 
             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",
+                    )
+
+                    use_batchnorm = gr.Checkbox(
+                        value=True,
+                        label="Normalisation par lots (BatchNorm)",
+                    )
+
                     dropout = gr.Slider(
                         minimum=0.0,
                         maximum=0.8,
@@ -218,11 +250,11 @@ with gr.Blocks(title="Classification d’images microscopiques") as demo:
                     fc_dim = gr.Dropdown(
                         choices=[64, 128, 256, 512],
                         value=256,
-                        label="Dimension de la couche cachée",
+                        label="Dimension de la couche cachée (classifieur)",
                     )
 
                     learning_rate = gr.Number(
-                        value=0.00001,
+                        value=0.001,
                         label="Taux d’apprentissage",
                     )
 
@@ -233,7 +265,7 @@ with gr.Blocks(title="Classification d’images microscopiques") as demo:
 
                     batch_size = gr.Dropdown(
                         choices=[8, 16, 32, 64],
-                        value=16,
+                        value=32,
                         label="Taille du batch",
                     )
 
@@ -245,20 +277,9 @@ with gr.Blocks(title="Classification d’images microscopiques") as demo:
                         label="Nombre d’époques",
                     )
 
-                    fine_tune_mode = gr.Dropdown(
-                        choices=["frozen", "layer4", "full"],
-                        value="layer4",
-                        label="Mode de fine-tuning",
-                        info=(
-                            "frozen = seul le classifieur est entraîné ; "
-                            "layer4 = dernière partie du ResNet18 + classifieur ; "
-                            "full = tout le réseau est ajusté."
-                        ),
-                    )
-
                     model_tag = gr.Textbox(
                         label="Nom court du modèle",
-                        placeholder="ex. charbon_resnet18_layer4",
+                        placeholder="ex. cnn_3blocs_32filtres",
                     )
 
                     train_btn = gr.Button("Lancer l’entraînement", variant="primary")
@@ -360,13 +381,16 @@ with gr.Blocks(title="Classification d’images microscopiques") as demo:
     train_btn.click(
         fn=train_callback,
         inputs=[
+            num_conv_blocks,
+            base_filters,
+            kernel_size,
+            use_batchnorm,
             dropout,
             fc_dim,
             learning_rate,
             weight_decay,
             batch_size,
             epochs,
-            fine_tune_mode,
             model_tag,
         ],
         outputs=[

model.py

@@ -1,52 +1,47 @@
 import torch.nn as nn
-from torchvision import models
 
 
-class ResNet18Classifier(nn.Module):
+class SimpleCNN(nn.Module):
     def __init__(
         self,
         num_classes: int,
+        num_conv_blocks: int = 3,
+        base_filters: int = 32,
+        kernel_size: int = 3,
+        use_batchnorm: bool = True,
         dropout: float = 0.4,
         fc_dim: int = 256,
-        fine_tune_mode: str = "layer4",
     ):
         super().__init__()
 
-        weights = models.ResNet18_Weights.DEFAULT
-        self.backbone = models.resnet18(weights=weights)
-
-        in_features = self.backbone.fc.in_features
-
-        # Freeze everything first
-        for param in self.backbone.parameters():
-            param.requires_grad = False
-
-        # Fine-tuning strategy
-        if fine_tune_mode == "frozen":
-            pass
-
-        elif fine_tune_mode == "layer4":
-            for param in self.backbone.layer4.parameters():
-                param.requires_grad = True
-
-        elif fine_tune_mode == "full":
-            for param in self.backbone.parameters():
-                param.requires_grad = True
-
-        else:
-            raise ValueError(f"Unsupported fine_tune_mode: {fine_tune_mode}")
-
-        self.backbone.fc = nn.Sequential(
+        padding = kernel_size // 2
+        layers = []
+        in_channels = 3
+
+        for i in range(num_conv_blocks):
+            # Les filtres doublent à chaque bloc, plafonnés à 512
+            out_channels = min(base_filters * (2 ** i), 512)
+            layers.append(nn.Conv2d(in_channels, out_channels, kernel_size, padding=padding))
+            if use_batchnorm:
+                layers.append(nn.BatchNorm2d(out_channels))
+            layers.append(nn.ReLU(inplace=True))
+            layers.append(nn.MaxPool2d(2, 2))
+            in_channels = out_channels
+
+        self.features = nn.Sequential(*layers)
+        # Pooling global : indépendant de la taille spatiale d'entrée
+        self.pool = nn.AdaptiveAvgPool2d(1)
+
+        self.classifier = nn.Sequential(
             nn.Dropout(dropout),
-            nn.Linear(in_features, fc_dim),
-            nn.ReLU(),
+            nn.Linear(in_channels, fc_dim),
+            nn.ReLU(inplace=True),
             nn.Dropout(dropout),
             nn.Linear(fc_dim, num_classes),
         )
 
-        # Always train classifier head
-        for param in self.backbone.fc.parameters():
-            param.requires_grad = True
-
     def forward(self, x):
-        return self.backbone(x)
+        x = self.features(x)
+        x = self.pool(x)
+        x = x.flatten(1)
+        return self.classifier(x)

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 ResNet18Classifier
+from model import SimpleCNN
 
 
 def model_weight_path(model_name: str) -> str:
@@ -64,11 +64,14 @@ def load_model(model_name: str, device: torch.device) -> Tuple[nn.Module, dict]:
 
     cfg = meta["config"]
 
-    model = ResNet18Classifier(
+    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),
-        fine_tune_mode=cfg.get("fine_tune_mode", "layer4"),
     )
 
     state_dict = torch.load(weight_file, map_location="cpu")
@@ -125,13 +128,16 @@ def collect_predictions(model, loader, device):
 
 
 def train_model(
+    num_conv_blocks: int = 3,
+    base_filters: int = 32,
+    kernel_size: int = 3,
+    use_batchnorm: bool = True,
     dropout: float = 0.4,
     fc_dim: int = 256,
-    learning_rate: float = 0.00005,
+    learning_rate: float = 0.001,
     weight_decay: float = 0.0001,
-    batch_size: int = 16,
+    batch_size: int = 32,
     epochs: int = 30,
-    fine_tune_mode: str = "layer4",
     model_tag: str = "",
 ):
     device = get_runtime_device()
@@ -139,11 +145,14 @@ def train_model(
     train_loader, val_loader, test_loader, class_names = make_loaders(batch_size)
     num_classes = len(class_names)
 
-    model = ResNet18Classifier(
+    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,
-        fine_tune_mode=fine_tune_mode,
     ).to(device)
 
     trainable_params = sum(p.numel() for p in model.parameters() if p.requires_grad)
@@ -237,16 +246,19 @@ def train_model(
 
     config = {
         "dataset_name": DATASET_DISPLAY_NAME,
-        "architecture": "ResNet18 pretrained + classifier head",
+        "architecture": "CNN simple entraîné de zéro",
         "num_classes": num_classes,
         "class_names": class_names,
+        "num_conv_blocks": num_conv_blocks,
+        "base_filters": base_filters,
+        "kernel_size": kernel_size,
+        "use_batchnorm": use_batchnorm,
         "dropout": dropout,
         "fc_dim": fc_dim,
         "learning_rate": learning_rate,
         "weight_decay": weight_decay,
         "batch_size": batch_size,
         "epochs": epochs,
-        "fine_tune_mode": fine_tune_mode,
     }
 
     training_summary = {
@@ -271,7 +283,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"Mode de fine-tuning : {fine_tune_mode}")
+    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"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}")