Upload 9 files

.gitattributes

@@ -33,3 +33,4 @@ saved_model/**/* 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
+sara_model.keras filter=lfs diff=lfs merge=lfs -text

Dockerfile

@@ -0,0 +1,18 @@
+FROM python:3.10-slim
+
+WORKDIR /app
+
+COPY requirements.txt .
+
+RUN pip install --no-cache-dir flask pillow numpy gunicorn
+RUN pip install --no-cache-dir torch torchvision --index-url https://download.pytorch.org/whl/cpu
+RUN pip install --no-cache-dir tensorflow-cpu
+
+
+COPY . .
+
+
+EXPOSE 7860
+
+
+CMD ["gunicorn", "app:app", "--bind", "0.0.0.0:7860", "--timeout", "120"]

app.py

@@ -0,0 +1,103 @@
+import os
+import io
+import base64
+from pathlib import Path
+from flask import (Flask, request, render_template,jsonify, redirect, url_for)
+from werkzeug.utils import secure_filename
+from PIL import Image
+from predict import predict_pytorch, predict_tensorflow
+
+
+
+app = Flask(__name__)
+
+
+app.config["MAX_CONTENT_LENGTH"] = 5 * 1024 * 1024   # 5 MB upload limit
+ALLOWED_EXT = {"png", "jpg", "jpeg", "webp", "bmp"}
+
+PYTORCH_MODEL_PATH = os.getenv("PYTORCH_MODEL_PATH", "sara_model.pth")
+TF_MODEL_PATH = os.getenv("TF_MODEL_PATH",      "sara_model.keras")
+
+CLASS_ICONS = {
+    "buildings",
+    "forest",
+    "glacier",
+    "mountain",
+    "sea",
+    "street",
+}
+
+
+def allowed_file(filename: str) -> bool:
+    return ("." in filename and filename.rsplit(".", 1)[1].lower() in ALLOWED_EXT)
+
+
+def image_to_b64(img: Image.Image, fmt: str = "JPEG") -> str:
+    buf = io.BytesIO()
+    img.convert("RGB").save(buf, format=fmt)
+    return base64.b64encode(buf.getvalue()).decode("utf-8")
+
+
+# Routes
+@app.route("/", methods=["GET"])
+def index():
+    return render_template("index.html")
+
+
+@app.route("/predict", methods=["POST"])
+def predict():
+    model_choice = request.form.get("model", "pytorch")
+    file = request.files.get("image")
+
+    if not file or file.filename == "":
+        return render_template("index.html", error="Please upload an image file."), 400
+
+    if not allowed_file(file.filename):
+        return render_template("index.html", error="Unsupported file type. " "Use JPG, PNG, WEBP or BMP."), 400
+
+   
+    img_bytes = file.read()
+    pil_img = Image.open(io.BytesIO(img_bytes)).convert("RGB")
+
+    tmp_path = Path("tmp_upload.jpg")
+    pil_img.save(tmp_path, format="JPEG")
+
+    try:
+        if model_choice == "pytorch":
+            result = predict_pytorch(str(tmp_path),model_path=PYTORCH_MODEL_PATH)
+        else:
+            result = predict_tensorflow(str(tmp_path),model_path=TF_MODEL_PATH)
+    except FileNotFoundError as e:
+        tmp_path.unlink(missing_ok=True)
+        return render_template("index.html",error=f"Model file not found: {e}. " "Train a model first."), 500
+    except Exception as e:
+        tmp_path.unlink(missing_ok=True)
+        return render_template("index.html",error=f"Inference error: {e}"), 500
+    finally:
+        tmp_path.unlink(missing_ok=True)
+
+    img_b64 = image_to_b64(pil_img)
+    probs = result["all_probabilities"]
+
+    # Sort by confidence descending for the bar chart
+    sorted_probs = sorted(probs.items(), key=lambda x: -x[1])
+
+    return render_template(
+        "index.html",
+        result = result,
+        model_used = model_choice,
+        img_b64 = img_b64,
+        sorted_probs = sorted_probs,
+        class_icons = CLASS_ICONS,
+    )
+
+
+@app.route("/health")
+def health():
+    return jsonify({"status": "ok"}), 200
+
+
+
+if __name__ == "__main__":
+    port = int(os.getenv("PORT", 7860))
+    app.run(host="0.0.0.0", port=port, debug=False)

data_loader.py

@@ -0,0 +1,140 @@
+import os
+import numpy as np
+from pathlib import Path
+import torch
+from torch.utils.data import DataLoader, random_split
+from torchvision import datasets, transforms
+import tensorflow as tf
+
+
+
+IMAGE_SIZE = (150, 150)   
+BATCH_SIZE = 32
+VAL_SPLIT = 0.2        
+SEED = 42
+
+CLASS_NAMES = ["buildings", "forest", "glacier", "mountain", "sea", "street"]
+
+
+
+
+#  PyTorch  Data Pipeline
+def get_pytorch_loaders(train_dir: str, test_dir: str):
+    mean = [0.485, 0.456, 0.406]
+    std = [0.229, 0.224, 0.225]
+
+    
+    train_transform = transforms.Compose([
+        transforms.Resize(IMAGE_SIZE),
+        transforms.RandomHorizontalFlip(p=0.5),          
+        transforms.RandomRotation(degrees=15),          
+        transforms.RandomResizedCrop(IMAGE_SIZE,scale=(0.8, 1.0)),
+        transforms.ColorJitter(brightness=0.2,contrast=0.2),
+        transforms.ToTensor(),                          
+        transforms.Normalize(mean, std),   
+    ])
+
+    eval_transform = transforms.Compose([
+        transforms.Resize(IMAGE_SIZE),
+        transforms.ToTensor(),
+        transforms.Normalize(mean, std),
+    ])
+
+    full_train = datasets.ImageFolder(root=train_dir,transform=train_transform)
+
+    # Split into train / validation
+    n_val = int(len(full_train) * VAL_SPLIT)
+    n_train = len(full_train) - n_val
+    train_ds, val_ds = random_split(
+        full_train, [n_train, n_val],
+        generator=torch.Generator().manual_seed(SEED)
+    )
+
+    
+    val_ds.dataset = datasets.ImageFolder(root=train_dir,transform=eval_transform)
+    test_ds = datasets.ImageFolder(root=test_dir, transform=eval_transform)
+
+    
+    train_loader = DataLoader(train_ds, batch_size=BATCH_SIZE, shuffle=True, num_workers=2, pin_memory=True)
+    val_loader = DataLoader(val_ds, batch_size=BATCH_SIZE, shuffle=False, num_workers=2, pin_memory=True)
+    test_loader  = DataLoader(test_ds, batch_size=BATCH_SIZE, shuffle=False, num_workers=2, pin_memory=True)
+
+    print(f"[PyTorch] Train: {n_train} | Val: {n_val} | Test: {len(test_ds)}")
+    return train_loader, val_loader, test_loader, full_train.classes
+
+
+
+
+
+#  TensorFlow  Data Pipeline
+def get_tensorflow_datasets(train_dir: str, test_dir: str):
+    img_h, img_w = IMAGE_SIZE
+
+    raw_train = tf.keras.utils.image_dataset_from_directory(
+        train_dir,
+        validation_split=VAL_SPLIT,
+        subset="training",
+        seed=SEED,
+        image_size=IMAGE_SIZE,
+        batch_size=BATCH_SIZE,
+        label_mode="categorical", 
+    )
+
+    raw_val = tf.keras.utils.image_dataset_from_directory(
+        train_dir,
+        validation_split=VAL_SPLIT,
+        subset="validation",
+        seed=SEED,
+        image_size=IMAGE_SIZE,
+        batch_size=BATCH_SIZE,
+        label_mode="categorical",
+    )
+
+    raw_test = tf.keras.utils.image_dataset_from_directory(
+        test_dir,
+        image_size=IMAGE_SIZE,
+        batch_size=BATCH_SIZE,
+        label_mode="categorical",
+        shuffle=False,
+    )
+    
+
+    class_names = raw_train.class_names
+
+    
+    normalization = tf.keras.layers.Rescaling(1.0 / 255)
+    augmentation = tf.keras.Sequential([
+        tf.keras.layers.RandomFlip("horizontal"),
+        tf.keras.layers.RandomRotation(0.1),       
+        tf.keras.layers.RandomZoom(0.2),           
+        tf.keras.layers.RandomContrast(0.1),
+    ])
+
+    def preprocess_train(images, labels):
+        images = normalization(images)
+        images = augmentation(images, training=True)
+        return images, labels
+
+    def preprocess_eval(images, labels):
+        images = normalization(images)
+        return images, labels
+
+    AUTOTUNE = tf.data.AUTOTUNE
+
+    train_ds = (raw_train
+                .map(preprocess_train, num_parallel_calls=AUTOTUNE)
+                .cache()
+                .shuffle(1000)
+                .prefetch(AUTOTUNE))
+
+    val_ds = (raw_val
+              .map(preprocess_eval, num_parallel_calls=AUTOTUNE)
+              .cache()
+              .prefetch(AUTOTUNE))
+
+    test_ds = (raw_test
+               .map(preprocess_eval, num_parallel_calls=AUTOTUNE)
+               .prefetch(AUTOTUNE))
+
+    print(f"[TensorFlow] Classes: {class_names}")
+    return train_ds, val_ds, test_ds, class_names

model_pytorch.py

@@ -0,0 +1,90 @@
+"""
+model_pytorch.py
+Architecture summary:
+    Block 1 : Conv(32)  → BN → ReLU → Conv(32)  → BN → ReLU → MaxPool → Dropout
+    Block 2 : Conv(64)  → BN → ReLU → Conv(64)  → BN → ReLU → MaxPool → Dropout
+    Block 3 : Conv(128) → BN → ReLU → Conv(128) → BN → ReLU → MaxPool → Dropout
+    Head    : Flatten → FC(256) → BN → ReLU → Dropout → FC(6) → Softmax
+"""
+
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+
+
+class ConvBlock(nn.Module):
+    """
+    Reusable double-convolution block.
+    Two Conv2d layers → Batch Norm → ReLU → MaxPool → Dropout.
+    """
+    def __init__(self, in_channels: int, out_channels: int, dropout_rate: float = 0.25):
+        super().__init__()
+
+        self.block = nn.Sequential(
+            nn.Conv2d(in_channels, out_channels, kernel_size=3, padding=1, bias=False),
+            nn.BatchNorm2d(out_channels),
+            nn.ReLU(inplace=True),
+
+            nn.Conv2d(out_channels, out_channels,kernel_size=3, padding=1, bias=False),
+            nn.BatchNorm2d(out_channels),
+            nn.ReLU(inplace=True),
+
+            nn.MaxPool2d(kernel_size=2, stride=2),
+
+            nn.Dropout2d(p=dropout_rate),
+        )
+
+    def forward(self, x):
+        return self.block(x)
+
+
+class SaraCNN(nn.Module):
+    def __init__(self, num_classes: int = 6):
+        super().__init__()
+
+        self.features = nn.Sequential(
+            ConvBlock(3,   32,  dropout_rate=0.25),   
+            ConvBlock(32,  64,  dropout_rate=0.25), 
+            ConvBlock(64,  128, dropout_rate=0.25),   
+        )
+
+        self.classifier = nn.Sequential(
+            nn.Flatten(),
+
+            nn.Linear(128 * 18 * 18, 256),
+            nn.BatchNorm1d(256),
+            nn.ReLU(inplace=True),
+            nn.Dropout(p=0.5),
+
+            nn.Linear(256, num_classes),  
+        )
+
+       
+        self._init_weights()
+
+    def _init_weights(self):
+        for m in self.modules():
+            if isinstance(m, nn.Conv2d):
+                nn.init.kaiming_normal_(m.weight, mode="fan_out", nonlinearity="relu")
+            elif isinstance(m, nn.Linear):
+                nn.init.xavier_uniform_(m.weight)
+                nn.init.zeros_(m.bias)
+            elif isinstance(m, (nn.BatchNorm2d, nn.BatchNorm1d)):
+                nn.init.ones_(m.weight)
+                nn.init.zeros_(m.bias)
+
+    def forward(self, x: torch.Tensor) -> torch.Tensor:
+        x = self.features(x)
+        x = self.classifier(x)
+        return x
+
+
+
+if __name__ == "__main__":
+    model = SaraCNN(num_classes=6)
+    dummy = torch.randn(4, 3, 150, 150)  
+    out   = model(dummy)
+    print("SaraCNN output shape:", out.shape)  
+
+    total = sum(p.numel() for p in model.parameters() if p.requires_grad)
+    print(f"Trainable parameters: {total:,}")

model_tensorflow.py

@@ -0,0 +1,70 @@
+"""
+Architecture summary:
+    Stem   : Conv(32, 3×3) → BN → ReLU
+    Stage 1: SepConv(64)  → BN → ReLU → MaxPool → Dropout
+    Stage 2: SepConv(128) → BN → ReLU → MaxPool → Dropout
+    Stage 3: SepConv(256) → BN → ReLU → MaxPool → Dropout
+    Head   : GlobalAvgPool → Dense(128) → BN → ReLU → Dropout → Dense(6, softmax)
+
+"""
+
+import tensorflow as tf
+from tensorflow.keras import layers, Model
+
+
+def separable_block(x, filters: int, dropout_rate: float = 0.25):
+    x = layers.SeparableConv2D(
+        filters, kernel_size=3, padding="same", use_bias=False)(x)
+    x = layers.BatchNormalization()(x)
+    x = layers.Activation("relu")(x)
+
+    x = layers.SeparableConv2D(
+        filters, kernel_size=3, padding="same", use_bias=False)(x)
+    x = layers.BatchNormalization()(x)
+    x = layers.Activation("relu")(x)
+
+    x = layers.MaxPooling2D(pool_size=2)(x)
+
+    x = layers.SpatialDropout2D(rate=dropout_rate)(x)
+
+    return x
+
+
+def build_sara_tf_model(input_shape=(150, 150, 3), num_classes: int = 6) -> Model:
+   
+    inputs = tf.keras.Input(shape=input_shape, name="image_input")
+
+    x = layers.Conv2D(32, kernel_size=3, padding="same",
+                      use_bias=False, name="stem_conv")(inputs)
+    x = layers.BatchNormalization(name="stem_bn")(x)
+    x = layers.Activation("relu", name="stem_relu")(x)
+
+    x = separable_block(x, filters=64,  dropout_rate=0.25)
+    x = separable_block(x, filters=128, dropout_rate=0.25)
+    x = separable_block(x, filters=256, dropout_rate=0.30)
+
+   
+    x = layers.GlobalAveragePooling2D(name="gap")(x)
+
+    x = layers.Dense(128, use_bias=False, name="fc1")(x)
+    x = layers.BatchNormalization(name="fc1_bn")(x)
+    x = layers.Activation("relu", name="fc1_relu")(x)
+    x = layers.Dropout(0.5, name="fc1_drop")(x)
+
+    outputs = layers.Dense(num_classes, activation="softmax",
+                           name="predictions")(x)
+
+    model = Model(inputs=inputs, outputs=outputs, name="SaraCNN_TF")
+
+    model.compile(
+        optimizer=tf.keras.optimizers.Adam(learning_rate=1e-3),
+        loss="categorical_crossentropy",
+        metrics=["accuracy"],
+    )
+
+    return model
+
+
+if __name__ == "__main__":
+    model = build_sara_tf_model()
+    model.summary()

predict.py

@@ -0,0 +1,141 @@
+import argparse
+import numpy as np
+from pathlib import Path
+from PIL import Image
+import torch
+from torchvision import transforms
+from model_pytorch import SaraCNN
+import tensorflow as tf
+
+
+CLASS_NAMES = ["buildings", "forest", "glacier", "mountain", "sea", "street"]
+
+IMAGE_SIZE = (150, 150)  
+MEAN = [0.485, 0.456, 0.406] 
+STD = [0.229, 0.224, 0.225]
+
+
+
+
+#  PyTorch Prediction
+def predict_pytorch(image_path: str,
+                    model_path: str = "sara_model.pth") -> dict:
+    """
+    Load the PyTorch checkpoint and return class probabilities.
+
+    Args:
+        image_path : path to the input image
+        model_path : path to the saved .pth file
+
+    Returns:
+        dict with keys: predicted_class, confidence, all_probabilities
+    """
+    
+    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+
+    checkpoint = torch.load(model_path, map_location=device)
+    class_names = checkpoint.get("class_names", CLASS_NAMES)
+    num_classes = len(class_names)
+
+    model = SaraCNN(num_classes=num_classes)
+    model.load_state_dict(checkpoint["model_state"])
+    model.to(device)
+    model.eval()
+
+    transform = transforms.Compose([
+        transforms.Resize(IMAGE_SIZE),
+        transforms.ToTensor(),
+        transforms.Normalize(MEAN, STD),
+    ])
+
+    img = Image.open(image_path).convert("RGB")
+    tensor = transform(img).unsqueeze(0).to(device)
+
+    with torch.no_grad():
+        logits = model(tensor)
+        probs = torch.softmax(logits, dim=1).squeeze().cpu().numpy()
+
+    idx = int(np.argmax(probs))
+    pred_class = class_names[idx]
+    confidence = float(probs[idx])
+
+    return {
+        "predicted_class": pred_class,
+        "confidence":      round(confidence * 100, 2),
+        "all_probabilities": {
+            cls: round(float(p) * 100, 2)
+            for cls, p in zip(class_names, probs)
+        },
+    }
+
+
+
+
+
+
+
+#  TensorFlow Prediction
+def predict_tensorflow(image_path: str,
+                       model_path: str = "sara_model.keras") -> dict:
+    """
+    Load the Keras model and return class probabilities.
+
+    Args:
+        image_path : path to the input image
+        model_path : path to the saved .keras file
+
+    Returns:
+        dict with keys: predicted_class, confidence, all_probabilities
+    """
+    
+    model = tf.keras.models.load_model(model_path)
+
+    img = tf.keras.utils.load_img(image_path, target_size=IMAGE_SIZE)
+    arr = tf.keras.utils.img_to_array(img) 
+    arr = arr / 255.0                         
+    arr = np.expand_dims(arr, axis=0)  
+
+   
+    probs = model.predict(arr, verbose=0)[0] 
+    idx = int(np.argmax(probs))
+    pred_class = CLASS_NAMES[idx]
+    confidence = float(probs[idx])
+
+    return {
+        "predicted_class": pred_class,
+        "confidence":      round(confidence * 100, 2),
+        "all_probabilities": {
+            cls: round(float(p) * 100, 2)
+            for cls, p in zip(CLASS_NAMES, probs)
+        },
+    }
+
+
+
+
+
+#  CLI Entry Point
+def parse_args():
+    p = argparse.ArgumentParser(description="Predict image class")
+    p.add_argument("--model", required=True, choices=["pytorch", "tensorflow"])
+    p.add_argument("--image", required=True, help="Path to the image file")
+    p.add_argument("--model_path", default=None, help="Override default model file path")
+    return p.parse_args()
+
+
+if __name__ == "__main__":
+    args = parse_args()
+
+    if args.model == "pytorch":
+        path   = args.model_path or "sara_model.pth"
+        result = predict_pytorch(args.image, model_path=path)
+    else:
+        path   = args.model_path or "sara_model.keras"
+        result = predict_tensorflow(args.image, model_path=path)
+
+    print(f"\n Predicted class : {result['predicted_class']}")
+    print(f" Confidence      : {result['confidence']}%")
+    print("\n All probabilities:")
+    for cls, prob in sorted(result["all_probabilities"].items(), key=lambda x: -x[1]):
+        bar = " " * int(prob / 5)
+        print(f"{cls:<12} {prob:6.2f}%  {bar}")

requirements.txt

@@ -0,0 +1,8 @@
+tensorflow>=2.14.0
+Pillow>=10.0.0
+numpy>=1.24.0
+Flask>=3.0.0
+Werkzeug>=3.0.0
+gunicorn>=21.2.0          
+tqdm>=4.66.0              
+matplotlib>=3.7.0        

sara_model.keras

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

sara_model.pth

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