Remove token

.gitattributes

@@ -0,0 +1,2 @@
+*.pth filter=lfs diff=lfs merge=lfs -text
+*.keras filter=lfs diff=lfs merge=lfs -text

Dockerfile

@@ -0,0 +1,12 @@
+FROM python:3.11-slim
+
+WORKDIR /app
+
+COPY requirements.txt .
+RUN pip install --no-cache-dir -r requirements.txt
+
+COPY . .
+
+EXPOSE 7860
+
+CMD ["python", "app.py"]

app.py

@@ -0,0 +1,117 @@
+import sys, os
+
+BASE_DIR = os.path.dirname(os.path.abspath(__file__))
+sys.path.insert(0, BASE_DIR)
+
+import io
+import numpy as np
+from PIL import Image
+from flask import Flask, request, jsonify, render_template
+
+import torch
+from models.cnn import IntelCNN_PyTorch
+
+# ── Config ────────────────────
+
+CLASSES         = ["buildings", "forest", "glacier", "mountain", "sea", "street"]
+IMG_SIZE        = 150
+PYTORCH_WEIGHTS = os.path.join(BASE_DIR, "geraud_model.pth")
+KERAS_WEIGHTS   = os.path.join(BASE_DIR, "geraud_model.keras")
+DEVICE          = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+
+app = Flask(__name__)
+
+# ── Load PyTorch model ────────────────────────────────────────
+pytorch_model = None
+if os.path.exists(PYTORCH_WEIGHTS):
+    pytorch_model = IntelCNN_PyTorch(num_classes=6).to(DEVICE)
+    pytorch_model.load_state_dict(torch.load(PYTORCH_WEIGHTS, map_location=DEVICE))
+    pytorch_model.eval()
+    print(f"✅ PyTorch model loaded ({DEVICE})")
+else:
+    print(f"⚠️  PyTorch weights not found: {PYTORCH_WEIGHTS}")
+
+# ── Load Keras model ──────────────────────────────────────────
+keras_model = None
+if os.path.exists(KERAS_WEIGHTS):
+    import tensorflow as tf
+    keras_model = tf.keras.models.load_model(KERAS_WEIGHTS)
+    print("✅ Keras model loaded")
+else:
+    print(f"⚠️  Keras weights not found: {KERAS_WEIGHTS}")
+
+# ── Preprocessing ─────────────────────────────────────────────
+import torchvision.transforms as T
+
+_torch_tf = T.Compose([
+    T.Resize((IMG_SIZE, IMG_SIZE)),
+    T.ToTensor(),
+    T.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225]),
+])
+
+def preprocess_torch(pil_img):
+    return _torch_tf(pil_img.convert("RGB")).unsqueeze(0).to(DEVICE)
+
+def preprocess_keras(pil_img):
+    img = pil_img.convert("RGB").resize((IMG_SIZE, IMG_SIZE))
+    arr = np.array(img, dtype=np.float32) / 255.0
+    return np.expand_dims(arr, 0)
+
+# ── 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": "No image uploaded"}), 400
+
+    backend = request.form.get("backend", "PyTorch")
+    file    = request.files["image"]
+    img     = Image.open(io.BytesIO(file.read()))
+
+    try:
+        if backend == "PyTorch":
+            if pytorch_model is None:
+                return jsonify({"error": "PyTorch model not loaded"}), 500
+            with torch.no_grad():
+                logits = pytorch_model(preprocess_torch(img))
+                probs  = torch.softmax(logits, dim=1).cpu().numpy()[0]
+
+        elif backend == "Keras":
+            if keras_model is None:
+                return jsonify({"error": "Keras model not loaded"}), 500
+            probs = keras_model.predict(preprocess_keras(img), verbose=0)[0]
+
+        else:
+            return jsonify({"error": "Unknown backend"}), 400
+
+        results = [
+            {"class": cls, "confidence": round(float(p) * 100, 2)}
+            for cls, p in zip(CLASSES, probs)
+        ]
+        results.sort(key=lambda x: x["confidence"], reverse=True)
+
+        return jsonify({
+            "prediction": results[0]["class"],
+            "confidence": results[0]["confidence"],
+            "all":        results,
+            "backend":    backend,
+        })
+
+    except Exception as e:
+        return jsonify({"error": str(e)}), 500
+
+@app.route("/models", methods=["GET"])
+def available_models():
+    return jsonify({
+        "PyTorch": pytorch_model is not None,
+        "Keras":   keras_model   is not None,
+    })
+
+# ── Run ───────────────────────────────────────────────────────
+if __name__ == "__main__":
+    # Hugging Face Spaces impose le port 7860
+    port = int(os.environ.get("PORT", 7860))
+    app.run(host="0.0.0.0", port=port, debug=False)

geraud_model.keras

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

geraud_model.pth

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:04d194547090947689a46833c0ab9cf9f6d93c99c558f6eb29fe5f03b11e944c
+size 2618509

main.py

@@ -0,0 +1,142 @@
+import torch
+import argparse
+from utils import prep
+from models.cnn import IntelCNN_PyTorch
+from models.train import Trainer
+
+
+def parse_args():
+    parser = argparse.ArgumentParser(description="Entraînement d'un modèle CNN")
+    parser.add_argument('--framework', type=str, choices=['pytorch', 'tensorflow'],
+                        default='pytorch', help="Framework à utiliser (default: pytorch)")
+    parser.add_argument('--epochs', type=int, default=20,
+                        help="Nombre d'époques d'entraînement")
+    parser.add_argument('--lr',  type=float, default=0.001,  help="Learning rate")
+    parser.add_argument('--wd',  type=float, default=0.0001, help="Weight decay")
+    parser.add_argument('--mode', type=str, choices=['train', 'eval'], default='train',
+                        help="Mode : 'train' ou 'eval' (default: train)")
+    parser.add_argument('--cuda', action='store_true', help="Utiliser le GPU si disponible")
+    return parser.parse_args()
+
+
+def main():
+    args = parse_args()
+    if args.framework == 'tensorflow':
+        run_tensorflow(args)
+    else:
+        run_pytorch(args)
+
+
+def run_pytorch(args):
+    device = torch.device("cuda" if args.cuda and torch.cuda.is_available() else "cpu")
+    print(f"[PyTorch] Device: {device}")
+
+    # Récupération des données
+    train_dataloader, test_dataloader = prep.get_data()
+
+    # Création du validation set (split)
+    from torch.utils.data import random_split, DataLoader
+
+    dataset = train_dataloader.dataset
+    train_size = int(0.8 * len(dataset))
+    val_size   = len(dataset) - train_size
+
+    train_dataset, val_dataset = random_split(dataset, [train_size, val_size])
+
+    train_dataloader = DataLoader(train_dataset,
+                                  batch_size=train_dataloader.batch_size,
+                                  shuffle=True)
+
+    val_dataloader = DataLoader(val_dataset,
+                                batch_size=train_dataloader.batch_size,
+                                shuffle=False)
+
+    # Modèle
+    model = IntelCNN_PyTorch().to(device)
+
+    if args.mode == 'eval':
+        model.load_state_dict(torch.load("geraud_model.pth", map_location=device))
+        print("Model loaded from geraud_model.pth")
+
+    # Trainer corrigé
+    trainer = Trainer(model,
+                      train_dataloader,
+                      val_dataloader,
+                      test_dataloader,
+                      args.lr,
+                      args.wd,
+                      args.epochs,
+                      device)
+
+    if args.mode == 'train':
+        trainer.train(save=True, plot=True)
+
+    # Évaluation finale CORRIGÉE
+    trainer.test()
+
+
+def run_tensorflow(args):
+    import tensorflow as tf
+    from tensorflow.keras import layers, callbacks
+    from models.cnn import get_tensorflow_model
+
+    print(f"[TensorFlow] GPUs: {tf.config.list_physical_devices('GPU')}")
+
+    IMG_SIZE = 150
+    BATCH    = 32
+    DATA_DIR = '/kaggle/input/datasets/puneet6060/intel-image-classification/seg_train/seg_train'
+    VAL_DIR  = '/kaggle/input/datasets/puneet6060/intel-image-classification/seg_test/seg_test'
+    AUTOTUNE = tf.data.AUTOTUNE
+
+    norm    = layers.Rescaling(1./255)
+    augment = tf.keras.Sequential([
+        layers.RandomFlip("horizontal"),
+        layers.RandomRotation(0.15),
+        layers.RandomZoom(0.15),
+        layers.RandomBrightness(0.2),
+        layers.RandomContrast(0.2),
+    ])
+
+    train_ds = tf.keras.utils.image_dataset_from_directory(
+        DATA_DIR, image_size=(IMG_SIZE, IMG_SIZE), batch_size=BATCH)
+    val_ds   = tf.keras.utils.image_dataset_from_directory(
+        VAL_DIR, image_size=(IMG_SIZE, IMG_SIZE), batch_size=BATCH, shuffle=False)
+
+    train_ds = train_ds.map(
+        lambda x, y: (norm(tf.clip_by_value(augment(x, training=True), 0, 255)), y),
+        num_parallel_calls=AUTOTUNE).prefetch(AUTOTUNE)
+
+    val_ds = val_ds.map(
+        lambda x, y: (norm(x), y),
+        num_parallel_calls=AUTOTUNE).prefetch(AUTOTUNE)
+
+    model = get_tensorflow_model(IMG_SIZE)
+
+    if args.mode == 'eval':
+        model = tf.keras.models.load_model("geraud_model.keras")
+        print("Model loaded from geraud_model.keras")
+    else:
+        model.summary()
+        model.compile(
+            optimizer=tf.keras.optimizers.Adam(args.lr),
+            loss='sparse_categorical_crossentropy',
+            metrics=['accuracy']
+        )
+
+        cb = [
+            callbacks.ModelCheckpoint('geraud_model.keras', save_best_only=True,
+                                       monitor='val_accuracy', verbose=1),
+            callbacks.ReduceLROnPlateau(monitor='val_loss', factor=0.5, patience=3, verbose=1),
+            callbacks.EarlyStopping(monitor='val_loss', patience=10,
+                                    restore_best_weights=True, verbose=1),
+        ]
+
+        model.fit(train_ds, validation_data=val_ds, epochs=args.epochs, callbacks=cb)
+        print("Model saved to geraud_model.keras")
+
+    loss, acc = model.evaluate(val_ds, verbose=1)
+    print(f"\nTest Accuracy: {acc*100:.2f}%  |  Test Loss: {loss:.4f}")
+
+
+if __name__ == '__main__':
+    main()

models/cnn.py

@@ -0,0 +1,93 @@
+import torch.nn as nn
+import torch.nn.functional as F
+
+
+class IntelCNN_PyTorch(nn.Module):
+    def __init__(self, num_classes=6):
+        super(IntelCNN_PyTorch, self).__init__()
+        # Block 1
+        self.conv1a = nn.Conv2d(3,   32,  kernel_size=3, padding=1)
+        self.conv1b = nn.Conv2d(32,  32,  kernel_size=3, padding=1)
+        self.bn1    = nn.BatchNorm2d(32)
+        self.drop1  = nn.Dropout2d(0.1)
+        # Block 2
+        self.conv2a = nn.Conv2d(32,  64,  kernel_size=3, padding=1)
+        self.conv2b = nn.Conv2d(64,  64,  kernel_size=3, padding=1)
+        self.bn2    = nn.BatchNorm2d(64)
+        self.drop2  = nn.Dropout2d(0.2)
+        # Block 3
+        self.conv3a = nn.Conv2d(64,  128, kernel_size=3, padding=1)
+        self.conv3b = nn.Conv2d(128, 128, kernel_size=3, padding=1)
+        self.bn3    = nn.BatchNorm2d(128)
+        self.drop3  = nn.Dropout2d(0.3)
+        # Block 4
+        self.conv4  = nn.Conv2d(128, 256, kernel_size=3, padding=1)
+        self.bn4    = nn.BatchNorm2d(256)
+        self.drop4  = nn.Dropout2d(0.3)
+        # Classifier
+        self.pool    = nn.AdaptiveAvgPool2d(1)
+        self.fc1     = nn.Linear(256, 256)
+        self.fc2     = nn.Linear(256, num_classes)
+        self.dropout = nn.Dropout(0.5)
+
+    def forward(self, x):
+        # Block 1 — BN appliqué après les deux convolutions
+        x = F.relu(self.conv1a(x))
+        x = F.relu(self.bn1(self.conv1b(x)))
+        x = self.drop1(F.max_pool2d(x, 2))
+        # Block 2
+        x = F.relu(self.conv2a(x))
+        x = F.relu(self.bn2(self.conv2b(x)))
+        x = self.drop2(F.max_pool2d(x, 2))
+        # Block 3
+        x = F.relu(self.conv3a(x))
+        x = F.relu(self.bn3(self.conv3b(x)))
+        x = self.drop3(F.max_pool2d(x, 2))
+        # Block 4
+        x = F.relu(self.bn4(self.conv4(x)))
+        x = self.drop4(F.max_pool2d(x, 2))
+        # Classifier
+        x = self.pool(x)
+        x = x.view(x.size(0), -1)
+        x = F.relu(self.fc1(x))
+        x = self.dropout(x)
+        return self.fc2(x)   # logits bruts
+
+
+def get_tensorflow_model(img_size=150, num_classes=6):
+    from tensorflow.keras import layers, models
+
+    inp = layers.Input(shape=(img_size, img_size, 3))
+
+    # Block 1
+    x = layers.Conv2D(32, 3, padding='same', activation='relu')(inp)
+    x = layers.Conv2D(32, 3, padding='same', activation='relu')(x)
+    x = layers.BatchNormalization()(x)
+    x = layers.MaxPooling2D()(x)
+    x = layers.Dropout(0.1)(x)
+
+    # Block 2
+    x = layers.Conv2D(64, 3, padding='same', activation='relu')(x)
+    x = layers.Conv2D(64, 3, padding='same', activation='relu')(x)
+    x = layers.BatchNormalization()(x)
+    x = layers.MaxPooling2D()(x)
+    x = layers.Dropout(0.2)(x)
+
+    # Block 3
+    x = layers.Conv2D(128, 3, padding='same', activation='relu')(x)
+    x = layers.Conv2D(128, 3, padding='same', activation='relu')(x)
+    x = layers.BatchNormalization()(x)
+    x = layers.MaxPooling2D()(x)
+    x = layers.Dropout(0.4)(x)
+
+    # Block 4
+    x = layers.Conv2D(256, 3, padding='same', activation='relu')(x)
+    x = layers.BatchNormalization()(x)
+    x = layers.GlobalAveragePooling2D()(x)
+
+    # Classifier
+    x   = layers.Dense(256, activation='relu')(x)
+    x   = layers.Dropout(0.6)(x)
+    out = layers.Dense(num_classes, activation='softmax')(x)
+
+    return models.Model(inp, out)

models/train.py

@@ -0,0 +1,145 @@
+import torch
+from torch import nn
+from tqdm import tqdm
+import matplotlib.pyplot as plt
+
+
+class Trainer:
+    def __init__(self, model, train_dataloader, val_dataloader, test_dataloader,
+                 lr, wd, epochs, device):
+
+        self.epochs           = epochs
+        self.model            = model
+        self.train_dataloader = train_dataloader
+        self.val_dataloader   = val_dataloader   
+        self.test_dataloader  = test_dataloader
+        self.device           = device
+
+        self.optimizer = torch.optim.Adam(model.parameters(), lr=lr, weight_decay=wd)
+        self.scheduler = torch.optim.lr_scheduler.CosineAnnealingLR(
+            self.optimizer, T_max=epochs, eta_min=1e-6
+        )
+
+        self.criterion = nn.CrossEntropyLoss()
+
+        #  Early stopping
+        self.patience   = 10
+        self.no_improve = 0
+        self.best_acc   = 0
+
+    def train(self, save=True, plot=False):
+        self.train_acc  = []
+        self.train_loss = []
+        self.val_accs   = []
+
+        for epoch in range(self.epochs):
+            self.model.train()
+
+            total_loss    = 0
+            total_correct = 0
+            total_samples = 0
+
+            progress_bar = tqdm(self.train_dataloader,
+                                desc=f"Epoch {epoch + 1}/{self.epochs}", leave=False)
+
+            for inputs, labels in progress_bar:
+                inputs, labels = inputs.to(self.device), labels.to(self.device)
+
+                self.optimizer.zero_grad()
+
+                outputs = self.model(inputs)
+                loss    = self.criterion(outputs, labels)
+
+                loss.backward()
+                self.optimizer.step()
+
+                _, preds = outputs.max(1)
+
+                total_correct += (preds == labels).sum().item()
+                total_samples += labels.size(0)
+                total_loss    += loss.item() * labels.size(0)
+
+                avg_acc  = 100.0 * total_correct / total_samples
+                avg_loss = total_loss / total_samples
+
+                progress_bar.set_postfix({
+                    'Acc': f'{avg_acc:.2f}%',
+                    'Loss': f'{avg_loss:.4f}'
+                })
+
+            self.scheduler.step()
+
+            self.train_acc.append(avg_acc)
+            self.train_loss.append(avg_loss)
+
+            #  VALIDATION
+            val_acc, val_loss = self.evaluate(self.val_dataloader)
+            self.val_accs.append(val_acc)
+
+            print(f"\nEpoch {epoch+1}/{self.epochs}")
+            print(f"Train Loss: {avg_loss:.4f} | Train Acc: {avg_acc:.2f}%")
+            print(f"Val   Loss: {val_loss:.4f} | Val   Acc: {val_acc:.2f}%")
+
+            #  SAVE BEST MODEL
+            if val_acc > self.best_acc:
+                self.best_acc = val_acc
+                self.no_improve = 0
+
+                if save:
+                    torch.save(self.model.state_dict(), "geraud_model.pth")
+                    print(f" Best model saved (val_acc={val_acc:.2f}%)")
+
+            else:
+                self.no_improve += 1
+                print(f"No improvement ({self.no_improve}/{self.patience})")
+
+                #  EARLY STOPPING
+                if self.no_improve >= self.patience:
+                    print(" Early stopping triggered")
+                    break
+
+        if plot:
+            self.plot_training_history()
+
+    @torch.no_grad()
+    def evaluate(self, dataloader):
+        self.model.eval()
+
+        total_loss    = 0
+        total_correct = 0
+        total_samples = 0
+
+        for inputs, labels in tqdm(dataloader, desc="Evaluating", leave=False):
+            inputs, labels = inputs.to(self.device), labels.to(self.device)
+
+            outputs = self.model(inputs)
+            loss    = self.criterion(outputs, labels)
+
+            _, preds = outputs.max(1)
+
+            total_correct += (preds == labels).sum().item()
+            total_samples += labels.size(0)
+            total_loss    += loss.item() * labels.size(0)
+
+        avg_loss = total_loss / total_samples
+        accuracy = 100.0 * total_correct / total_samples
+
+        return accuracy, avg_loss
+
+    def test(self):
+        print("\n Final Test Evaluation:")
+        return self.evaluate(self.test_dataloader)
+
+    def plot_training_history(self):
+        epochs = range(1, len(self.train_loss) + 1)
+
+        plt.figure(figsize=(8, 5))
+        plt.plot(epochs, self.train_loss, label="Train Loss")
+        plt.plot(epochs, self.train_acc, label="Train Acc")
+        plt.plot(epochs, self.val_accs, label="Val Acc")
+
+        plt.xlabel("Epoch")
+        plt.title("Training History")
+        plt.legend()
+        plt.savefig("training_history.png")
+        plt.show()

requirements.txt

@@ -0,0 +1,7 @@
+flask
+torch
+torchvision
+pillow
+numpy
+tensorflow
+gunicorn

templates/index.html

@@ -0,0 +1,347 @@
+<!DOCTYPE html>
+<html lang="fr">
+<head>
+  <meta charset="UTF-8" />
+  <meta name="viewport" content="width=device-width, initial-scale=1.0"/>
+  <title>Intel Image Classifier</title>
+  <style>
+    * { box-sizing: border-box; margin: 0; padding: 0; }
+
+    body {
+      font-family: 'Segoe UI', sans-serif;
+      background: #0f1117;
+      color: #e2e8f0;
+      min-height: 100vh;
+      display: flex;
+      flex-direction: column;
+      align-items: center;
+      padding: 40px 16px;
+    }
+
+    h1 {
+      font-size: 1.8rem;
+      font-weight: 700;
+      margin-bottom: 4px;
+      background: linear-gradient(90deg, #6366f1, #06b6d4);
+      -webkit-background-clip: text;
+      -webkit-text-fill-color: transparent;
+    }
+
+    .subtitle {
+      font-size: 0.85rem;
+      color: #64748b;
+      margin-bottom: 36px;
+    }
+
+    .card {
+      background: #1e2130;
+      border: 1px solid #2d3148;
+      border-radius: 16px;
+      padding: 32px;
+      width: 100%;
+      max-width: 560px;
+      box-shadow: 0 8px 32px rgba(0,0,0,0.4);
+    }
+
+    /* Drop zone */
+    .drop-zone {
+      border: 2px dashed #3b4265;
+      border-radius: 12px;
+      padding: 36px 16px;
+      text-align: center;
+      cursor: pointer;
+      transition: border-color 0.2s, background 0.2s;
+      margin-bottom: 20px;
+      position: relative;
+    }
+    .drop-zone:hover, .drop-zone.dragover {
+      border-color: #6366f1;
+      background: rgba(99,102,241,0.05);
+    }
+    .drop-zone input[type="file"] {
+      position: absolute;
+      inset: 0;
+      opacity: 0;
+      cursor: pointer;
+      width: 100%;
+      height: 100%;
+    }
+    .drop-zone .icon { font-size: 2.4rem; margin-bottom: 8px; }
+    .drop-zone p { font-size: 0.85rem; color: #64748b; }
+    .drop-zone p span { color: #6366f1; font-weight: 600; }
+
+    /* Preview */
+    #preview-wrap {
+      display: none;
+      margin-bottom: 20px;
+      border-radius: 10px;
+      overflow: hidden;
+    }
+    #preview-wrap img {
+      width: 100%;
+      max-height: 260px;
+      object-fit: cover;
+      border-radius: 10px;
+    }
+
+    /* Backend selector */
+    .backend-row {
+      display: flex;
+      gap: 10px;
+      margin-bottom: 20px;
+    }
+    .backend-btn {
+      flex: 1;
+      padding: 10px;
+      border-radius: 8px;
+      border: 2px solid #2d3148;
+      background: transparent;
+      color: #94a3b8;
+      font-size: 0.9rem;
+      cursor: pointer;
+      transition: all 0.2s;
+      font-weight: 500;
+    }
+    .backend-btn.active {
+      border-color: #6366f1;
+      background: rgba(99,102,241,0.15);
+      color: #a5b4fc;
+    }
+
+    /* Predict button */
+    #predict-btn {
+      width: 100%;
+      padding: 13px;
+      border: none;
+      border-radius: 10px;
+      background: linear-gradient(90deg, #6366f1, #06b6d4);
+      color: white;
+      font-size: 1rem;
+      font-weight: 600;
+      cursor: pointer;
+      transition: opacity 0.2s;
+      margin-bottom: 24px;
+    }
+    #predict-btn:hover { opacity: 0.88; }
+    #predict-btn:disabled { opacity: 0.45; cursor: not-allowed; }
+
+    /* Results */
+    #result-box { display: none; }
+
+    .result-header {
+      display: flex;
+      align-items: center;
+      gap: 10px;
+      margin-bottom: 16px;
+    }
+    .badge {
+      background: rgba(99,102,241,0.2);
+      color: #a5b4fc;
+      border-radius: 20px;
+      padding: 4px 12px;
+      font-size: 0.78rem;
+      font-weight: 600;
+      text-transform: uppercase;
+      letter-spacing: 0.05em;
+    }
+    .top-label { font-size: 1.25rem; font-weight: 700; }
+    .top-conf  { font-size: 0.85rem; color: #64748b; }
+
+    /* Bars */
+    .bar-row {
+      display: flex;
+      align-items: center;
+      gap: 10px;
+      margin-bottom: 9px;
+    }
+    .bar-label {
+      width: 80px;
+      font-size: 0.8rem;
+      color: #94a3b8;
+      text-align: right;
+      flex-shrink: 0;
+    }
+    .bar-track {
+      flex: 1;
+      background: #2d3148;
+      border-radius: 6px;
+      height: 10px;
+      overflow: hidden;
+    }
+    .bar-fill {
+      height: 100%;
+      border-radius: 6px;
+      background: linear-gradient(90deg, #6366f1, #06b6d4);
+      transition: width 0.6s ease;
+    }
+    .bar-pct {
+      width: 42px;
+      font-size: 0.78rem;
+      color: #64748b;
+      text-align: right;
+      flex-shrink: 0;
+    }
+
+    /* Error */
+    .error-msg {
+      background: rgba(239,68,68,0.12);
+      border: 1px solid rgba(239,68,68,0.3);
+      border-radius: 8px;
+      padding: 12px 16px;
+      color: #fca5a5;
+      font-size: 0.85rem;
+    }
+
+    /* Spinner */
+    .spinner {
+      display: inline-block;
+      width: 16px; height: 16px;
+      border: 2px solid rgba(255,255,255,0.3);
+      border-top-color: #fff;
+      border-radius: 50%;
+      animation: spin 0.7s linear infinite;
+      vertical-align: middle;
+      margin-right: 8px;
+    }
+    @keyframes spin { to { transform: rotate(360deg); } }
+  </style>
+</head>
+<body>
+
+  <h1> Intel Image Classifier</h1>
+  <p class="subtitle">buildings · forest · glacier · mountain · sea · street</p>
+
+  <div class="card">
+
+    <!-- Drop zone -->
+    <div class="drop-zone" id="drop-zone">
+      <input type="file" id="file-input" accept="image/*" />
+      <div class="icon"></div>
+      <p> <span>Put here your to predict</span></p>
+    </div>
+
+    <!-- Preview -->
+    <div id="preview-wrap">
+      <img id="preview-img" src="" alt="preview" />
+    </div>
+
+    <!-- Backend -->
+    <div class="backend-row">
+      <button class="backend-btn active" data-backend="PyTorch"> PyTorch</button>
+      <button class="backend-btn"        data-backend="Keras"> Keras</button>
+    </div>
+
+    <!-- Predict -->
+    <button id="predict-btn" disabled>Predict</button>
+
+    <!-- Results -->
+    <div id="result-box"></div>
+
+  </div>
+
+  <script>
+    let selectedFile    = null;
+    let selectedBackend = "PyTorch";
+
+    // Backend toggle 
+    document.querySelectorAll(".backend-btn").forEach(btn => {
+      btn.addEventListener("click", () => {
+        document.querySelectorAll(".backend-btn").forEach(b => b.classList.remove("active"));
+        btn.classList.add("active");
+        selectedBackend = btn.dataset.backend;
+      });
+    });
+
+    // File input
+    const fileInput  = document.getElementById("file-input");
+    const dropZone   = document.getElementById("drop-zone");
+    const predictBtn = document.getElementById("predict-btn");
+    const preview    = document.getElementById("preview-img");
+    const previewWrap = document.getElementById("preview-wrap");
+
+    fileInput.addEventListener("change", () => handleFile(fileInput.files[0]));
+
+    dropZone.addEventListener("dragover",  e => { e.preventDefault(); dropZone.classList.add("dragover"); });
+    dropZone.addEventListener("dragleave", ()  => dropZone.classList.remove("dragover"));
+    dropZone.addEventListener("drop", e => {
+      e.preventDefault();
+      dropZone.classList.remove("dragover");
+      handleFile(e.dataTransfer.files[0]);
+    });
+
+    function handleFile(file) {
+      if (!file || !file.type.startsWith("image/")) return;
+      selectedFile = file;
+      const url = URL.createObjectURL(file);
+      preview.src       = url;
+      previewWrap.style.display = "block";
+      predictBtn.disabled = false;
+      document.getElementById("result-box").style.display = "none";
+    }
+
+    // Predict 
+    predictBtn.addEventListener("click", async () => {
+      if (!selectedFile) return;
+
+      predictBtn.disabled = true;
+      predictBtn.innerHTML = '<span class="spinner"></span> Analysis in progress…';
+
+      const formData = new FormData();
+      formData.append("image",   selectedFile);
+      formData.append("backend", selectedBackend);
+
+      try {
+        const res  = await fetch("/predict", { method: "POST", body: formData });
+        const data = await res.json();
+        renderResult(data);
+      } catch (err) {
+        renderError("Network Error : " + err.message);
+      } finally {
+        predictBtn.disabled = false;
+        predictBtn.textContent = "Predict";
+      }
+    });
+
+    // ── Render ───────────────────────────────────────────────
+    function renderResult(data) {
+      const box = document.getElementById("result-box");
+      box.style.display = "block";
+
+      if (data.error) { renderError(data.error); return; }
+
+      const EMOJIS = {
+        buildings: "", forest: "", glacier: "",
+        mountain: "",  sea: "",    street: ""
+      };
+
+      let html = `
+        <div class="result-header">
+          <span class="badge">${data.backend}</span>
+          <div>
+            <div class="top-label">${EMOJIS[data.prediction] || "--"} ${data.prediction}</div>
+            <div class="top-conf">${data.confidence}% confidence</div>
+          </div>
+        </div>`;
+
+      data.all.forEach(item => {
+        html += `
+          <div class="bar-row">
+            <div class="bar-label">${item.class}</div>
+            <div class="bar-track">
+              <div class="bar-fill" style="width:${item.confidence}%"></div>
+            </div>
+            <div class="bar-pct">${item.confidence}%</div>
+          </div>`;
+      });
+
+      box.innerHTML = html;
+    }
+
+    function renderError(msg) {
+      const box = document.getElementById("result-box");
+      box.style.display = "block";
+      box.innerHTML = `<div class="error-msg"> ${msg}</div>`;
+    }
+  </script>
+</body>
+</html>

utils/prep.py

@@ -0,0 +1,35 @@
+from torch.utils.data import DataLoader
+from torchvision import datasets, transforms
+
+DATA_DIR = '/kaggle/input/datasets/puneet6060/intel-image-classification/seg_train/seg_train'
+VAL_DIR  = '/kaggle/input/datasets/puneet6060/intel-image-classification/seg_test/seg_test'
+IMG_SIZE = 150
+BATCH    = 32
+
+
+def get_data():
+    train_transforms = transforms.Compose([
+        transforms.Resize((IMG_SIZE, IMG_SIZE)),
+        transforms.RandomHorizontalFlip(),
+        transforms.RandomRotation(15),
+        transforms.ColorJitter(brightness=0.2, contrast=0.2, saturation=0.2),
+        transforms.ToTensor(),
+        transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225]),
+    ])
+    val_transforms = transforms.Compose([
+        transforms.Resize((IMG_SIZE, IMG_SIZE)),
+        transforms.ToTensor(),
+        transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225]),
+    ])
+
+    train_dataset = datasets.ImageFolder(DATA_DIR, transform=train_transforms)
+    val_dataset   = datasets.ImageFolder(VAL_DIR,  transform=val_transforms)
+
+    # num_workers=4 et pin_memory=True pour accélérer le chargement GPU
+    train_dataloader = DataLoader(train_dataset, batch_size=BATCH, shuffle=True,
+                                  num_workers=4, pin_memory=True,
+                                  persistent_workers=True)
+    test_dataloader  = DataLoader(val_dataset,   batch_size=BATCH, shuffle=False,
+                                  num_workers=4, pin_memory=True,
+                                  persistent_workers=True)
+    return train_dataloader, test_dataloader