to push to hf

.gitattributes

@@ -0,0 +1,56 @@
+
+* text=auto
+
+*.py      text eol=lf
+*.ipynb   -diff
+*.sh      text eol=lf
+Dockerfile text eol=lf
+*.yml     text eol=lf
+*.yaml    text eol=lf
+
+*.ps1     text eol=crlf
+*.bat     text eol=crlf
+
+*.csv     text eol=lf working-tree-encoding=UTF-8
+*.tsv     text eol=lf working-tree-encoding=UTF-8
+
+*.png     binary
+*.jpg     binary
+*.jpeg    binary
+*.pdf     binary
+
+*.7z filter=lfs diff=lfs merge=lfs -text
+*.arrow filter=lfs diff=lfs merge=lfs -text
+*.bin filter=lfs diff=lfs merge=lfs -text
+*.bz2 filter=lfs diff=lfs merge=lfs -text
+*.ckpt filter=lfs diff=lfs merge=lfs -text
+*.ftz filter=lfs diff=lfs merge=lfs -text
+*.gz filter=lfs diff=lfs merge=lfs -text
+*.h5 filter=lfs diff=lfs merge=lfs -text
+*.joblib filter=lfs diff=lfs merge=lfs -text
+*.lfs.* filter=lfs diff=lfs merge=lfs -text
+*.mlmodel filter=lfs diff=lfs merge=lfs -text
+*.model filter=lfs diff=lfs merge=lfs -text
+*.msgpack filter=lfs diff=lfs merge=lfs -text
+*.npy filter=lfs diff=lfs merge=lfs -text
+*.npz filter=lfs diff=lfs merge=lfs -text
+*.onnx filter=lfs diff=lfs merge=lfs -text
+*.ot filter=lfs diff=lfs merge=lfs -text
+*.parquet filter=lfs diff=lfs merge=lfs -text
+*.pb filter=lfs diff=lfs merge=lfs -text
+*.pickle filter=lfs diff=lfs merge=lfs -text
+*.pkl filter=lfs diff=lfs merge=lfs -text
+*.pt filter=lfs diff=lfs merge=lfs -text
+*.pth filter=lfs diff=lfs merge=lfs -text
+*.rar filter=lfs diff=lfs merge=lfs -text
+*.safetensors filter=lfs diff=lfs merge=lfs -text
+saved_model/**/* filter=lfs diff=lfs merge=lfs -text
+*.tar.* filter=lfs diff=lfs merge=lfs -text
+*.tar filter=lfs diff=lfs merge=lfs -text
+*.tflite filter=lfs diff=lfs merge=lfs -text
+*.tgz filter=lfs diff=lfs merge=lfs -text
+*.wasm filter=lfs diff=lfs merge=lfs -text
+*.xz filter=lfs diff=lfs merge=lfs -text
+*.zip filter=lfs diff=lfs merge=lfs -text
+*.zst filter=lfs diff=lfs merge=lfs -text
+*tfevents* filter=lfs diff=lfs merge=lfs -text

.gitignore

@@ -0,0 +1,11 @@
+# Environnement virtuel
+.venv/
+
+# Variables secrètes
+.env
+
+# Fichiers générés automatiquement
+__pycache__/
+*.pyc
+*.pptx
+.dockerignore

Dockerfile

@@ -0,0 +1,18 @@
+FROM python:3.13-slim
+
+WORKDIR /app
+
+ENV PYTHONDONTWRITEBYTECODE=1
+ENV PYTHONUNBUFFERED=1
+
+RUN apt-get update && apt-get install -y --no-install-recommends \
+    && rm -rf /var/lib/apt/lists/*
+
+COPY requirements.txt ./requirements.txt
+RUN pip install --no-cache-dir -r requirements.txt
+
+COPY . .
+
+EXPOSE 7860
+
+CMD ["streamlit", "run", "app.py", "--server.port=7860", "--server.address=0.0.0.0"]

README.md

@@ -1,119 +1,12 @@
-# Fire_detection
-
-## Datasets et publications 
-Datasets :     
-https://docs.google.com/spreadsheets/d/1mSaPf1uFKBiJR4ECJ9Qw8Ne89AfqBFdzOHYIDpTkkfE/edit?gid=0#gid=0    
-Publications :    
-https://docs.google.com/document/d/1pBWHai2zxGqSHPpdVhFFJNARVEa5PGTwTP2JDLOGoOk/edit?usp=sharing     
-
-# Idées / Pistes 
-
-un site génial : https://www.alertwildfire.org/?viewMode=Grid
-
-Un réseau de caméra de sécrité anti incendies qui couvre tout l'Ouest des Etats_Unis     
-Ils n'ont pas d'ia connectés aux caméras pour détecter automatiquement les incendies   
-idée de projet : on peut concevoir notre ia pour qu'elle puisse surveiller ces videos en temps réel et lancer des alertes     
-
-# feuille de route pour y voir plus clair 
-
-Problématique : Détection précoce des incendies 
-  - afin d'avoir le plus de chances possible
-
-**Etapes** :     
-
-I. **Datasets** et **publications** : (Mercredi et jeudi)
-- début de feu
-- feux déjà bien présent
-- avec variable cible
-- Choix du dataset : OK : https://www.kaggle.com/datasets/elmadafri/the-wildfire-dataset
-  - Dataset vidéos surveillance découpées en images. Vue de loin, surtout fumée. 
--  Publications : voir ce que les autres ont fait
-  - lien google doc explications publications
- https://docs.google.com/document/d/1pBWHai2zxGqSHPpdVhFFJNARVEa5PGTwTP2JDLOGoOk/edit?usp=sharing 
-
-II. **Choix** : (Jeudi)
-- finir publications 
-- de la démarche à suivre / Variable retenus
-- cleaner le dataset 
-
-III. **Baseline** : (Vendredi) 
-- cleanner le dataset 
-- essayer d'entrainer un modèle sur ces données
-
-# Structure deep learning - d'après les publications : 
-https://www.mdpi.com/1424-8220/20/22/6442#Early_Fire_Detection_Systems
-
-### Préparation des images  
-* redimensionner les images
-* Augmenter les données (rotation, miroir, luminosité ...)
-* split de la publication : Train test Val : 60-20-20 ou 70-15-15
-
-### CNN avancé (type VGG, LeNet, ou GoogleNet)
-
-* On charge un modèle existant (pré-entraîné) puis on ajuste les couches de sortie (fine-tuning) :
-* Exemple pour VGG16 :      
-from tensorflow.keras.applications import VGG16      
-base_model = VGG16(weights='imagenet', include_top=False, input_shape=(224,224,3))      
-> On ajoute une nouvelle tête de classification adaptée à la détection feu/non-feu
-
-### Combiner images fixes et mouvement 
-* images statiques
-* mouvement par "optical flow" : déplacement de pixel entre deux images fixes
-  *  (différentes méthodes : " Lucas-kanade", "Pyramdal Lucas-Kanade", "Farneback"
-  * Ca donne une carte qui indique la vitesse et le déplacement des pixels
-  * sinon j'amagine que c'est quasi impossible de distinguer fumée / nuage
-* concaténer les deux
-  * il faut qu'ils soient normalisés - échelle comparable -
-  * et redimensionner : trop de dimension > surapprentissage / nécessite plus de données (réduction dimensionalité potentiel)
-* ça donne un gros vecteur final ui combine les deux ancien
-  * si problème de dimension avant : problème de dimension entre ces vecteurs
-  * la couche de sortie fournie la probabilité feu / non feu
-
-### Entraîner 2 CNN, de façon hiérarchique 
-* 1er : Dit si feu ou non
-* 2e : Sert à localiser le feu dans l'image 
-* superpixels : grand groupe pixel avec ses voisins
-
-### Détection temps-réel 
-* Pour qu'il puisse détecter en temps réel il faut que ce soit léger
-  * MobileNet, SqueezeNet : architecture compressé
-  * cadence d'image (fps) limité, peut être directement embarqué dans caméra
-* système adaptatif : si suspicion : activer caméra HD sinon flu basse résolution 
-
-### Segmentation par réseaux spécialisés 
-* un modèle type "FCN" ou Deeplabv3" : pas tout à fait compris
-* comprends rien mais pour ça il va d'aord détecter les régions par Faster R-CNN
-* ensuite il passe ces régions dans un LSTM pour "validation temporelle" (il prend tant de frames autour pour voir le mouvement et l'évoluion de la fumée)
-
-### Amélioration 
-* training avec data augmentation
-* validation croisée : diviser en k fold pour évaluer robestesse
-
-
-
-# Problèmatiques : 
-influençant le choix du modèle à pré-entrainer 
-
-## Problème principal : les caméras 
-
-### Variabilité extrême :
-- Caméra de volontaires, publique ou privé
-- rafraichissement inégale : parfois 1 à plusieurs minutes voir plusieurs heures
-- Variabilité extrême : lumière, météo, angle
-
-### Qualité trés basse 
-- caméra trés distante > fumée petite > l'IA doit être sensible au faibles signaux
-- Donc architecture puissante pour capter les petits indices
-- DOnc faux positive élevé > Couche de de validation ou score de confiance (ou les deux)
-
-### Donc le pipeline : 
-- Le pipeline devra récupérer automatiquement les images du site : traitement de batch en temps réel
-- pour chaque caméra : il faut enregistrer : Quel distance / angle / paysage et créer un base de donnée de référencement
-- on peut envisager un modèle spécifique pour chaque type 
-
-Donc, le mieux est de contacter ces charmants personnages à l'origine de ce site, ci-nommés : 
-- Dr. Bill Savran, NSL Lab Manager, University of Nevada Reno : wsavran@unr.edu
-- Dr. Christie Rowe, NSL Director, University of Nevada Reno, : rowec@unr.edu    
-On découvre que ce site a été mis en place par l'Université du Nevada, on leur fait un coucou
-
-
+---
+title: Fire Detection
+emoji: 💻
+colorFrom: green
+colorTo: indigo
+sdk: gradio
+sdk_version: 5.49.1
+app_file: app.py
+pinned: false
+license: apache-2.0
+short_description: Fire Detection System using Streamlit
+---

app.py

@@ -0,0 +1,131 @@
+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
+)
+
+# -----------------------------------------------------------
+# 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
+)
+
+# -----------------------------------------------------------
+# Chargement du modèle (une seule fois)
+# -----------------------------------------------------------
+@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
+
+model, device, transform = load_app_model()
+
+# -----------------------------------------------------------
+# Sidebar : infos et paramètres
+# -----------------------------------------------------------
+st.sidebar.title("⚙️ Paramètres")
+st.sidebar.markdown(
+    """
+Ce dashboard utilise un modèle EfficientNet-B0,  
+entraîné à prédire **FIRE / NO FIRE** sur des images.
+
+- Classe 0 : **no_fire**
+- Classe 1 : **fire**
+    """
+)
+
+threshold = st.sidebar.slider(
+    "Seuil de détection du feu (probabilité minimale pour 'fire')",
+    min_value=0.1,
+    max_value=0.9,
+    value=0.5,
+    step=0.05,
+)
+
+st.sidebar.markdown(f"Seuil actuel : **{threshold:.2f}**")
+
+# -----------------------------------------------------------
+# 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.
+
+_Charger une image pour obtenir une prédiction._
+    """
+)
+
+# -----------------------------------------------------------
+# Zone d'upload d'image (texte personnalisé ajouté)
+# -----------------------------------------------------------
+uploaded_file = st.file_uploader(
+    "📂 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",                                       
+    accept_multiple_files=False
+)
+
+# -----------------------------------------------------------
+# Si aucune image n'est encore uploadée
+# -----------------------------------------------------------
+if uploaded_file is None:
+    st.info("👉 En attente d'une image. Charger une photo de forêt, flamme, paysage, etc.")
+else:
+    # -------------------------------------------------------
+    # Afficher l'image uploadée
+    # -------------------------------------------------------
+    image = Image.open(uploaded_file)
+    st.image(image, caption="Image chargée", use_container_width=True)
+
+    # -------------------------------------------------------
+    # Prédiction
+    # -------------------------------------------------------
+    with st.spinner("Analyse de l'image en cours..."):
+        label, prob = predict_from_pil(
+            image=image,
+            model=model,
+            device=device,
+            transform=transform,
+            threshold=threshold
+        )
+
+    # -------------------------------------------------------
+    # Affichage du résultat avec couleur
+    # -------------------------------------------------------
+    prob_percent = prob * 100
+
+    if label == "fire":
+        st.error(
+            f"🔥 **FEU DÉTECTÉ**  \nProbabilité de feu : **{prob_percent:.2f}%**  \n(Seuil utilisé : {threshold:.2f})"
+        )
+    else:
+        st.success(
+            f"✅ **PAS DE FEU DÉTECTÉ**  \nProbabilité de feu : **{prob_percent:.2f}%**  \n(Seuil utilisé : {threshold:.2f})"
+        )
+
+    # -------------------------------------------------------
+    # Détails supplémentaires (dans un expander)
+    # -------------------------------------------------------
+    with st.expander("🔍 Détails techniques (optionnel)"):
+        st.markdown(
+            f"""
+- Label retourné : **{label}**
+- Probabilité brute de la classe *fire* : **{prob:.4f}**
+- Seuil de décision : **{threshold:.2f}**
+
+Si `prob_fire >= seuil` → prédiction = *fire*,  
+sinon → *no_fire*.
+            """
+        )

efficientnet_fire.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:1618ff899b64649c5752a546f57d2a05ad8d85e0cd385ffd07b7732d49f5fbda
+size 16338683

inference.py

@@ -0,0 +1,355 @@
+"""
+inference.py
+------------
+Module d'inférence pour le modèle EfficientNet-B0 entraîné
+sur la classification binaire : FIRE (1) / NO_FIRE (0).
+
+Compatible :
+- Google Colab
+- Exécution locale (Python)
+- Lightning AI
+- HuggingFace Spaces / Streamlit
+
+Usage typique :
+---------------
+from inference import load_model, get_val_transform, predict_from_path
+
+model, device = load_model("efficientnet_fire.pt")
+transform = get_val_transform()
+
+label, prob = predict_from_path("mon_image.jpg", model, device, transform)
+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
+
+
+# ----------------------------
+# 2) Constantes globales
+# ----------------------------
+
+# Taille d'entrée du modèle EfficientNet-B0
+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
+IMAGENET_STD = [0.229, 0.224, 0.225]    # écart-type des canaux R, G, B
+
+# Mapping des classes numériques vers des labels lisibles
+IDX_TO_LABEL = {
+    0: "no_fire",   # classe 0 → pas de feu
+    1: "fire"       # classe 1 → feu
+}
+
+
+# ----------------------------
+# 3) Utilitaires device
+# ----------------------------
+
+def get_device():
+    """
+    Retourne le device à utiliser pour l'inférence :
+    - '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
+    else:
+        return torch.device("cpu")    # sinon le CPU
+
+
+# ----------------------------
+# 4) Chargement du modèle
+# ----------------------------
+
+def build_model(num_classes=2):
+    """
+    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.
+    """
+    # 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)
+
+    # On récupère le nombre de features en entrée de la dernière couche
+    in_features = model.classifier.in_features
+
+    # On remplace la dernière couche par une couche linéaire avec num_classes sorties
+    model.classifier = nn.Linear(in_features, num_classes)
+
+    return model
+
+
+def load_model(weights_path: str, map_location=None):
+    """
+    Charge le modèle EfficientNet-B0 avec les poids entraînés.
+
+    Paramètres
+    ----------
+    weights_path : str
+        Chemin vers le fichier .pt contenant les poids (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).
+
+    Retour
+    ------
+    model : torch.nn.Module
+        Le modèle prêt pour l'inférence.
+    device : torch.device
+        Le device utilisé (cuda ou cpu).
+    """
+    # On détecte le device si non fourni
+    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)
+
+    # On charge le dictionnaire de poids sauvegardés (state_dict)
+    state_dict = torch.load(weights_path, map_location=device)
+
+    # On applique les poids au modèle
+    model.load_state_dict(state_dict)
+
+    # On envoie le modèle sur le bon device (GPU ou CPU)
+    model = model.to(device)
+
+    # On passe le modèle en mode évaluation (important pour dropout, batchnorm, etc.)
+    model.eval()
+
+    return model, device
+
+
+# ----------------------------
+# 5) Transforms pour l'inférence
+# ----------------------------
+
+def get_val_transform():
+    """
+    Renvoie les transformations à appliquer aux images pour l'inférence.
+    Ce sont les mêmes que pour la validation :
+    - Resize 224x224
+    - ToTensor
+    - Normalize (ImageNet)
+    """
+    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
+    ])
+    return transform
+
+
+# ----------------------------
+# 6) Prétraitement d'une image
+# ----------------------------
+
+def preprocess_image(image: Image.Image, transform=None):
+    """
+    Applique les transforms à une image PIL et ajoute une dimension batch.
+
+    Paramètres
+    ----------
+    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()).
+
+    Retour
+    ------
+    image_tensor : torch.Tensor
+        Tenseur prêt pour l'inférence, de taille [1, 3, 224, 224].
+    """
+    # Si aucune transform n'est fournie, on utilise la transform par défaut
+    if transform is None:
+        transform = get_val_transform()
+
+    # 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)
+
+    return img_tensor
+
+
+# ----------------------------
+# 7) Fonction de prédiction principale
+# ----------------------------
+
+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).
+    model : torch.nn.Module
+        Modèle EfficientNet-B0 chargé.
+    device : torch.device
+        Device sur lequel le modèle est (cuda ou cpu).
+    threshold : float
+        Seuil sur la probabilité de FEU pour décider entre no_fire / fire.
+
+    Retour
+    ------
+    predicted_label : str
+        "fire" ou "no_fire".
+    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)
+
+        # 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
+        else:
+            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):
+    """
+    Prédit la classe à partir d'une image PIL.
+
+    Paramètres
+    ----------
+    image : PIL.Image.Image
+        Image chargée (par exemple via Image.open).
+    model : torch.nn.Module
+        Modèle EfficientNet-B0 chargé.
+    device : torch.device
+        Device (cuda ou cpu).
+    transform : callable ou None
+        Transformations à appliquer à l'image.
+    threshold : float
+        Seuil sur la probabilité de FEU.
+
+    Retour
+    ------
+    predicted_label : str
+        "fire" ou "no_fire".
+    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)
+
+    # 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):
+    """
+    Prédit la classe à partir d'un chemin vers une image.
+
+    Paramètres
+    ----------
+    image_path : str
+        Chemin vers le fichier image (jpg, png, etc.).
+    model : torch.nn.Module
+        Modèle EfficientNet-B0 chargé.
+    device : torch.device
+        Device (cuda ou cpu).
+    transform : callable ou None
+        Transformations à appliquer.
+    threshold : float
+        Seuil sur la probabilité de FEU.
+
+    Retour
+    ------
+    predicted_label : str
+        "fire" ou "no_fire".
+    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)
+
+
+# ----------------------------
+# 8) Exemple d'utilisation en script direct
+# ----------------------------
+
+if __name__ == "__main__":
+    """
+    Ce bloc s'exécute uniquement si on lance le fichier directement :
+    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"
+
+    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
+        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
+
+        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
+            )
+            print(f"Résultat pour {test_image_path} : label={label}, prob_fire={prob:.4f}")