app update

.gitignore

@@ -7,5 +7,10 @@
 # Fichiers générés automatiquement
 __pycache__/
 *.pyc
+
 *.pptx
 .dockerignore
+app_v0.py
+inference_v0.py
+Dockerfile
+Notes.txt

app.py

@@ -1,6 +1,7 @@
-import streamlit as st                         # librairie pour le dashboard
-from PIL import Image                          # pour ouvrir les images
-from inference import (                        # fonctions importées du fichier inference.py
+import os                                   # pour vérifier la présence des fichiers de modèles
+import streamlit as st                      # librairie pour le dashboard
+from PIL import Image                       # pour ouvrir les images
+from inference import (                     # fonctions importées du fichier inference.py
     load_model,
     get_val_transform,
     predict_from_pil
@@ -10,36 +11,48 @@ from inference import (                        # fonctions importées du fichier
 # Configuration de la page
 # -----------------------------------------------------------
 st.set_page_config(
-    page_title="Fire Detection Dashboard",      # titre de l’onglet du navigateur
-    page_icon="🔥",                             # icône (emoji)
-    layout="centered"                           # mise en page centrée
+    page_title="Fire Detection Dashboard",   # titre de l’onglet du navigateur
+    page_icon="🔥",                          # icône (emoji)
+    layout="centered"                        # mise en page centrée
 )
 
 # -----------------------------------------------------------
-# Chargement du modèle (une seule fois)
+# Déclaration des modèles potentiels
 # -----------------------------------------------------------
-@st.cache_resource
-def load_app_model():
-    """
-    Charge le modèle, le device et la transform une seule fois,
-    puis les réutilise pour toutes les prédictions.
-    """
-    model, device = load_model("efficientnet_fire.pt")  # charge les poids
-    transform = get_val_transform()                     # transform validation/inférence
-    return model, device, transform
+ALL_MODEL_FILES = {
+    "Modèle Efficientnet Baseline": "efficientnet_fire.pt",
+    "Modèle Efficientnet Improved": "efficientnet_fire_2.pt",
+    "Modèle Inception3": "inception3_fire.pt",
+}
+
+# Ne garder que les modèles réellement présents dans le repo
+MODEL_FILES = {
+    name: path for name, path in ALL_MODEL_FILES.items() if os.path.exists(path)
+}
 
-model, device, transform = load_app_model()
+if len(MODEL_FILES) == 0:
+    st.error("❌ Aucun modèle trouvé dans le repository. Ajoutez au moins un fichier .pt.")
+    st.stop()
 
 # -----------------------------------------------------------
-# Sidebar : infos et paramètres
+# Sidebar : choix du modèle + infos et paramètres
 # -----------------------------------------------------------
 st.sidebar.title("⚙️ Paramètres")
+
+selected_model_name = st.sidebar.selectbox(
+    "Choisir le modèle à utiliser",
+    options=list(MODEL_FILES.keys()),
+    index=0
+)
+selected_model_path = MODEL_FILES[selected_model_name]
+
+st.sidebar.markdown(f"🧠 Modèle sélectionné : **{selected_model_name}**")
+
 st.sidebar.markdown(
     """
-Ce dashboard utilise un modèle EfficientNet-B0,  
-entraîné à prédire **FIRE / NO FIRE** sur des images.
+Ce dashboard prédit **FIRE / NO FIRE** sur des images.
 
-- Classe 0 : **no_fire**
+- Classe 0 : **no_fire**  
 - Classe 1 : **fire**
     """
 )
@@ -54,26 +67,41 @@ threshold = st.sidebar.slider(
 
 st.sidebar.markdown(f"Seuil actuel : **{threshold:.2f}**")
 
+# -----------------------------------------------------------
+# Chargement du modèle (en fonction du choix)
+# -----------------------------------------------------------
+@st.cache_resource
+def load_app_model(model_path: str):
+    """
+    Charge le modèle, le device et la transform une seule fois
+    pour un chemin donné, puis les réutilise pour toutes les prédictions.
+    """
+    model, device = load_model(model_path)   # charge les poids du modèle choisi
+    transform = get_val_transform()          # transform validation/inférence
+    return model, device, transform
+
+model, device, transform = load_app_model(selected_model_path)
+
 # -----------------------------------------------------------
 # Titre principal
 # -----------------------------------------------------------
 st.title("🔥 Fire Detection Dashboard")
 st.markdown(
     """
-Ce prototype permet de tester un modèle de détection de feu,  
-sur des images individuelles.
+Ce prototype permet de tester un modèle de détection de feu  
+sur des images individuelles.  
 
 _Charger une image pour obtenir une prédiction._
     """
 )
 
 # -----------------------------------------------------------
-# Zone d'upload d'image (texte personnalisé ajouté)
+# Zone d'upload d'image
 # -----------------------------------------------------------
 uploaded_file = st.file_uploader(
-    "📂 Déposez une image ici (ou cliquez sur Browse Files pour choisir une image)",    
+    "📂 Déposez une image ici (ou cliquez sur Browse Files pour choisir une image)",
     type=["jpg", "jpeg", "png"],
-    help="Formats supportés : JPG, JPEG, PNG\nMaximum 200MB par image",                                       
+    help="Formats supportés : JPG, JPEG, PNG\nMaximum 200MB par image",
     accept_multiple_files=False
 )
 
@@ -121,8 +149,10 @@ else:
     with st.expander("🔍 Détails techniques (optionnel)"):
         st.markdown(
             f"""
-- Label retourné : **{label}**
-- Probabilité brute de la classe *fire* : **{prob:.4f}**
+- Modèle utilisé : **{selected_model_name}**  
+- Fichier de poids : `{selected_model_path}`  
+- Label retourné : **{label}**  
+- Probabilité brute de la classe *fire* : **{prob:.4f}**  
 - Seuil de décision : **{threshold:.2f}**
 
 Si `prob_fire >= seuil` → prédiction = *fire*,  

inference.py

@@ -1,21 +1,23 @@
 """
 inference.py
 ------------
-Module d'inférence pour le modèle EfficientNet-B0 entraîné
-sur la classification binaire : FIRE (1) / NO_FIRE (0).
+Module d'inférence pour des modèles de classification binaire : FIRE (1) / NO_FIRE (0).
 
-Compatible :
-- Google Colab
-- Exécution locale (Python)
-- Lightning AI
-- HuggingFace Spaces / Streamlit
+Compatible avec plusieurs architectures (ex. EfficientNet-B0, Inception v3),
+sans changer le code dès qu'on ajoute un nouveau fichier .pt, à condition :
+
+- que le nom du fichier permette de deviner le type de modèle
+  (ex : "inception3_fire.pt" → Inception v3,
+        sinon → EfficientNet-B0 par défaut),
+- ou que le fichier .pt contienne un dictionnaire avec "state_dict" (et
+  éventuellement "model_name" / "model_key").
 
 Usage typique :
 ---------------
 from inference import load_model, get_val_transform, predict_from_path
 
 model, device = load_model("efficientnet_fire.pt")
-transform = get_val_transform()
+transform = get_val_transform()  # ou get_val_transform(image_size_personnalisée)
 
 label, prob = predict_from_path("mon_image.jpg", model, device, transform)
 print(label, prob)
@@ -24,19 +26,20 @@ print(label, prob)
 # ----------------------------
 # 1) Imports
 # ----------------------------
-import torch                         # bibliothèque principale pour le deep learning
-import torch.nn as nn                # pour définir la tête de classification
-from torchvision import transforms   # pour les pré-traitements d'images
-from PIL import Image                # pour charger les images depuis un fichier
-import timm                          # pour charger EfficientNet-B0
+import os                               # pour gérer les chemins de fichiers
+import torch                            # bibliothèque principale pour le deep learning
+import torch.nn as nn                   # pour définir les têtes de classification
+from torchvision import transforms      # pour les pré-traitements d'images
+from PIL import Image                   # pour charger les images depuis un fichier
+import timm                             # pour charger des architectures (EfficientNet, Inception, etc.)
 
 
 # ----------------------------
 # 2) Constantes globales
 # ----------------------------
 
-# Taille d'entrée du modèle EfficientNet-B0
-IMAGE_SIZE = 224  # (224 x 224 pixels)
+# Taille d'entrée par défaut (utilisée si on ne précise rien d'autre).
+DEFAULT_IMAGE_SIZE = 224  # (224 x 224 pixels)
 
 # Moyennes et écarts-types d'ImageNet (pour normaliser les images)
 IMAGENET_MEAN = [0.485, 0.456, 0.406]   # moyenne des canaux R, G, B
@@ -48,6 +51,27 @@ IDX_TO_LABEL = {
     1: "fire"       # classe 1 → feu
 }
 
+# Registre des modèles supportés.
+# - model_key : identifiant interne (nos clés)
+# - timm_name : nom utilisé dans timm.create_model(...)
+# - image_size : taille d'entrée "recommandée" pour ce modèle (optionnelle)
+# - classifier_attr : nom de l'attribut contenant la dernière couche de classification
+MODEL_REGISTRY = {
+    "efficientnet_b0": {
+        "timm_name": "efficientnet_b0",
+        "image_size": 224,
+        "classifier_attr": "classifier",
+    },
+    "inception_v3": {
+        "timm_name": "inception_v3",
+        "image_size": 299,
+        "classifier_attr": "fc",
+    },
+}
+
+# Si on ne reconnaît pas de modèle particulier, on utilisera EfficientNet-B0 par défaut.
+DEFAULT_MODEL_KEY = "efficientnet_b0"
+
 
 # ----------------------------
 # 3) Utilitaires device
@@ -59,47 +83,115 @@ def get_device():
     - 'cuda' si un GPU est disponible
     - sinon 'cpu'
     """
-    # torch.cuda.is_available() renvoie True si un GPU CUDA est accessible
     if torch.cuda.is_available():
-        return torch.device("cuda")   # on utilisera le GPU
+        return torch.device("cuda")
     else:
-        return torch.device("cpu")    # sinon le CPU
+        return torch.device("cpu")
 
 
 # ----------------------------
-# 4) Chargement du modèle
+# 4) Détection du type de modèle
 # ----------------------------
 
-def build_model(num_classes=2):
+def infer_model_key_from_path(weights_path: str) -> str:
     """
-    Construit l'architecture EfficientNet-B0 avec une tête
-    adaptée à la classification binaire (2 classes).
-    Les poids seront chargés ensuite via load_state_dict.
+    Devine une clé de modèle (model_key) à partir du nom de fichier.
+    Exemple :
+    - "inception3_fire.pt"  → "inception_v3"
+    - "efficientnet_fire.pt" → "efficientnet_b0" (par défaut)
     """
-    # On crée le modèle EfficientNet-B0 sans poids pré-entraînés ici
-    # (les poids spécifiques à ton projet seront chargés après)
-    model = timm.create_model("efficientnet_b0", pretrained=False)
+    filename = os.path.basename(weights_path).lower()
+
+    # Règle simple : si "inception" est dans le nom → Inception v3
+    if "inception" in filename:
+        return "inception_v3"
 
-    # On récupère le nombre de features en entrée de la dernière couche
-    in_features = model.classifier.in_features
+    # Sinon, par défaut → EfficientNet-B0
+    return DEFAULT_MODEL_KEY
 
-    # On remplace la dernière couche par une couche linéaire avec num_classes sorties
-    model.classifier = nn.Linear(in_features, num_classes)
+
+def get_model_config(model_key: str) -> dict:
+    """
+    Renvoie la config du modèle à partir d'une model_key.
+    Si model_key n'est pas connue, on retourne la config du modèle par défaut.
+    """
+    if model_key in MODEL_REGISTRY:
+        return MODEL_REGISTRY[model_key]
+    # Fallback de sécurité : ne jamais casser si clé inconnue
+    return MODEL_REGISTRY[DEFAULT_MODEL_KEY]
+
+
+# ----------------------------
+# 5) Construction de l'architecture
+# ----------------------------
+
+def build_model(model_key: str, num_classes: int = 2) -> torch.nn.Module:
+    """
+    Construit l'architecture correspondant à model_key
+    et adapte la tête de classification à num_classes sorties.
+    """
+    config = get_model_config(model_key)
+    timm_name = config["timm_name"]
+    classifier_attr = config["classifier_attr"]
+
+    # On crée le backbone via timm (sans pré-entraînement, les poids viendront du .pt)
+    model = timm.create_model(timm_name, pretrained=False)
+
+    # On adapte la tête de classification à notre problème binaire.
+    # On récupère l'ancienne couche de classification (fc, classifier, etc.)
+    classifier = getattr(model, classifier_attr)
+
+    # Certains modèles ont déjà un nn.Linear, on récupère in_features
+    if isinstance(classifier, nn.Linear):
+        in_features = classifier.in_features
+    else:
+        # Cas plus exotique : on essaie de deviner proprement, sinon on lève une erreur claire.
+        raise ValueError(
+            f"Impossible de déterminer in_features pour la tête du modèle '{timm_name}'. "
+            f"Attribut '{classifier_attr}' de type {type(classifier)} non supporté."
+        )
+
+    # On remplace par une couche linéaire adaptée à notre nombre de classes
+    new_classifier = nn.Linear(in_features, num_classes)
+    setattr(model, classifier_attr, new_classifier)
 
     return model
 
 
-def load_model(weights_path: str, map_location=None):
+# ----------------------------
+# 6) Chargement du modèle
+# ----------------------------
+
+def _clean_state_dict_keys(state_dict: dict) -> dict:
+    """
+    Nettoie les clés d'un state_dict pour gérer plusieurs cas courants :
+    - clés préfixées par 'model.' (Lightning)
+    - clés préfixées par 'module.' (DataParallel)
     """
-    Charge le modèle EfficientNet-B0 avec les poids entraînés.
+    new_state_dict = {}
+    for k, v in state_dict.items():
+        new_key = k
+        if new_key.startswith("model."):
+            new_key = new_key[len("model."):]
+        if new_key.startswith("module."):
+            new_key = new_key[len("module."):]
+        new_state_dict[new_key] = v
+    return new_state_dict
+
+
+def load_model(weights_path: str, map_location=None, model_key: str | None = None):
+    """
+    Charge un modèle avec les poids entraînés.
 
     Paramètres
     ----------
     weights_path : str
-        Chemin vers le fichier .pt contenant les poids (state_dict).
+        Chemin vers le fichier .pt (state_dict ou dict avec 'state_dict').
     map_location : torch.device ou None
-        Device sur lequel charger les poids.
-        Si None, on détecte automatiquement (GPU si dispo, sinon CPU).
+        Device sur lequel charger les poids. Si None, on détecte automatiquement.
+    model_key : str ou None
+        Clé de modèle à utiliser (ex: 'efficientnet_b0', 'inception_v3').
+        Si None, on essaie de la déduire du nom de fichier.
 
     Retour
     ------
@@ -108,52 +200,87 @@ def load_model(weights_path: str, map_location=None):
     device : torch.device
         Le device utilisé (cuda ou cpu).
     """
-    # On détecte le device si non fourni
+    # 1) Sélection du device
     device = map_location if map_location is not None else get_device()
 
-    # On construit l'architecture du modèle
-    model = build_model(num_classes=2)
+    # 2) Si la model_key n'est pas donnée, on essaye de l'inférer depuis le nom de fichier
+    if model_key is None:
+        model_key = infer_model_key_from_path(weights_path)
+
+    # 3) Chargement brut du .pt
+    checkpoint = torch.load(weights_path, map_location=device)
+
+    # 4) Si le checkpoint est un dict complet (ex: {'state_dict': ..., 'model_name': ...})
+    if isinstance(checkpoint, dict) and "state_dict" in checkpoint:
+        state_dict = checkpoint["state_dict"]
+
+        # Optionnel : si un model_name ou model_key est stocké dedans, on peut le préférer.
+        if "model_key" in checkpoint and checkpoint["model_key"] in MODEL_REGISTRY:
+            model_key = checkpoint["model_key"]
+        elif "model_name" in checkpoint:
+            # Tentative : si model_name correspond au timm_name d'une entrée du registre
+            model_name_lower = str(checkpoint["model_name"]).lower()
+            for k, cfg in MODEL_REGISTRY.items():
+                if cfg["timm_name"].lower() == model_name_lower:
+                    model_key = k
+                    break
+    else:
+        # Cas simple : le fichier .pt est directement un state_dict
+        state_dict = checkpoint
+
+    # 5) Nettoyage des clés du state_dict (Lightning, DataParallel...)
+    state_dict = _clean_state_dict_keys(state_dict)
 
-    # On charge le dictionnaire de poids sauvegardés (state_dict)
-    state_dict = torch.load(weights_path, map_location=device)
+    # 6) Construction de l'architecture adaptée
+    model = build_model(model_key=model_key, num_classes=2)
 
-    # On applique les poids au modèle
-    model.load_state_dict(state_dict)
+    # 7) Application des poids (strict=False pour tolérer quelques petites diff de clés)
+    missing, unexpected = model.load_state_dict(state_dict, strict=False)
 
-    # On envoie le modèle sur le bon device (GPU ou CPU)
-    model = model.to(device)
+    # (Optionnel) DEBUG : on pourrait afficher missing / unexpected si besoin
+    # print("Missing keys:", missing)
+    # print("Unexpected keys:", unexpected)
 
-    # On passe le modèle en mode évaluation (important pour dropout, batchnorm, etc.)
+    # 8) Envoi sur le bon device + mode eval
+    model = model.to(device)
     model.eval()
 
     return model, device
 
 
 # ----------------------------
-# 5) Transforms pour l'inférence
+# 7) Transforms pour l'inférence
 # ----------------------------
 
-def get_val_transform():
+def get_val_transform(image_size: int | None = None):
     """
     Renvoie les transformations à appliquer aux images pour l'inférence.
-    Ce sont les mêmes que pour la validation :
-    - Resize 224x224
-    - ToTensor
-    - Normalize (ImageNet)
+    Paramètres
+    ----------
+    image_size : int ou None
+        Si None, on utilise DEFAULT_IMAGE_SIZE (224).
+        Sinon, on redimensionne en (image_size, image_size).
+
+    Retour
+    ------
+    transform : torchvision.transforms.Compose
     """
+    if image_size is None:
+        image_size = DEFAULT_IMAGE_SIZE
+
     transform = transforms.Compose([
-        transforms.Resize((IMAGE_SIZE, IMAGE_SIZE)),              # redimensionne en 224x224
-        transforms.ToTensor(),                                    # convertit PIL → Tensor [0,1]
-        transforms.Normalize(mean=IMAGENET_MEAN, std=IMAGENET_STD)  # normalise selon ImageNet
+        transforms.Resize((image_size, image_size)),
+        transforms.ToTensor(),
+        transforms.Normalize(mean=IMAGENET_MEAN, std=IMAGENET_STD),
     ])
     return transform
 
 
 # ----------------------------
-# 6) Prétraitement d'une image
+# 8) Prétraitement d'une image
 # ----------------------------
 
-def preprocess_image(image: Image.Image, transform=None):
+def preprocess_image(image: Image.Image, transform=None, image_size: int | None = None):
     """
     Applique les transforms à une image PIL et ajoute une dimension batch.
 
@@ -162,43 +289,43 @@ def preprocess_image(image: Image.Image, transform=None):
     image : PIL.Image.Image
         Image brute chargée (par exemple via Image.open(...)).
     transform : callable ou None
-        Transformations à appliquer (si None, on utilise get_val_transform()).
+        Transformations à appliquer (si None, on utilise get_val_transform(image_size)).
+    image_size : int ou None
+        Taille de redimensionnement si transform est None.
 
     Retour
     ------
     image_tensor : torch.Tensor
-        Tenseur prêt pour l'inférence, de taille [1, 3, 224, 224].
+        Tenseur prêt pour l'inférence, de taille [1, 3, H, W].
     """
-    # Si aucune transform n'est fournie, on utilise la transform par défaut
     if transform is None:
-        transform = get_val_transform()
+        transform = get_val_transform(image_size=image_size)
 
-    # On applique la transform à l'image PIL → tensor [3, 224, 224]
-    img_tensor = transform(image)
-
-    # On ajoute une dimension batch devant : [1, 3, 224, 224]
-    img_tensor = img_tensor.unsqueeze(0)
+    img_tensor = transform(image)        # [3, H, W]
+    img_tensor = img_tensor.unsqueeze(0) # [1, 3, H, W]
 
     return img_tensor
 
 
 # ----------------------------
-# 7) Fonction de prédiction principale
+# 9) Fonction de prédiction principale
 # ----------------------------
 
-def predict_from_tensor(image_tensor: torch.Tensor,
-                        model: torch.nn.Module,
-                        device: torch.device,
-                        threshold: float = 0.5):
+def predict_from_tensor(
+    image_tensor: torch.Tensor,
+    model: torch.nn.Module,
+    device: torch.device,
+    threshold: float = 0.5
+):
     """
     Prédit la classe (fire/no_fire) à partir d'un tenseur déjà prétraité.
 
     Paramètres
     ----------
     image_tensor : torch.Tensor
-        Tenseur d'images de taille [1, 3, 224, 224] (batch de 1 image).
+        Tenseur d'images de taille [1, 3, H, W] (batch de 1 image).
     model : torch.nn.Module
-        Modèle EfficientNet-B0 chargé.
+        Modèle chargé (EfficientNet, Inception, etc.).
     device : torch.device
         Device sur lequel le modèle est (cuda ou cpu).
     threshold : float
@@ -211,37 +338,32 @@ def predict_from_tensor(image_tensor: torch.Tensor,
     fire_prob : float
         Probabilité prédite pour la classe "fire" (entre 0 et 1).
     """
-    # On envoie l'image sur le même device que le modèle
     image_tensor = image_tensor.to(device)
 
-    # On désactive le calcul des gradients pour l'inférence
     with torch.no_grad():
-        # Le modèle renvoie des logits de taille [1, 2]
-        outputs = model(image_tensor)
-
-        # On convertit en probabilités via softmax
-        probs = torch.softmax(outputs, dim=1)
+        outputs = model(image_tensor)           # logits [1, 2]
+        probs = torch.softmax(outputs, dim=1)   # probabilités
 
-        # Probabilité de la classe fire (indice 1)
         fire_prob = probs[0, 1].item()
 
-        # On décide du label en comparant à un seuil
         if fire_prob >= threshold:
-            predicted_idx = 1     # feu
+            predicted_idx = 1  # feu
         else:
-            predicted_idx = 0     # pas de feu
+            predicted_idx = 0  # pas de feu
 
-    # Conversion en label lisible
     predicted_label = IDX_TO_LABEL[predicted_idx]
 
     return predicted_label, fire_prob
 
 
-def predict_from_pil(image: Image.Image,
-                     model: torch.nn.Module,
-                     device: torch.device,
-                     transform=None,
-                     threshold: float = 0.5):
+def predict_from_pil(
+    image: Image.Image,
+    model: torch.nn.Module,
+    device: torch.device,
+    transform=None,
+    threshold: float = 0.5,
+    image_size: int | None = None,
+):
     """
     Prédit la classe à partir d'une image PIL.
 
@@ -250,13 +372,15 @@ def predict_from_pil(image: Image.Image,
     image : PIL.Image.Image
         Image chargée (par exemple via Image.open).
     model : torch.nn.Module
-        Modèle EfficientNet-B0 chargé.
+        Modèle chargé.
     device : torch.device
         Device (cuda ou cpu).
     transform : callable ou None
         Transformations à appliquer à l'image.
     threshold : float
         Seuil sur la probabilité de FEU.
+    image_size : int ou None
+        Taille utilisée si transform est None.
 
     Retour
     ------
@@ -265,22 +389,22 @@ def predict_from_pil(image: Image.Image,
     fire_prob : float
         Probabilité de "fire".
     """
-    # On s'assure que l'image est en mode RGB
     if image.mode != "RGB":
         image = image.convert("RGB")
 
-    # On prétraite l'image (resize, tensor, normalize, batch)
-    image_tensor = preprocess_image(image, transform=transform)
+    image_tensor = preprocess_image(image, transform=transform, image_size=image_size)
 
-    # On délègue la prédiction à predict_from_tensor
     return predict_from_tensor(image_tensor, model, device, threshold=threshold)
 
 
-def predict_from_path(image_path: str,
-                      model: torch.nn.Module,
-                      device: torch.device,
-                      transform=None,
-                      threshold: float = 0.5):
+def predict_from_path(
+    image_path: str,
+    model: torch.nn.Module,
+    device: torch.device,
+    transform=None,
+    threshold: float = 0.5,
+    image_size: int | None = None,
+):
     """
     Prédit la classe à partir d'un chemin vers une image.
 
@@ -289,13 +413,15 @@ def predict_from_path(image_path: str,
     image_path : str
         Chemin vers le fichier image (jpg, png, etc.).
     model : torch.nn.Module
-        Modèle EfficientNet-B0 chargé.
+        Modèle chargé.
     device : torch.device
         Device (cuda ou cpu).
     transform : callable ou None
         Transformations à appliquer.
     threshold : float
         Seuil sur la probabilité de FEU.
+    image_size : int ou None
+        Taille utilisée si transform est None.
 
     Retour
     ------
@@ -304,52 +430,47 @@ def predict_from_path(image_path: str,
     fire_prob : float
         Probabilité de "fire".
     """
-    # On charge l'image depuis le disque via PIL
     image = Image.open(image_path)
-
-    # On délègue la prédiction à la fonction base sur PIL
-    return predict_from_pil(image, model, device, transform=transform, threshold=threshold)
+    return predict_from_pil(
+        image,
+        model=model,
+        device=device,
+        transform=transform,
+        threshold=threshold,
+        image_size=image_size,
+    )
 
 
 # ----------------------------
-# 8) Exemple d'utilisation en script direct
+# 10) Exemple d'utilisation en script direct
 # ----------------------------
 
 if __name__ == "__main__":
     """
-    Ce bloc s'exécute uniquement si on lance le fichier directement :
+    Exemple simple pour tester le module en local :
     python inference.py
-
-    Tu peux le modifier pour faire un petit test rapide en local
-    ou dans un notebook via !python inference.py.
     """
-    import os
-
-    # Chemin vers le fichier de poids (à adapter si besoin)
-    weights_path = "efficientnet_fire.pt"
+    weights_path = "efficientnet_fire.pt"  # à adapter si besoin
 
     if not os.path.exists(weights_path):
         print(f"[ERREUR] Fichier de poids introuvable : {weights_path}")
     else:
-        # 1) On charge le modèle et on détecte le device
         model, device = load_model(weights_path)
         print(f"Modèle chargé sur le device : {device}")
 
-        # 2) On récupère la transform de validation/inférence
+        # On utilise la taille par défaut (224) pour ce test
         transform = get_val_transform()
 
-        # 3) Exemple : prédire sur une image de test (chemin à adapter)
-        test_image_path = "example.jpg"  # ← remplace par une vraie image
+        test_image_path = "example.jpg"  # à adapter si besoin
 
         if not os.path.exists(test_image_path):
             print(f"[INFO] Aucune image test trouvée à : {test_image_path}")
-            print("       Modifie le chemin dans __main__ pour tester une image.")
         else:
             label, prob = predict_from_path(
                 test_image_path,
                 model=model,
                 device=device,
                 transform=transform,
-                threshold=0.5
+                threshold=0.5,
             )
             print(f"Résultat pour {test_image_path} : label={label}, prob_fire={prob:.4f}")