Update

app.py

@@ -4,59 +4,49 @@ Intel Scene Classifier — Flask App
 
 import io
 import os
+import urllib.request
 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
-
-
-# ── 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 léger pour images RGB.
+    Entrée : (B, 3, 150, 150)
+    Sortie : logits transformés en 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
             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
             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
             nn.Conv2d(64, 128, kernel_size=3, padding=1, bias=False),
             nn.BatchNorm2d(128),
             nn.ReLU(inplace=True),
@@ -64,7 +54,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(),
@@ -80,17 +70,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
 
 
@@ -102,32 +104,26 @@ 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")
+        with urllib.request.urlopen(image_url) as response:
+            return Image.open(io.BytesIO(response.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
-
-    # framework = request.form.get("model", "pytorch")
+    framework = request.form.get("model", "pytorch")
 
     try:
         pil_img = read_input_image()
@@ -136,30 +132,42 @@ 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:
+
+        elif framework == "tensorflow":
             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]
+
+        else:
+            return jsonify({"error": "Framework non supporté"}), 400
 
         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)