updat file

README.md

@@ -111,24 +111,82 @@ project/
 
 ## 4. Model Architecture
 
-Both models share the **same 4-block VGG-inspired architecture**
-with `GlobalAveragePooling` replacing `Flatten` for ~20× fewer parameters.
+### 4.1 TensorFlow / Keras model
 
 ```
-Input (B, 3, 150, 150)  — RGB, 3 channels
-│
-├─ Block 1: Conv(32)×2 → BN → ReLU → MaxPool(2)          [150→75]
-├─ Block 2: Conv(64)×2 → BN → ReLU → MaxPool(2) → Drop(0.10) [75→37]
-├─ Block 3: Conv(128)×2→ BN → ReLU → MaxPool(2) → Drop(0.15) [37→18]
-├─ Block 4: Conv(256)×2→ BN → ReLU → MaxPool(2) → Drop(0.20) [18→9]
-│
-├─ GlobalAveragePooling2D                                  [→ (B,256)]
-├─ Dense(256) → ReLU → Dropout(0.30)
-└─ Dense(6)   → Softmax / LogSoftmax
-
-Trainable parameters : ~2.1M (PyTorch)  |  ~2.2M (TensorFlow)
+Input: (228, 228, 3)
+
+Block 1: Conv2D(32, 5×5, ReLU) → MaxPool(2×2)         → 224×224×32 → 112×112×32
+Block 2: Conv2D(32, 5×5, ReLU) → MaxPool(2×2)         → 108×108×32 → 54×54×32
+Block 3: Conv2D(32, 3×3, ReLU) → MaxPool(2×2)         → 52×52×32  → 26×26×32
+Block 4: Conv2D(64, 3×3, ReLU) → MaxPool(2×2)         → 24×24×64  → 12×12×64
+Block 5: Conv2D(64, 3×3, ReLU) → MaxPool(2×2)         → 10×10×64  → 5×5×64
+
+Flatten                                                  → 1600
+Dense(1024, ReLU)
+Dropout(0.20)
+Dense(124, ReLU)
+Dropout(0.20)
+Dense(6, Softmax)
+
+Trainable parameters : 1,86M 
+Input size           : 228 × 228 × 3 (RGB)
+```
+
+### 4.1 PyTorch model
+
+```
+Input: (B, 3, 150, 150)
+
+Block 1:
+  Conv2d(3 → 32, 3×3, padding=1) 
+  BatchNorm2d(32)
+  ReLU
+  Conv2d(32 → 32, 3×3, padding=1)
+  BatchNorm2d(32)
+  ReLU
+  MaxPool2d(2)
+
+Block 2:
+  Conv2d(32 → 64, 3×3, padding=1)
+  BatchNorm2d(64)
+  ReLU
+  Conv2d(64 → 64, 3×3, padding=1)
+  BatchNorm2d(64)
+  ReLU
+  MaxPool2d(2)
+  Dropout2d(0.10)
+
+Block 3:
+  Conv2d(64 → 128, 3×3, padding=1)
+  BatchNorm2d(128)
+  ReLU
+  Conv2d(128 → 128, 3×3, padding=1)
+  BatchNorm2d(128)
+  ReLU
+  MaxPool2d(2)
+  Dropout2d(0.15)
+
+Block 4:
+  Conv2d(128 → 256, 3×3, padding=1)
+  BatchNorm2d(256)
+  ReLU
+  Conv2d(256 → 256, 3×3, padding=1)
+  BatchNorm2d(256)
+  ReLU
+  MaxPool2d(2)
+  Dropout2d(0.20)
+
+AdaptiveAvgPool2d(1)     → (B, 256, 1, 1)
+Flatten                  → (B, 256)
+Linear(256 → 256)
+ReLU
+Dropout(0.30)
+Linear(256 → 6)
+
+
+Trainable parameters :  1.24M 
 Input size           : 150 × 150 × 3 (RGB)
-Normalization        : ImageNet mean/std  [0.485,0.456,0.406] / [0.229,0.224,0.225]
 ```
 
 **Training configuration:**
@@ -138,7 +196,7 @@ Normalization        : ImageNet mean/std  [0.485,0.456,0.406] / [0.229,0.224,0.2
 | Optimizer      | Adam          |
 | Learning rate  | 1e-4          |
 | LR scheduler   | ReduceLROnPlateau (factor=0.5, patience=3) |
-| Early stopping | patience=15   |
+| Early stopping | patience=5    |
 | Batch size     | 32            |
 | Max epochs     | 50            |
 | Loss function  | CrossEntropyLoss / SparseCategoricalCrossentropy |
@@ -150,10 +208,6 @@ Normalization        : ImageNet mean/std  [0.485,0.456,0.406] / [0.229,0.224,0.2
 **Python 3.9+** is required.
 
 ```bash
-# Clone / download the project
-git clone <your-repo-url>
-cd project
-
 # Install dependencies
 pip install -r requirements.txt
 ```
@@ -238,7 +292,7 @@ python main.py \
     --mode       eval \
     --model_path parfait_model.pth \
     --data_dir   ../data \
-    --output_dir ./eval_output_dir
+    --output_dir ./outputs
 
 # Evaluate TensorFlow model
 python main.py \
@@ -246,7 +300,7 @@ python main.py \
     --mode       eval \
     --model_path parfait_model.keras \
     --data_dir   ../data \
-    --output_dir ./eval_output_dir
+    --output_dir ./outputs
 
 ```
 
@@ -265,12 +319,11 @@ outputs/
 
 ```bash
 # Start Flask server
-python app.py
-# → http://localhost:5000
-
-# Production (gunicorn)
 gunicorn app:app --bind 0.0.0.0:8000 --workers 1 --timeout 120
 ```
+# Live link
+
+For instance the app is available at: https://huggingface.co/spaces/CyberAl/Image_Classification_Parfait_TOLEFO
 
 **Features:**
 - Model selector: **PyTorch** or **TensorFlow**
@@ -302,7 +355,7 @@ gunicorn app:app --bind 0.0.0.0:8000 --workers 1 --timeout 120
 | street    | 0.90      | 0.91   | 0.90     |
 
 > Note: `buildings` vs `street` is the hardest pair due to visual overlap.
-> Run `--mode eval` on your trained model to get your exact numbers.
+
 
 ---
 
@@ -352,30 +405,3 @@ The seed fixes:
 - DataLoader worker seeds (via `worker_init_fn`)
 
 ---
-
-## 10. Deployment
-
-### PythonAnywhere (recommended, free tier available)
-1. Upload all project files via the **Files** tab
-2. Upload `parfait_model.pth` and `parfait_model.keras`
-3. Open a Bash console → `pip install -r requirements.txt`
-4. **Web** tab → New web app → Manual configuration → Python 3.10
-5. Edit the WSGI file:
-   ```python
-   import sys
-   sys.path.insert(0, '/home/YOUR_USERNAME/project')
-   from app import app as application
-   ```
-6. **Reload** → your app is live at `https://yourusername.pythonanywhere.com`
-
-### Railway / Render
-1. Push the project to a GitHub repository
-2. Connect the repo to Railway or Render
-3. Set start command: `gunicorn app:app --bind 0.0.0.0:$PORT --workers 1 --timeout 120`
-4. Upload model files as part of the repo or via persistent volume
-
-### Environment variables
-| Variable | Default | Description              |
-|---------|---------|--------------------------|
-| `PORT`  | `5000`  | Flask server port        |
-

models/__init__.py

@@ -0,0 +1,2 @@
+from .cnn   import CNN_Torch, build_cnn_tf
+from .train import Trainer

models/cnn.py

@@ -0,0 +1,135 @@
+"""
+models/cnn.py
+CNN pour images RGB 3 canaux — Intel Image Classification (228×228, 6 classes).
+
+RÈGLE DE NORMALISATION :
+    La normalisation est faite UNIQUEMENT dans utils/prep.py (pipeline de données).
+    Les modèles reçoivent des images déjà normalisées — il n'y a PAS de couche
+    Rescaling à l'intérieur des modèles. Cela garantit un comportement identique
+    entre training, evaluation et production (Flask).
+"""
+
+# ── PyTorch ───────────────────────────────────────────────────────────────────
+import torch.nn as nn
+import torch.nn.functional as F
+
+
+class CNN_Torch(nn.Module):
+    """
+    CNN PyTorch 4 blocs pour images RGB (3 canaux, 150×150).
+    Entrée  : (B, 3, 150, 150) — normalisée ImageNet (mean/std)
+    Sortie  : (B, num_classes) — logits bruts (CrossEntropyLoss)
+
+    Architecture :
+        Block 1 : Conv(3→32)×2   + BN + ReLU + MaxPool(2)            150→75
+        Block 2 : Conv(32→64)×2  + BN + ReLU + MaxPool(2) + Drop2d   75→37
+        Block 3 : Conv(64→128)×2 + BN + ReLU + MaxPool(2) + Drop2d   37→18
+        Block 4 : Conv(128→256)×2+ BN + ReLU + MaxPool(2) + Drop2d   18→9
+        GAP     : AdaptiveAvgPool2d(1)                                  →(B,256)
+        Head    : Linear(256→256) + ReLU + Dropout + Linear(256→C)
+    """
+    def __init__(self, num_classes: int = 6):
+        super().__init__()
+
+        self.features = nn.Sequential(
+            # Block 1 — 150×150 → 75×75
+            nn.Conv2d(3, 32, kernel_size=3, padding=1, bias=False),
+            nn.BatchNorm2d(32), nn.ReLU(inplace=True),
+            nn.Conv2d(32, 32, kernel_size=3, padding=1, bias=False),
+            nn.BatchNorm2d(32), nn.ReLU(inplace=True),
+            nn.MaxPool2d(2),
+
+            # Block 2 — 75×75 → 37×37
+            nn.Conv2d(32, 64, kernel_size=3, padding=1, bias=False),
+            nn.BatchNorm2d(64), nn.ReLU(inplace=True),
+            nn.Conv2d(64, 64, kernel_size=3, padding=1, bias=False),
+            nn.BatchNorm2d(64), nn.ReLU(inplace=True),
+            nn.MaxPool2d(2), nn.Dropout2d(0.10),
+
+            # Block 3 — 37×37 → 18×18
+            nn.Conv2d(64, 128, kernel_size=3, padding=1, bias=False),
+            nn.BatchNorm2d(128), nn.ReLU(inplace=True),
+            nn.Conv2d(128, 128, kernel_size=3, padding=1, bias=False),
+            nn.BatchNorm2d(128), nn.ReLU(inplace=True),
+            nn.MaxPool2d(2), nn.Dropout2d(0.15),
+
+            # Block 4 — 18×18 → 9×9
+            nn.Conv2d(128, 256, kernel_size=3, padding=1, bias=False),
+            nn.BatchNorm2d(256), nn.ReLU(inplace=True),
+            nn.Conv2d(256, 256, kernel_size=3, padding=1, bias=False),
+            nn.BatchNorm2d(256), nn.ReLU(inplace=True),
+            nn.MaxPool2d(2), nn.Dropout2d(0.20),
+        )
+
+        # (B,256,9,9) → (B,256,1,1) → (B,256)
+        self.gap = nn.AdaptiveAvgPool2d(1)
+
+        self.classifier = nn.Sequential(
+            nn.Flatten(),
+            nn.Linear(256, 256),
+            nn.ReLU(inplace=True),
+            nn.Dropout(0.30),
+            nn.Linear(256, num_classes),
+        )
+
+    def forward(self, x):
+        return self.classifier(self.gap(self.features(x)))
+
+
+# ── TensorFlow / Keras ────────────────────────────────────────────────────────
+def build_cnn_tf(num_classes: int = 6, input_shape: tuple = (228, 228, 3)):
+    """
+    CNN TF reproduisant l'architecture du notebook de référence hassanraof.
+    Source : https://www.kaggle.com/code/hassanraof/intel-image-classification
+
+    Entrée  : (B, 228, 228, 3) — valeurs [0, 1] normalisées par prep.py
+    Sortie  : (B, num_classes) — softmax
+
+    Architecture (5 blocs conv) :
+        Block 1 : Conv(32, 5×5) → ReLU → MaxPool(2,2)
+        Block 2 : Conv(32, 5×5) → ReLU → MaxPool(2,2)
+        Block 3 : Conv(32, 3×3) → ReLU → MaxPool(2,2)
+        Block 4 : Conv(64, 3×3) → ReLU → MaxPool(2,2)
+        Block 5 : Conv(64, 3×3) → ReLU → MaxPool(2,2)
+        Head    : Flatten → Dense(1024) → Dropout(0.20)
+                           → Dense(124)  → Dropout(0.20)
+                           → Dense(num_classes, softmax)
+
+    ⚠️  PAS de couche Rescaling ici — la normalisation est faite dans prep.py.
+        Ajouter Rescaling ici causerait une double normalisation.
+    """
+    from tensorflow.keras import layers, models
+
+    return models.Sequential([
+        layers.Input(shape=input_shape),
+        # ← PAS de Rescaling ici
+
+        # Block 1
+        layers.Conv2D(32, kernel_size=(5, 5), activation="relu"),
+        layers.MaxPooling2D(2, 2),
+
+        # Block 2
+        layers.Conv2D(32, kernel_size=(5, 5), activation="relu"),
+        layers.MaxPooling2D(2, 2),
+
+        # Block 3
+        layers.Conv2D(32, kernel_size=(3, 3), activation="relu"),
+        layers.MaxPooling2D(2, 2),
+
+        # Block 4
+        layers.Conv2D(64, kernel_size=(3, 3), activation="relu"),
+        layers.MaxPooling2D(2, 2),
+
+        # Block 5
+        layers.Conv2D(64, kernel_size=(3, 3), activation="relu"),
+        layers.MaxPooling2D(2, 2),
+
+        # Head
+        layers.Flatten(),
+        layers.Dense(1024, activation="relu"),
+        layers.Dropout(0.20),
+        layers.Dense(124, activation="relu"),
+        layers.Dropout(0.20),
+        layers.Dense(num_classes, activation="softmax"),
+
+    ], name="CNN_TF_hassanraof")

models/train.py

@@ -0,0 +1,146 @@
+"""
+models/train.py
+Classe Trainer pour PyTorch.
+Fonctionnalités : early stopping, ReduceLROnPlateau,
+                  sauvegarde du meilleur modèle, courbes train/val.
+"""
+
+import torch
+import torch.nn as nn
+from tqdm import tqdm
+import matplotlib.pyplot as plt
+
+
+class Trainer:
+    def __init__(self, model, train_dataloader, test_dataloader,
+                 lr=1e-3, epochs=30, device="cpu", patience=5):
+        self.model            = model
+        self.train_dataloader = train_dataloader
+        self.test_dataloader  = test_dataloader
+        self.epochs           = epochs
+        self.patience         = patience
+        self.device           = device
+        self.criterion        = nn.CrossEntropyLoss()
+        self.optimizer        = torch.optim.Adam(model.parameters(), lr=lr)
+        self.scheduler        = torch.optim.lr_scheduler.ReduceLROnPlateau(
+                                    self.optimizer, mode="min",
+                                    factor=0.5, patience=3)
+
+    # ── Entraînement complet ───────────────────────────────────────────────
+    def train(self, save_path=None, plot=False):
+        self.train_loss, self.train_acc = [], []
+        self.val_loss,   self.val_acc   = [], []
+
+        best_val_loss     = float("inf")
+        epochs_no_improve = 0
+        best_state        = None
+
+        for epoch in range(self.epochs):
+            tr_loss, tr_acc = self._train_one_epoch(epoch)
+            v_loss,  v_acc  = self._validate()
+
+            self.train_loss.append(tr_loss)
+            self.train_acc.append(tr_acc)
+            self.val_loss.append(v_loss)
+            self.val_acc.append(v_acc)
+
+            self.scheduler.step(v_loss)
+            lr = self.optimizer.param_groups[0]["lr"]
+
+            print(f"Epoch {epoch+1:02d}/{self.epochs} "
+                  f"| Train  loss={tr_loss:.4f}  acc={tr_acc:.2f}% "
+                  f"| Val    loss={v_loss:.4f}  acc={v_acc:.2f}% "
+                  f"| LR={lr:.2e}")
+
+            # Early stopping
+            if v_loss < best_val_loss:
+                best_val_loss     = v_loss
+                epochs_no_improve = 0
+                best_state = {k: v.clone() for k, v in self.model.state_dict().items()}
+                if save_path:
+                    torch.save(best_state, save_path)
+                    print(f"  ✓ Best model saved  (val_loss={v_loss:.4f})")
+            else:
+                epochs_no_improve += 1
+                print(f"  ⚠ No improvement {epochs_no_improve}/{self.patience}")
+                if epochs_no_improve >= self.patience:
+                    print(f"\n⛔ Early stopping at epoch {epoch+1}")
+                    break
+
+        if best_state:
+            self.model.load_state_dict(best_state)
+        if plot:
+            self.plot_history()
+
+    # ── Une epoch de train ─────────────────────────────────────────────────
+    def _train_one_epoch(self, epoch):
+        self.model.train()
+        total_loss, total_correct, total_samples = 0, 0, 0
+        pbar = tqdm(self.train_dataloader,
+                    desc=f"Epoch {epoch+1}/{self.epochs} [train]", leave=False)
+
+        for imgs, labels in pbar:
+            imgs, labels = imgs.to(self.device), labels.to(self.device)
+            self.optimizer.zero_grad()
+            out  = self.model(imgs)
+            loss = self.criterion(out, labels)
+            loss.backward()
+            self.optimizer.step()
+
+            _, preds       = out.max(1)
+            correct        = (preds == labels).sum().item()
+            total          = labels.size(0)
+            total_correct += correct
+            total_samples += total
+            total_loss    += loss.item()
+
+            pbar.set_postfix({
+                "Batch Acc": f"{100.*correct/total:.1f}%",
+                "Avg Acc":   f"{100.*total_correct/total_samples:.1f}%",
+                "Loss":      f"{total_loss/total_samples:.4f}",
+            })
+
+        return total_loss / total_samples, 100. * total_correct / total_samples
+
+    # ── Validation ────────────────────────────────────────────────────────
+    @torch.no_grad()
+    def _validate(self):
+        self.model.eval()
+        total_loss, total_correct, total_samples = 0, 0, 0
+        for imgs, labels in self.test_dataloader:
+            imgs, labels  = imgs.to(self.device), labels.to(self.device)
+            out           = self.model(imgs)
+            loss          = self.criterion(out, labels)
+            _, preds      = out.max(1)
+            total_correct += (preds == labels).sum().item()
+            total_samples += labels.size(0)
+            total_loss    += loss.item() * labels.size(0)
+        return total_loss / total_samples, 100. * total_correct / total_samples
+
+    # ── Évaluation finale (public) ────────────────────────────────────────
+    @torch.no_grad()
+    def evaluate(self):
+        loss, acc = self._validate()
+        print(f"\nTest Accuracy : {acc:.2f}%  |  Test Loss : {loss:.4f}")
+        return acc, loss
+
+    # ── Courbes ───────────────────────────────────────────────────────────
+    def plot_history(self, save_path="/kaggle/working/history_pytorch.png"):
+        epochs = range(1, len(self.train_loss) + 1)
+        fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(14, 5))
+
+        ax1.plot(epochs, self.train_loss, label="Train", color="tab:blue")
+        ax1.plot(epochs, self.val_loss,   label="Val",   color="tab:orange")
+        ax1.set_title("Loss"); ax1.set_xlabel("Epoch")
+        ax1.legend(); ax1.grid(alpha=.3)
+
+        ax2.plot(epochs, self.train_acc, label="Train", color="tab:blue")
+        ax2.plot(epochs, self.val_acc,   label="Val",   color="tab:orange")
+        ax2.set_title("Accuracy (%)"); ax2.set_xlabel("Epoch")
+        ax2.legend(); ax2.grid(alpha=.3)
+
+        fig.suptitle("Training History — PyTorch", fontsize=13)
+        fig.tight_layout()
+        plt.savefig(save_path, dpi=120)
+        plt.show()
+        print(f"✓ Courbes sauvegardées → {save_path}")

utils/__init__.py

@@ -0,0 +1,7 @@
+from .prep import (
+    get_pytorch_transforms,
+    get_pytorch_loaders,
+    get_tf_datasets,
+    preprocess_image_pytorch,
+    preprocess_image_tf,
+)

utils/prep.py

@@ -0,0 +1,137 @@
+
+# ══════════════════════════════════════════════════════════════════════════════
+# PYTORCH — Transforms & DataLoaders
+# ══════════════════════════════════════════════════════════════════════════════
+def get_pytorch_transforms(img_size: int = 150):
+    """
+    Retourne (train_transform, val_transform).
+    Augmentation scène-aware pour le dataset Intel (6 classes naturelles RGB).
+    """
+    from torchvision import transforms
+
+    # Statistiques ImageNet — optimal pour images naturelles RGB 3 canaux
+    MEAN = [0.485, 0.456, 0.406]
+    STD  = [0.229, 0.224, 0.225]
+
+    train_transform = transforms.Compose([
+        transforms.Resize((img_size, img_size)),
+        transforms.RandomHorizontalFlip(p=0.5),
+        transforms.RandomVerticalFlip(p=0.1),
+        transforms.RandomRotation(degrees=40),
+        transforms.ColorJitter(
+            brightness=0.3, contrast=0.2, saturation=0.1, hue=0.05
+        ),
+        transforms.RandomGrayscale(p=0.05),
+        transforms.ToTensor(),
+        transforms.Normalize(MEAN, STD),      # ← normalisation ici, pas dans le modèle
+        transforms.RandomErasing(p=0.15, scale=(0.02, 0.15)),
+    ])
+
+    val_transform = transforms.Compose([
+        transforms.Resize((img_size, img_size)),
+        transforms.ToTensor(),
+        transforms.Normalize(MEAN, STD),      # ← même normalisation en val/test
+    ])
+
+    return train_transform, val_transform
+
+
+def get_pytorch_loaders(
+    train_dir: str,
+    test_dir:  str,
+    img_size:  int = 150,
+    batch_size: int = 64,
+):
+    from torch.utils.data import DataLoader
+    from torchvision import datasets
+
+    train_tf, val_tf = get_pytorch_transforms(img_size)
+
+    train_loader = DataLoader(
+        datasets.ImageFolder(train_dir, transform=train_tf),
+        batch_size=batch_size, shuffle=True,
+        num_workers=2, pin_memory=True,
+    )
+    test_loader = DataLoader(
+        datasets.ImageFolder(test_dir, transform=val_tf),
+        batch_size=batch_size, shuffle=False,
+        num_workers=2, pin_memory=True,
+    )
+    return train_loader, test_loader
+
+
+# ══════════════════════════════════════════════════════════════════════════════
+# TENSORFLOW — Dataset pipeline
+# ══════════════════════════════════════════════════════════════════════════════
+def get_tf_datasets(
+    train_dir: str,
+    test_dir: str,
+    img_size: int = 228,
+    batch_size: int = 64,
+):
+    import tensorflow as tf
+
+    # Same preprocessing as in the notebook
+    norm_layer = tf.keras.layers.Rescaling(1.0 / 255.0)
+
+    # ── Raw loading ──────────────────────────────────────────────────────────
+    train_ds = tf.keras.utils.image_dataset_from_directory(
+        train_dir,
+        seed=123,
+        image_size=(img_size, img_size),
+        batch_size=batch_size,
+        shuffle=True,
+        label_mode="int",
+    )
+
+    test_ds = tf.keras.utils.image_dataset_from_directory(
+        test_dir,
+        seed=123,
+        image_size=(img_size, img_size),
+        batch_size=batch_size,
+        shuffle=False,
+        label_mode="int",
+    )
+
+    # ── Normalization only ───────────────────────────────────────────────────
+    train_ds = train_ds.map(
+        lambda x, y: (norm_layer(x), y),
+        num_parallel_calls=tf.data.AUTOTUNE
+    )
+
+    test_ds = test_ds.map(
+        lambda x, y: (norm_layer(x), y),
+        num_parallel_calls=tf.data.AUTOTUNE
+    )
+
+    # ── Performance ──────────────────────────────────────────────────────────
+    train_ds = train_ds.prefetch(tf.data.AUTOTUNE)
+    test_ds = test_ds.prefetch(tf.data.AUTOTUNE)
+
+    return train_ds, test_ds
+
+# ══════════════════════════════════════════════════════════════════════════════
+# INFÉRENCE — Preprocessing image unique (Flask / production)
+# ══════════════════════════════════════════════════════════════════════════════
+def preprocess_image_pytorch(pil_img, img_size: int = 150):
+    """Prépare une image PIL pour l'inférence PyTorch. Retourne (1,3,H,W)."""
+    import torch
+    from torchvision import transforms
+
+    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]),
+    ])
+    return tf(pil_img).unsqueeze(0)
+
+
+def preprocess_image_tf(pil_img, img_size: int = 150):
+    """
+    Prépare une image PIL pour l'inférence TensorFlow. Retourne (1,H,W,3).
+    Normalisation identique au pipeline val/test : ÷255 → [0,1].
+    """
+    import numpy as np
+    arr = np.array(pil_img.resize((img_size, img_size)), dtype=np.float32)
+    arr = arr / 255.0              # ← même normalisation que normalize_only()
+    return np.expand_dims(arr, 0)  # (1, H, W, 3)