Update

app.py

@@ -8,43 +8,55 @@ import numpy as np
 from flask import Flask, jsonify, render_template, request
 from PIL import Image
 
-import torch
-import torch.nn as nn
-import torch.nn.functional as F
-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
+_tf_model      = None
+
+
+# ── Loaders ────────────────────────────────────────────────────────────────────
+def load_pytorch():
+    global _pytorch_model
+    if _pytorch_model is not None:
+        return _pytorch_model
 
 
 class CNN_Torch(nn.Module):
     """
-    CNN PyTorch pour images RGB (3, 150, 150)
-    Retourne des log-probabilités via log_softmax.
+    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.
     """
     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),
@@ -52,7 +64,7 @@ class CNN_Torch(nn.Module):
             nn.Dropout2d(0.2),
         )
 
-        self.gap = nn.AdaptiveAvgPool2d(1)
+        self.gap = nn.AdaptiveAvgPool2d(1)   # (B, 128, 18, 18) → (B, 128, 1, 1)
 
         self.classifier = nn.Sequential(
             nn.Flatten(),
@@ -68,29 +80,17 @@ 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(num_classes=6).to(device)
-
-    state_dict = torch.load("parfait_model.pth", map_location=device)
-    model.load_state_dict(state_dict)
+    model  = CNN_Torch(6).to(device)
+    model.load_state_dict(torch.load("parfait_model.pth", map_location=device))
     model.eval()
 
-    tf_transform = transforms.Compose([
+    tf = 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_transform)
+    _pytorch_model = (model, device, tf)
     return _pytorch_model
 
 
@@ -102,55 +102,64 @@ def load_tensorflow():
     return _tf_model
 
 
+
+def read_input_image():
+    if "image" in request.files and request.files["image"].filename:
+        return Image.open(io.BytesIO(request.files["image"].read())).convert("RGB")
+
+    image_url = request.form.get("image_url", "").strip()
+    if image_url:
+        with urllib.request.urlopen(image_url) as resp:
+            return Image.open(io.BytesIO(resp.read())).convert("RGB")
+
+    raise ValueError("No image provided")
+
+# ── Routes ─────────────────────────────────────────────────────────────────────
 @app.route("/")
 def index():
     return render_template("index.html")
 
 
+
+
 @app.route("/predict", methods=["POST"])
 def predict():
-    if "image" not in request.files:
-        return jsonify({"error": "Aucune image fournie"}), 400
+    # if "image" not in request.files:
+    #     return jsonify({"error": "Aucune image fournie"}), 400
 
-    framework = request.form.get("model", "pytorch")
+    # framework = request.form.get("model", "pytorch")
 
     try:
-        pil_img = Image.open(io.BytesIO(request.files["image"].read())).convert("RGB")
+        pil_img = read_input_image()
     except Exception:
         return jsonify({"error": "Fichier image invalide"}), 400
 
     try:
         if framework == "pytorch":
-            model, device, tf_transform = load_pytorch()
-            tensor = tf_transform(pil_img).unsqueeze(0).to(device)
-
+            import torch
+            model, device, tf = load_pytorch()
+            tensor = tf(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)
-            arr = np.expand_dims(arr, axis=0)
-            probs = model.predict(arr, verbose=0)[0]
+            arr   = np.array(pil_img.resize((IMG_SIZE, IMG_SIZE)), dtype=np.float32)
+            probs = model.predict(np.expand_dims(arr, 0), 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)

parfait_model.keras

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:a477cdf46a8abe2d6c9aede0dee169e4d3b0f5706f57e8e40a8db3ed1ac0c133
+oid sha256:70968e23930d4f12cd05b9beaa9ffd0fe969d8fb2bb312153c599adf1d8a0ade
 size 1619355

parfait_model.pth

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:1ad964d670faae671f200a74dc90713a00af83e18f2114bcddc521b496a29f96
-size 521545
+oid sha256:1fe727faa7a44e19589bdfe86434ab17416ff240f150d84df7f08e4d4862be0f
+size 523282