Update

app.py

@@ -15,53 +15,36 @@ from torchvision import transforms
 
 app = Flask(__name__)
 
-CLASSES  = ["buildings", "forest", "glacier", "mountain", "sea", "street"]
+CLASSES = ["buildings", "forest", "glacier", "mountain", "sea", "street"]
 IMG_SIZE = 150
 
 _pytorch_model = None
-_tf_model      = None
-
-
-# ── Loaders ────────────────────────────────────────────────────────────────────
-def load_pytorch():
-    global _pytorch_model
-    if _pytorch_model is not None:
-        return _pytorch_model
+_tf_model = None
 
 
 class CNN_Torch(nn.Module):
     """
-    CNN PyTorch allégé pour images RGB (3 canaux).
-    Entrée  : (B, 3, 150, 150)
-    Sortie  : (B, num_classes) — log-softmax
-
-    Architecture :
-        Block 1 : Conv2d(3→32)  + BN + ReLU + MaxPool2d(2)          → 75×75
-        Block 2 : Conv2d(32→64) + BN + ReLU + MaxPool2d(2) + Drop2d → 37×37
-        Block 3 : Conv2d(64→128)+ BN + ReLU + MaxPool2d(2) + Drop2d → 18×18
-        GAP     : AdaptiveAvgPool2d(1)                               → (B,128)
-        Head    : Linear(128→256) + ReLU + Dropout + Linear(256→C)
-
-    Paramètre `dropout` contrôlé depuis l'extérieur → utilisé dans le CV.
+    CNN PyTorch pour images RGB (3, 150, 150)
+    Retourne des log-probabilités via log_softmax.
     """
     def __init__(self, num_classes: int = 6, dropout: float = 0.5):
         super().__init__()
 
         self.features = nn.Sequential(
-            # Block 1 — 150 → 75
+            # Block 1: 150 -> 75
             nn.Conv2d(3, 32, kernel_size=3, padding=1, bias=False),
             nn.BatchNorm2d(32),
             nn.ReLU(inplace=True),
             nn.MaxPool2d(2),
 
-            # Block 2 — 75 → 37
+            # Block 2: 75 -> 37
             nn.Conv2d(32, 64, kernel_size=3, padding=1, bias=False),
             nn.BatchNorm2d(64),
             nn.ReLU(inplace=True),
             nn.MaxPool2d(2),
             nn.Dropout2d(0.1),
 
-            # Block 3 — 37 → 18
+            # Block 3: 37 -> 18
             nn.Conv2d(64, 128, kernel_size=3, padding=1, bias=False),
             nn.BatchNorm2d(128),
             nn.ReLU(inplace=True),
@@ -69,7 +52,7 @@ class CNN_Torch(nn.Module):
             nn.Dropout2d(0.2),
         )
 
-        self.gap = nn.AdaptiveAvgPool2d(1)   # (B, 128, 18, 18) → (B, 128, 1, 1)
+        self.gap = nn.AdaptiveAvgPool2d(1)
 
         self.classifier = nn.Sequential(
             nn.Flatten(),
@@ -85,17 +68,29 @@ class CNN_Torch(nn.Module):
         x = self.classifier(x)
         return F.log_softmax(x, dim=1)
 
+
+def load_pytorch():
+    global _pytorch_model
+    if _pytorch_model is not None:
+        return _pytorch_model
+
     device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
-    model  = CNN_Torch(6).to(device)
-    model.load_state_dict(torch.load("parfait_model.pth", map_location=device))
+    model = CNN_Torch(num_classes=6).to(device)
+
+    state_dict = torch.load("parfait_model.pth", map_location=device)
+    model.load_state_dict(state_dict)
     model.eval()
 
-    tf = transforms.Compose([
+    tf_transform = transforms.Compose([
         transforms.Resize((IMG_SIZE, IMG_SIZE)),
         transforms.ToTensor(),
-        transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225]),
+        transforms.Normalize(
+            [0.485, 0.456, 0.406],
+            [0.229, 0.224, 0.225]
+        ),
     ])
-    _pytorch_model = (model, device, tf)
+
+    _pytorch_model = (model, device, tf_transform)
     return _pytorch_model
 
 
@@ -107,7 +102,6 @@ def load_tensorflow():
     return _tf_model
 
 
-# ── Routes ─────────────────────────────────────────────────────────────────────
 @app.route("/")
 def index():
     return render_template("index.html")
@@ -127,30 +121,36 @@ def predict():
 
     try:
         if framework == "pytorch":
-            import torch
-            model, device, tf = load_pytorch()
-            tensor = tf(pil_img).unsqueeze(0).to(device)
+            model, device, tf_transform = load_pytorch()
+            tensor = tf_transform(pil_img).unsqueeze(0).to(device)
+
             with torch.no_grad():
-                out   = model(tensor)
+                out = model(tensor)
                 probs = torch.exp(out).cpu().numpy()[0]
+
         else:
             model = load_tensorflow()
-            arr   = np.array(pil_img.resize((IMG_SIZE, IMG_SIZE)), dtype=np.float32)
-            probs = model.predict(np.expand_dims(arr, 0), verbose=0)[0]
+            arr = np.array(pil_img.resize((IMG_SIZE, IMG_SIZE)), dtype=np.float32)
+            arr = np.expand_dims(arr, axis=0)
+            probs = model.predict(arr, verbose=0)[0]
 
         pred_idx = int(np.argmax(probs))
         return jsonify({
-            "class":         CLASSES[pred_idx],
-            "confidence":    float(probs[pred_idx]),
-            "probabilities": {c: float(p) for c, p in zip(CLASSES, probs)},
+            "class": CLASSES[pred_idx],
+            "confidence": float(probs[pred_idx]),
+            "probabilities": {
+                c: float(p) for c, p in zip(CLASSES, probs)
+            },
         })
 
     except FileNotFoundError as e:
-        return jsonify({"error": f"Modèle introuvable : {e}. Placez les fichiers .pth et .keras à la racine."}), 500
+        return jsonify({
+            "error": f"Modèle introuvable : {e}. Placez les fichiers .pth et .keras à la racine."
+        }), 500
     except Exception as e:
         return jsonify({"error": str(e)}), 500
 
 
 if __name__ == "__main__":
     port = int(os.environ.get("PORT", 5000))
-    app.run(host="0.0.0.0", port=port, debug=False)
+    app.run(host="0.0.0.0", port=port, debug=False)