Deployment Added

Dockerfile

@@ -0,0 +1,21 @@
+FROM python:3.10-slim
+
+ENV PYTHONDONTWRITEBYTECODE=1 \
+    PYTHONUNBUFFERED=1 \
+    PIP_NO_CACHE_DIR=1
+
+WORKDIR /app
+
+RUN apt-get update && apt-get install -y --no-install-recommends \
+    libgl1 \
+    libglib2.0-0 \
+    && rm -rf /var/lib/apt/lists/*
+
+COPY requirements.txt /app/requirements.txt
+RUN pip install --upgrade pip && pip install -r /app/requirements.txt
+
+COPY . /app
+
+EXPOSE 7860
+
+CMD ["uvicorn", "app:app", "--host", "0.0.0.0", "--port", "7860"]

LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Md Shoaib Shahriar Ibrahim
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

app.py

@@ -0,0 +1,283 @@
+# main.py — FastAPI backend
+# Endpoints:
+#   GET  /                  -> serve static/index.html
+#   GET  /health            -> health check
+#   GET  /benchmark         -> cached benchmark results
+#   GET  /models/info       -> metadata about loaded models
+#   POST /predict           -> TF model prediction
+#   POST /predict/onnx      -> ONNX FP32 prediction
+#   POST /predict/dynamic   -> Dynamic INT8 prediction
+#   POST /predict/static    -> Static INT8 prediction
+#   POST /predict/gradcam   -> TF prediction + Grad-CAM overlay image
+
+import os
+import io
+import json
+import time
+import base64
+import tempfile
+import numpy as np
+import cv2
+import matplotlib
+matplotlib.use("Agg")
+from PIL import Image
+
+from fastapi import FastAPI, File, UploadFile, HTTPException
+from fastapi.middleware.cors import CORSMiddleware
+from fastapi.responses import FileResponse
+from fastapi.staticfiles import StaticFiles
+from pydantic import BaseModel
+
+from src.utils import load_config, get_logger
+from predict import BrainTumorPredictor
+
+logger = get_logger("api")
+cfg = load_config("config.yaml")
+
+# ---------------------------------------------------------------------------
+# App setup
+# ---------------------------------------------------------------------------
+
+app = FastAPI(
+    title       = "Brain Tumor Classification API",
+    description = "MRI brain tumor classification with TF, ONNX FP32, Dynamic INT8, Static INT8 + Grad-CAM",
+    version     = "1.0.0",
+)
+
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins     = ["*"],
+    allow_credentials = True,
+    allow_methods     = ["*"],
+    allow_headers     = ["*"],
+)
+
+BASE_DIR   = os.path.dirname(os.path.abspath(__file__))
+STATIC_DIR = os.path.join(BASE_DIR, "static")
+
+if os.path.exists(STATIC_DIR):
+    app.mount("/static", StaticFiles(directory=STATIC_DIR), name="static")
+else:
+    logger.warning(f"Static directory not found: {STATIC_DIR}")
+
+# ---------------------------------------------------------------------------
+# Load predictors at startup
+# ---------------------------------------------------------------------------
+
+predictors:  dict = {}
+load_errors: dict = {}   # stores error messages for failed backends
+
+@app.on_event("startup")
+async def load_models():
+    global predictors, load_errors
+    logger.info("Loading models ...")
+
+    # TF backend — always try first
+    try:
+        predictors["tensorflow"] = BrainTumorPredictor(cfg, backend="tensorflow")
+        logger.info("[OK] TF model loaded.")
+    except Exception as e:
+        load_errors["tensorflow"] = str(e)
+        logger.error(f"[FAIL] TF model failed to load: {e}")
+
+    # ONNX backends — optional, warn if not found
+    for backend in ["onnx_fp32", "onnx_dynamic", "onnx_static"]:
+        try:
+            predictors[backend] = BrainTumorPredictor(cfg, backend=backend)
+            logger.info(f"[OK] {backend} loaded.")
+        except FileNotFoundError as e:
+            load_errors[backend] = str(e)
+            logger.warning(f"[SKIP] {backend} — file not found. Run export_onnx.py first.")
+        except Exception as e:
+            load_errors[backend] = str(e)
+            logger.error(f"[FAIL] {backend} failed: {e}")
+
+    logger.info(f"Loaded backends : {list(predictors.keys())}")
+    if load_errors:
+        logger.warning(f"Failed backends : {list(load_errors.keys())}")
+
+
+# ---------------------------------------------------------------------------
+# Helpers
+# ---------------------------------------------------------------------------
+
+def save_upload_temp(file: UploadFile) -> str:
+    suffix = os.path.splitext(file.filename)[-1] or ".jpg"
+    tmp    = tempfile.NamedTemporaryFile(delete=False, suffix=suffix)
+    tmp.write(file.file.read())
+    tmp.flush()
+    return tmp.name
+
+
+def numpy_to_b64(img_array: np.ndarray) -> str:
+    img_pil = Image.fromarray(img_array.astype(np.uint8))
+    buf     = io.BytesIO()
+    img_pil.save(buf, format="PNG")
+    return base64.b64encode(buf.getvalue()).decode("utf-8")
+
+
+def predict_with_backend(backend: str, tmp_path: str) -> dict:
+    if backend not in predictors:
+        # Give a specific error message explaining what to do
+        if backend in load_errors:
+            detail = (
+                f"Backend '{backend}' failed to load: {load_errors[backend]}. "
+                f"Run export_onnx.py first to generate ONNX models."
+            )
+        else:
+            detail = (
+                f"Backend '{backend}' is not available. "
+                f"Run export_onnx.py to generate ONNX models."
+            )
+        raise HTTPException(status_code=503, detail=detail)
+
+    t0     = time.time()
+    result = predictors[backend].predict(tmp_path)
+    result["latency_ms"] = round((time.time() - t0) * 1000, 2)
+    return result
+
+
+# ---------------------------------------------------------------------------
+# Pydantic response models
+# ---------------------------------------------------------------------------
+
+class PredictionResponse(BaseModel):
+    predicted_class   : str
+    confidence        : float
+    all_probabilities : dict
+    backend           : str
+    latency_ms        : float
+
+
+class GradCamResponse(BaseModel):
+    predicted_class   : str
+    confidence        : float
+    all_probabilities : dict
+    backend           : str
+    latency_ms        : float
+    gradcam_b64       : str
+    heatmap_b64       : str
+
+
+# ---------------------------------------------------------------------------
+# Routes
+# ---------------------------------------------------------------------------
+
+@app.get("/")
+async def serve_index():
+    index_path = os.path.join(STATIC_DIR, "index.html")
+    if not os.path.exists(index_path):
+        raise HTTPException(status_code=404, detail="static/index.html not found.")
+    return FileResponse(index_path)
+
+
+@app.get("/health")
+async def health():
+    return {
+        "status"          : "ok",
+        "loaded_backends" : list(predictors.keys()),
+        "failed_backends" : load_errors,   
+    }
+
+
+@app.get("/models/info")
+async def models_info():
+    meta_path = os.path.join(cfg["models"]["save_dir"], "model_metadata.json")
+    if not os.path.exists(meta_path):
+        raise HTTPException(status_code=404, detail="model_metadata.json not found.")
+    with open(meta_path) as f:
+        return json.load(f)
+
+
+@app.get("/benchmark")
+async def get_benchmark():
+    bench_path = os.path.join(cfg["models"]["onnx_dir"], "benchmark_results.json")
+    if not os.path.exists(bench_path):
+        raise HTTPException(
+            status_code=404,
+            detail="benchmark_results.json not found. Run export_onnx.py first.",
+        )
+    with open(bench_path) as f:
+        return json.load(f)
+
+
+@app.post("/predict", response_model=PredictionResponse)
+async def predict_tf(file: UploadFile = File(...)):
+    tmp = save_upload_temp(file)
+    try:
+        return predict_with_backend("tensorflow", tmp)
+    finally:
+        os.unlink(tmp)
+
+
+@app.post("/predict/onnx", response_model=PredictionResponse)
+async def predict_onnx_fp32(file: UploadFile = File(...)):
+    tmp = save_upload_temp(file)
+    try:
+        return predict_with_backend("onnx_fp32", tmp)
+    finally:
+        os.unlink(tmp)
+
+
+@app.post("/predict/dynamic", response_model=PredictionResponse)
+async def predict_dynamic(file: UploadFile = File(...)):
+    tmp = save_upload_temp(file)
+    try:
+        return predict_with_backend("onnx_dynamic", tmp)
+    finally:
+        os.unlink(tmp)
+
+
+@app.post("/predict/static", response_model=PredictionResponse)
+async def predict_static(file: UploadFile = File(...)):
+    tmp = save_upload_temp(file)
+    try:
+        return predict_with_backend("onnx_static", tmp)
+    finally:
+        os.unlink(tmp)
+
+
+@app.post("/predict/gradcam", response_model=GradCamResponse)
+async def predict_gradcam(file: UploadFile = File(...)):
+    if "tensorflow" not in predictors:
+        raise HTTPException(status_code=503, detail="TF model not loaded.")
+
+    tmp = save_upload_temp(file)
+    try:
+        t0      = time.time()
+        result  = predictors["tensorflow"].predict_with_gradcam(tmp)
+        latency = round((time.time() - t0) * 1000, 2)
+
+        gradcam_b64 = numpy_to_b64(result["gradcam_overlay"])
+        heatmap_b64 = numpy_to_b64(
+            cv2.applyColorMap(
+                np.uint8(255 * result["heatmap"]), cv2.COLORMAP_JET
+            )[:, :, ::-1]
+        )
+
+        return {
+            "predicted_class"  : result["predicted_class"],
+            "confidence"       : result["confidence"],
+            "all_probabilities": result["all_probabilities"],
+            "backend"          : result["backend"],
+            "latency_ms"       : latency,
+            "gradcam_b64"      : gradcam_b64,
+            "heatmap_b64"      : heatmap_b64,
+        }
+    finally:
+        os.unlink(tmp)
+
+
+# ---------------------------------------------------------------------------
+# Run
+# ---------------------------------------------------------------------------
+
+if __name__ == "__main__":
+    import uvicorn
+    api_cfg = cfg["api"]
+    uvicorn.run(
+        "main:app",
+        host   = api_cfg["host"],
+        port   = api_cfg["port"],
+        reload = api_cfg["reload"],
+    )

config.yaml

@@ -0,0 +1,47 @@
+project:
+  name: "Brain Tumor Classification"
+  version: "1.0.0"
+  seed: 42
+
+data:
+  train_dir: "./data/Training"
+  test_dir: "./data/Testing"
+  image_size: [150, 150]
+  batch_size: 16
+  validation_split: 0.2
+  classes: ["glioma", "meningioma", "notumor", "pituitary"]
+
+augmentation:
+  rotation_range: 15
+  width_shift_range: 0.1
+  height_shift_range: 0.1
+  zoom_range: 0.1
+  horizontal_flip: true
+  brightness_range: [0.9, 1.1]
+
+training:
+  epochs: 20
+  early_stopping_patience: 5
+  reduce_lr_patience: 3
+  reduce_lr_factor: 0.5
+  min_lr: 0.000001
+
+optuna:
+  n_trials: 10
+  direction: "maximize"
+
+models:
+  save_dir: "./saved_models"
+  onnx_dir: "./onnx_models"
+  logs_dir: "./logs"
+
+mlflow:
+  dagshub_username: "shoaib.shahriar01"
+  dagshub_token: "2df3bdfdd248ea99d5af9a5d3e485bfaf6ca7c81"
+  dagshub_repo: "brain-tumor-classification"
+  experiment_name: "Brain_Tumor_Classification"
+
+api:
+  host: "0.0.0.0"
+  port: 8000
+  reload: true

evaluate.py

@@ -0,0 +1,126 @@
+# evaluate.py — confusion matrix, classification report, per-class metrics
+
+import os
+import numpy as np
+import matplotlib.pyplot as plt
+import seaborn as sns
+import tensorflow as tf
+from sklearn.metrics import classification_report, confusion_matrix
+from utils import get_logger, load_config
+from src.data_loader import get_data_generators
+
+logger = get_logger("evaluate")
+
+
+def evaluate_model(model, test_data, class_names: list,
+                   model_name: str = "model", save_dir: str = "./logs"):
+    os.makedirs(save_dir, exist_ok=True)
+    logger.info(f"Evaluating {model_name} on test set ...")
+
+    # Reset generator so it always starts from the beginning
+    test_data.reset()
+
+    y_pred_prob = model.predict(test_data, verbose=1)
+    y_pred      = np.argmax(y_pred_prob, axis=1)
+    y_true      = test_data.classes
+
+    # Align lengths — generator may yield slightly more due to batch rounding
+    min_len = min(len(y_true), len(y_pred))
+    y_true  = y_true[:min_len]
+    y_pred  = y_pred[:min_len]
+
+    # Classification report
+    report = classification_report(y_true, y_pred, target_names=class_names, digits=4)
+    logger.info(f"\nClassification Report - {model_name}:\n{report}")
+
+    report_path = os.path.join(save_dir, f"{model_name}_report.txt")
+    with open(report_path, "w", encoding="utf-8") as f:
+        f.write(f"Classification Report - {model_name}\n")
+        f.write("=" * 60 + "\n")
+        f.write(report)
+    logger.info(f"Report saved -> {report_path}")
+
+    # Confusion matrix
+    cm = confusion_matrix(y_true, y_pred)
+    plt.figure(figsize=(8, 6))
+    sns.heatmap(
+        cm, annot=True, fmt="d", cmap="Blues",
+        xticklabels=class_names, yticklabels=class_names,
+        linewidths=0.5,
+    )
+    plt.title(f"Confusion Matrix - {model_name}")
+    plt.ylabel("True Label")
+    plt.xlabel("Predicted Label")
+    plt.tight_layout()
+
+    cm_path = os.path.join(save_dir, f"{model_name}_confusion_matrix.png")
+    plt.savefig(cm_path, dpi=100, bbox_inches="tight")
+    plt.show()
+    plt.close()
+    logger.info(f"Confusion matrix saved -> {cm_path}")
+
+    # Use sklearn accuracy (more reliable than model.evaluate on generators)
+    test_acc = float((y_pred == y_true).mean())
+    logger.info(f"{model_name} - Test accuracy: {test_acc:.4f}")
+
+    return {
+        "test_accuracy" : test_acc,
+        "y_true"        : y_true.tolist(),
+        "y_pred"        : y_pred.tolist(),
+    }
+
+
+def evaluate_all_models(models_dict: dict, test_data, class_names: list,
+                        save_dir: str = "./logs"):
+    results = {}
+    for name, model in models_dict.items():
+        safe_name     = name.lower().replace(" ", "_")
+        results[name] = evaluate_model(
+            model, test_data, class_names,
+            model_name=safe_name, save_dir=save_dir,
+        )
+
+    logger.info("\n" + "=" * 45)
+    logger.info(f"{'Model':<25} {'Test Acc':>10}")
+    logger.info("=" * 45)
+    for name, r in results.items():
+        logger.info(f"{name:<25} {r['test_accuracy']:>10.4f}")
+    logger.info("=" * 45)
+    return results
+
+
+# ---------------------------------------------------------------------------
+# Main
+# ---------------------------------------------------------------------------
+
+if __name__ == "__main__":
+    cfg = load_config("config.yaml")
+    _, _, test_data = get_data_generators(cfg)
+
+    class_names = cfg["data"]["classes"]
+    save_dir    = cfg["models"]["save_dir"]
+    logs_dir    = cfg["models"]["logs_dir"]
+    os.makedirs(logs_dir, exist_ok=True)
+
+    # Load best saved model
+    best_model_path = os.path.join(save_dir, "ft_best.h5")
+    if not os.path.exists(best_model_path):
+        logger.error(f"Model not found at {best_model_path}. Run train.py first.")
+        exit(1)
+
+    logger.info(f"Loading model from {best_model_path}")
+
+    # compile=False avoids optimizer state errors when loading
+    # MobileNetV2 or EfficientNetB0 models in TF 2.10
+    model = tf.keras.models.load_model(best_model_path, compile=False)
+    model.compile(
+        optimizer = "adam",
+        loss      = "categorical_crossentropy",
+        metrics   = ["accuracy"],
+    )
+
+    results = evaluate_model(
+        model, test_data, class_names,
+        model_name="best_model", save_dir=logs_dir,
+    )
+    logger.info("Evaluation complete.")

logs/api.log

@@ -0,0 +1,135 @@
+2026-04-01 00:27:54 | INFO | api | Loading models ...
+2026-04-01 00:27:54 | ERROR | api | Failed to load TF model: No file or directory found at ./saved_models\best_brain_tumor_model.h5
+2026-04-01 00:27:54 | INFO | api | onnx_fp32 loaded.
+2026-04-01 00:27:55 | WARNING | api | onnx_dynamic not available: [ONNXRuntimeError] : 9 : NOT_IMPLEMENTED : Could not find an implementation for ConvInteger(10) node with name 'mobilenet_transfer/mobilenetv2_1.00_224/Conv1/Conv2D_quant'
+2026-04-01 00:27:55 | INFO | api | onnx_static loaded.
+2026-04-01 00:27:55 | INFO | api | Loaded backends: ['onnx_fp32', 'onnx_static']
+2026-04-01 00:37:17 | INFO | api | Loading models ...
+2026-04-01 00:37:17 | ERROR | api | Failed to load TF model: No file or directory found at ./saved_models\best_brain_tumor_model.h5
+2026-04-01 00:37:17 | INFO | api | onnx_fp32 loaded.
+2026-04-01 00:37:17 | WARNING | api | onnx_dynamic not available: [ONNXRuntimeError] : 9 : NOT_IMPLEMENTED : Could not find an implementation for ConvInteger(10) node with name 'mobilenet_transfer/mobilenetv2_1.00_224/Conv1/Conv2D_quant'
+2026-04-01 00:37:17 | INFO | api | onnx_static loaded.
+2026-04-01 00:37:17 | INFO | api | Loaded backends: ['onnx_fp32', 'onnx_static']
+2026-04-01 00:42:17 | INFO | api | Loading models ...
+2026-04-01 00:42:19 | INFO | api | TF model loaded.
+2026-04-01 00:42:19 | INFO | api | onnx_fp32 loaded.
+2026-04-01 00:42:19 | WARNING | api | onnx_dynamic not available: [ONNXRuntimeError] : 9 : NOT_IMPLEMENTED : Could not find an implementation for ConvInteger(10) node with name 'mobilenet_transfer/mobilenetv2_1.00_224/Conv1/Conv2D_quant'
+2026-04-01 00:42:19 | INFO | api | onnx_static loaded.
+2026-04-01 00:42:19 | INFO | api | Loaded backends: ['tensorflow', 'onnx_fp32', 'onnx_static']
+2026-04-01 00:50:24 | INFO | api | Loading models ...
+2026-04-01 00:50:26 | INFO | api | TF model loaded.
+2026-04-01 00:50:26 | INFO | api | onnx_fp32 loaded.
+2026-04-01 00:50:26 | WARNING | api | onnx_dynamic not available: [ONNXRuntimeError] : 9 : NOT_IMPLEMENTED : Could not find an implementation for ConvInteger(10) node with name 'mobilenet_transfer/mobilenetv2_1.00_224/Conv1/Conv2D_quant'
+2026-04-01 00:50:26 | INFO | api | onnx_static loaded.
+2026-04-01 00:50:26 | INFO | api | Loaded backends: ['tensorflow', 'onnx_fp32', 'onnx_static']
+2026-04-01 00:53:52 | INFO | api | Loading models ...
+2026-04-01 00:53:53 | INFO | api | TF model loaded.
+2026-04-01 00:53:53 | INFO | api | onnx_fp32 loaded.
+2026-04-01 00:53:53 | WARNING | api | onnx_dynamic not available: [ONNXRuntimeError] : 9 : NOT_IMPLEMENTED : Could not find an implementation for ConvInteger(10) node with name 'mobilenet_transfer/mobilenetv2_1.00_224/Conv1/Conv2D_quant'
+2026-04-01 00:53:53 | INFO | api | onnx_static loaded.
+2026-04-01 00:53:53 | INFO | api | Loaded backends: ['tensorflow', 'onnx_fp32', 'onnx_static']
+2026-04-01 00:54:31 | INFO | api | Loading models ...
+2026-04-01 00:54:32 | INFO | api | TF model loaded.
+2026-04-01 00:54:32 | INFO | api | onnx_fp32 loaded.
+2026-04-01 00:54:32 | WARNING | api | onnx_dynamic not available: [ONNXRuntimeError] : 9 : NOT_IMPLEMENTED : Could not find an implementation for ConvInteger(10) node with name 'mobilenet_transfer/mobilenetv2_1.00_224/Conv1/Conv2D_quant'
+2026-04-01 00:54:32 | INFO | api | onnx_static loaded.
+2026-04-01 00:54:32 | INFO | api | Loaded backends: ['tensorflow', 'onnx_fp32', 'onnx_static']
+2026-04-01 00:56:42 | INFO | api | Loading models ...
+2026-04-01 00:56:44 | INFO | api | TF model loaded.
+2026-04-01 00:56:44 | INFO | api | onnx_fp32 loaded.
+2026-04-01 00:56:44 | WARNING | api | onnx_dynamic not available: [ONNXRuntimeError] : 9 : NOT_IMPLEMENTED : Could not find an implementation for ConvInteger(10) node with name 'mobilenet_transfer/mobilenetv2_1.00_224/Conv1/Conv2D_quant'
+2026-04-01 00:56:44 | INFO | api | onnx_static loaded.
+2026-04-01 00:56:44 | INFO | api | Loaded backends: ['tensorflow', 'onnx_fp32', 'onnx_static']
+2026-04-01 00:59:49 | INFO | api | Loading models ...
+2026-04-01 00:59:51 | INFO | api | TF model loaded.
+2026-04-01 00:59:51 | INFO | api | onnx_fp32 loaded.
+2026-04-01 00:59:51 | WARNING | api | onnx_dynamic not available: [ONNXRuntimeError] : 9 : NOT_IMPLEMENTED : Could not find an implementation for ConvInteger(10) node with name 'mobilenet_transfer/mobilenetv2_1.00_224/Conv1/Conv2D_quant'
+2026-04-01 00:59:51 | INFO | api | onnx_static loaded.
+2026-04-01 00:59:51 | INFO | api | Loaded backends: ['tensorflow', 'onnx_fp32', 'onnx_static']
+2026-04-01 01:00:17 | INFO | api | Loading models ...
+2026-04-01 01:00:18 | INFO | api | TF model loaded.
+2026-04-01 01:00:18 | INFO | api | onnx_fp32 loaded.
+2026-04-01 01:00:18 | WARNING | api | onnx_dynamic not available: [ONNXRuntimeError] : 9 : NOT_IMPLEMENTED : Could not find an implementation for ConvInteger(10) node with name 'mobilenet_transfer/mobilenetv2_1.00_224/Conv1/Conv2D_quant'
+2026-04-01 01:00:18 | INFO | api | onnx_static loaded.
+2026-04-01 01:00:18 | INFO | api | Loaded backends: ['tensorflow', 'onnx_fp32', 'onnx_static']
+2026-04-01 01:01:53 | INFO | api | Loading models ...
+2026-04-01 01:01:54 | INFO | api | TF model loaded.
+2026-04-01 01:01:54 | INFO | api | onnx_fp32 loaded.
+2026-04-01 01:01:55 | WARNING | api | onnx_dynamic not available: [ONNXRuntimeError] : 9 : NOT_IMPLEMENTED : Could not find an implementation for ConvInteger(10) node with name 'mobilenet_transfer/mobilenetv2_1.00_224/Conv1/Conv2D_quant'
+2026-04-01 01:01:55 | INFO | api | onnx_static loaded.
+2026-04-01 01:01:55 | INFO | api | Loaded backends: ['tensorflow', 'onnx_fp32', 'onnx_static']
+2026-04-01 11:18:47 | INFO | api | [OK] tensorflow loaded.
+2026-04-01 11:18:47 | INFO | api | [OK] onnx_fp32 loaded.
+2026-04-01 11:18:47 | ERROR | api | [FAIL] onnx_dynamic failed to load: [ONNXRuntimeError] : 9 : NOT_IMPLEMENTED : Could not find an implementation for ConvInteger(10) node with name 'mobilenet_transfer/mobilenetv2_1.00_224/Conv1/Conv2D_quant'
+2026-04-01 11:18:47 | INFO | api | [OK] onnx_static loaded.
+2026-04-01 11:18:47 | INFO | api | Loaded backends  : ['tensorflow', 'onnx_fp32', 'onnx_static']
+2026-04-01 11:18:47 | WARNING | api | Failed backends  : ['onnx_dynamic']
+2026-04-01 11:18:47 | WARNING | api |   onnx_dynamic: [ONNXRuntimeError] : 9 : NOT_IMPLEMENTED : Could not find an implementation for ConvInteger(10) node with name 'mobilenet_transfer/mobilenetv2_1.00_224/Conv1/Conv2D_quant'
+2026-04-01 11:19:01 | INFO | api | [OK] tensorflow loaded.
+2026-04-01 11:19:01 | INFO | api | [OK] onnx_fp32 loaded.
+2026-04-01 11:19:01 | ERROR | api | [FAIL] onnx_dynamic failed to load: [ONNXRuntimeError] : 9 : NOT_IMPLEMENTED : Could not find an implementation for ConvInteger(10) node with name 'mobilenet_transfer/mobilenetv2_1.00_224/Conv1/Conv2D_quant'
+2026-04-01 11:19:01 | INFO | api | [OK] onnx_static loaded.
+2026-04-01 11:19:01 | INFO | api | Loaded backends  : ['tensorflow', 'onnx_fp32', 'onnx_static']
+2026-04-01 11:19:01 | WARNING | api | Failed backends  : ['onnx_dynamic']
+2026-04-01 11:19:01 | WARNING | api |   onnx_dynamic: [ONNXRuntimeError] : 9 : NOT_IMPLEMENTED : Could not find an implementation for ConvInteger(10) node with name 'mobilenet_transfer/mobilenetv2_1.00_224/Conv1/Conv2D_quant'
+2026-04-01 11:20:15 | INFO | api | [OK] tensorflow loaded.
+2026-04-01 11:20:15 | INFO | api | [OK] onnx_fp32 loaded.
+2026-04-01 11:20:15 | ERROR | api | [FAIL] onnx_dynamic failed to load: [ONNXRuntimeError] : 9 : NOT_IMPLEMENTED : Could not find an implementation for ConvInteger(10) node with name 'mobilenet_transfer/mobilenetv2_1.00_224/Conv1/Conv2D_quant'
+2026-04-01 11:20:15 | INFO | api | [OK] onnx_static loaded.
+2026-04-01 11:20:15 | INFO | api | Loaded backends  : ['tensorflow', 'onnx_fp32', 'onnx_static']
+2026-04-01 11:20:15 | WARNING | api | Failed backends  : ['onnx_dynamic']
+2026-04-01 11:20:15 | WARNING | api |   onnx_dynamic: [ONNXRuntimeError] : 9 : NOT_IMPLEMENTED : Could not find an implementation for ConvInteger(10) node with name 'mobilenet_transfer/mobilenetv2_1.00_224/Conv1/Conv2D_quant'
+2026-04-01 11:20:41 | INFO | api | Loading models ...
+2026-04-01 11:20:43 | INFO | api | TF model loaded.
+2026-04-01 11:20:43 | INFO | api | onnx_fp32 loaded.
+2026-04-01 11:20:43 | WARNING | api | onnx_dynamic not available: [ONNXRuntimeError] : 9 : NOT_IMPLEMENTED : Could not find an implementation for ConvInteger(10) node with name 'mobilenet_transfer/mobilenetv2_1.00_224/Conv1/Conv2D_quant'
+2026-04-01 11:20:43 | INFO | api | onnx_static loaded.
+2026-04-01 11:20:43 | INFO | api | Loaded backends: ['tensorflow', 'onnx_fp32', 'onnx_static']
+2026-04-01 11:20:59 | INFO | api | Loading models ...
+2026-04-01 11:21:01 | INFO | api | TF model loaded.
+2026-04-01 11:21:01 | INFO | api | onnx_fp32 loaded.
+2026-04-01 11:21:01 | WARNING | api | onnx_dynamic not available: [ONNXRuntimeError] : 9 : NOT_IMPLEMENTED : Could not find an implementation for ConvInteger(10) node with name 'mobilenet_transfer/mobilenetv2_1.00_224/Conv1/Conv2D_quant'
+2026-04-01 11:21:01 | INFO | api | onnx_static loaded.
+2026-04-01 11:21:01 | INFO | api | Loaded backends: ['tensorflow', 'onnx_fp32', 'onnx_static']
+2026-04-01 11:28:21 | INFO | api | Loading models ...
+2026-04-01 11:28:22 | INFO | api | [OK] TF model loaded.
+2026-04-01 11:28:22 | INFO | api | [OK] onnx_fp32 loaded.
+2026-04-01 11:28:23 | ERROR | api | [FAIL] onnx_dynamic failed: [ONNXRuntimeError] : 9 : NOT_IMPLEMENTED : Could not find an implementation for ConvInteger(10) node with name 'mobilenet_transfer/mobilenetv2_1.00_224/Conv1/Conv2D_quant'
+2026-04-01 11:28:23 | INFO | api | [OK] onnx_static loaded.
+2026-04-01 11:28:23 | INFO | api | Loaded backends : ['tensorflow', 'onnx_fp32', 'onnx_static']
+2026-04-01 11:28:23 | WARNING | api | Failed backends : ['onnx_dynamic']
+2026-04-01 11:28:29 | INFO | api | Loading models ...
+2026-04-01 11:28:31 | INFO | api | [OK] TF model loaded.
+2026-04-01 11:28:31 | INFO | api | [OK] onnx_fp32 loaded.
+2026-04-01 11:28:31 | ERROR | api | [FAIL] onnx_dynamic failed: [ONNXRuntimeError] : 9 : NOT_IMPLEMENTED : Could not find an implementation for ConvInteger(10) node with name 'mobilenet_transfer/mobilenetv2_1.00_224/Conv1/Conv2D_quant'
+2026-04-01 11:28:31 | INFO | api | [OK] onnx_static loaded.
+2026-04-01 11:28:31 | INFO | api | Loaded backends : ['tensorflow', 'onnx_fp32', 'onnx_static']
+2026-04-01 11:28:31 | WARNING | api | Failed backends : ['onnx_dynamic']
+2026-04-01 11:28:38 | INFO | api | Loading models ...
+2026-04-01 11:28:40 | INFO | api | [OK] TF model loaded.
+2026-04-01 11:28:40 | INFO | api | [OK] onnx_fp32 loaded.
+2026-04-01 11:28:40 | ERROR | api | [FAIL] onnx_dynamic failed: [ONNXRuntimeError] : 9 : NOT_IMPLEMENTED : Could not find an implementation for ConvInteger(10) node with name 'mobilenet_transfer/mobilenetv2_1.00_224/Conv1/Conv2D_quant'
+2026-04-01 11:28:40 | INFO | api | [OK] onnx_static loaded.
+2026-04-01 11:28:40 | INFO | api | Loaded backends : ['tensorflow', 'onnx_fp32', 'onnx_static']
+2026-04-01 11:28:40 | WARNING | api | Failed backends : ['onnx_dynamic']
+2026-04-01 11:46:37 | INFO | api | Loading models ...
+2026-04-01 11:46:39 | INFO | api | [OK] TF model loaded.
+2026-04-01 11:46:39 | INFO | api | [OK] onnx_fp32 loaded.
+2026-04-01 11:46:39 | ERROR | api | [FAIL] onnx_dynamic failed: ONNX Dynamic INT8 model is not supported in this ONNX Runtime build: [ONNXRuntimeError] : 9 : NOT_IMPLEMENTED : Could not find an implementation for ConvInteger(10) node with name 'mobilenet_transfer/mobilenetv2_1.00_224/Conv1/Conv2D_quant'
+2026-04-01 11:46:39 | INFO | api | [OK] onnx_static loaded.
+2026-04-01 11:46:39 | INFO | api | Loaded backends : ['tensorflow', 'onnx_fp32', 'onnx_static']
+2026-04-01 11:46:39 | WARNING | api | Failed backends : ['onnx_dynamic']
+2026-04-01 11:51:09 | INFO | api | Loading models ...
+2026-04-01 11:51:10 | INFO | api | [OK] TF model loaded.
+2026-04-01 11:51:10 | INFO | api | [OK] onnx_fp32 loaded.
+2026-04-01 11:51:10 | ERROR | api | [FAIL] onnx_dynamic failed: ONNX Dynamic INT8 model is not supported in this ONNX Runtime build: [ONNXRuntimeError] : 9 : NOT_IMPLEMENTED : Could not find an implementation for ConvInteger(10) node with name 'mobilenet_transfer/mobilenetv2_1.00_224/Conv1/Conv2D_quant'
+2026-04-01 11:51:10 | INFO | api | [OK] onnx_static loaded.
+2026-04-01 11:51:10 | INFO | api | Loaded backends : ['tensorflow', 'onnx_fp32', 'onnx_static']
+2026-04-01 11:51:10 | WARNING | api | Failed backends : ['onnx_dynamic']
+2026-04-01 12:06:18 | INFO | api | Loading models ...
+2026-04-01 12:06:20 | INFO | api | [OK] TF model loaded.
+2026-04-01 12:06:20 | INFO | api | [OK] onnx_fp32 loaded.
+2026-04-01 12:06:20 | ERROR | api | [FAIL] onnx_dynamic failed: ONNX Dynamic INT8 model is not supported in this ONNX Runtime build: [ONNXRuntimeError] : 9 : NOT_IMPLEMENTED : Could not find an implementation for ConvInteger(10) node with name 'mobilenet_transfer/mobilenetv2_1.00_224/Conv1/Conv2D_quant'
+2026-04-01 12:06:20 | INFO | api | [OK] onnx_static loaded.
+2026-04-01 12:06:20 | INFO | api | Loaded backends : ['tensorflow', 'onnx_fp32', 'onnx_static']
+2026-04-01 12:06:20 | WARNING | api | Failed backends : ['onnx_dynamic']

logs/best_model_report.txt

@@ -0,0 +1,12 @@
+Classification Report � best_model
+============================================================
+              precision    recall  f1-score   support
+
+      glioma     0.9444    0.7225    0.8187       400
+  meningioma     0.8414    0.7825    0.8109       400
+     notumor     0.9045    0.9950    0.9476       400
+   pituitary     0.8237    0.9925    0.9002       400
+
+    accuracy                         0.8731      1600
+   macro avg     0.8785    0.8731    0.8694      1600
+weighted avg     0.8785    0.8731    0.8694      1600

logs/data_loader.log

@@ -0,0 +1,92 @@
+2026-03-31 12:45:57 | INFO | data_loader | Train samples : 4480
+2026-03-31 12:45:57 | INFO | data_loader | Val samples   : 1120
+2026-03-31 12:45:57 | INFO | data_loader | Test samples  : 1600
+2026-03-31 12:45:57 | INFO | data_loader | Classes       : {'glioma': 0, 'meningioma': 1, 'notumor': 2, 'pituitary': 3}
+2026-03-31 15:59:57 | INFO | data_loader | Train samples : 4480
+2026-03-31 15:59:57 | INFO | data_loader | Val samples   : 1120
+2026-03-31 15:59:57 | INFO | data_loader | Test samples  : 1600
+2026-03-31 15:59:57 | INFO | data_loader | Classes       : {'glioma': 0, 'meningioma': 1, 'notumor': 2, 'pituitary': 3}
+2026-03-31 16:43:07 | INFO | data_loader | Train samples : 4480
+2026-03-31 16:43:07 | INFO | data_loader | Val samples   : 1120
+2026-03-31 16:43:07 | INFO | data_loader | Test samples  : 1600
+2026-03-31 16:43:07 | INFO | data_loader | Classes       : {'glioma': 0, 'meningioma': 1, 'notumor': 2, 'pituitary': 3}
+2026-03-31 17:36:33 | INFO | data_loader | Train samples : 4480
+2026-03-31 17:36:33 | INFO | data_loader | Val samples   : 1120
+2026-03-31 17:36:33 | INFO | data_loader | Test samples  : 1600
+2026-03-31 17:36:33 | INFO | data_loader | Classes       : {'glioma': 0, 'meningioma': 1, 'notumor': 2, 'pituitary': 3}
+2026-03-31 20:07:21 | INFO | data_loader | Train samples : 4480
+2026-03-31 20:07:21 | INFO | data_loader | Val samples   : 1120
+2026-03-31 20:07:21 | INFO | data_loader | Test samples  : 1600
+2026-03-31 20:07:21 | INFO | data_loader | Classes       : {'glioma': 0, 'meningioma': 1, 'notumor': 2, 'pituitary': 3}
+2026-03-31 20:34:10 | INFO | data_loader | Train samples : 4480
+2026-03-31 20:34:10 | INFO | data_loader | Val samples   : 1120
+2026-03-31 20:34:10 | INFO | data_loader | Test samples  : 1600
+2026-03-31 20:34:10 | INFO | data_loader | Classes       : {'glioma': 0, 'meningioma': 1, 'notumor': 2, 'pituitary': 3}
+2026-03-31 21:12:50 | INFO | data_loader | Train samples : 4480
+2026-03-31 21:12:50 | INFO | data_loader | Val samples   : 1120
+2026-03-31 21:12:50 | INFO | data_loader | Test samples  : 1600
+2026-03-31 21:12:50 | INFO | data_loader | Classes       : {'glioma': 0, 'meningioma': 1, 'notumor': 2, 'pituitary': 3}
+2026-03-31 23:02:54 | INFO | data_loader | Train samples : 4480
+2026-03-31 23:02:54 | INFO | data_loader | Val samples   : 1120
+2026-03-31 23:02:54 | INFO | data_loader | Test samples  : 1600
+2026-03-31 23:02:54 | INFO | data_loader | Classes       : {'glioma': 0, 'meningioma': 1, 'notumor': 2, 'pituitary': 3}
+2026-03-31 23:05:49 | INFO | data_loader | Train samples : 4480
+2026-03-31 23:05:49 | INFO | data_loader | Val samples   : 1120
+2026-03-31 23:05:49 | INFO | data_loader | Test samples  : 1600
+2026-03-31 23:05:49 | INFO | data_loader | Classes       : {'glioma': 0, 'meningioma': 1, 'notumor': 2, 'pituitary': 3}
+2026-03-31 23:12:49 | INFO | data_loader | Train samples : 4480
+2026-03-31 23:12:49 | INFO | data_loader | Val samples   : 1120
+2026-03-31 23:12:49 | INFO | data_loader | Test samples  : 1600
+2026-03-31 23:12:49 | INFO | data_loader | Classes       : {'glioma': 0, 'meningioma': 1, 'notumor': 2, 'pituitary': 3}
+2026-03-31 23:13:36 | INFO | data_loader | Train samples : 4480
+2026-03-31 23:13:36 | INFO | data_loader | Val samples   : 1120
+2026-03-31 23:13:36 | INFO | data_loader | Test samples  : 1600
+2026-03-31 23:13:36 | INFO | data_loader | Classes       : {'glioma': 0, 'meningioma': 1, 'notumor': 2, 'pituitary': 3}
+2026-03-31 23:47:29 | INFO | data_loader | Train samples : 4480
+2026-03-31 23:47:29 | INFO | data_loader | Val samples   : 1120
+2026-03-31 23:47:29 | INFO | data_loader | Test samples  : 1600
+2026-03-31 23:47:29 | INFO | data_loader | Classes       : {'glioma': 0, 'meningioma': 1, 'notumor': 2, 'pituitary': 3}
+2026-03-31 23:48:32 | INFO | data_loader | Train samples : 4480
+2026-03-31 23:48:32 | INFO | data_loader | Val samples   : 1120
+2026-03-31 23:48:32 | INFO | data_loader | Test samples  : 1600
+2026-03-31 23:48:32 | INFO | data_loader | Classes       : {'glioma': 0, 'meningioma': 1, 'notumor': 2, 'pituitary': 3}
+2026-03-31 23:48:45 | INFO | data_loader | Train samples : 4480
+2026-03-31 23:48:45 | INFO | data_loader | Val samples   : 1120
+2026-03-31 23:48:45 | INFO | data_loader | Test samples  : 1600
+2026-03-31 23:48:45 | INFO | data_loader | Classes       : {'glioma': 0, 'meningioma': 1, 'notumor': 2, 'pituitary': 3}
+2026-03-31 23:51:06 | INFO | data_loader | Train samples : 4480
+2026-03-31 23:51:06 | INFO | data_loader | Val samples   : 1120
+2026-03-31 23:51:06 | INFO | data_loader | Test samples  : 1600
+2026-03-31 23:51:06 | INFO | data_loader | Classes       : {'glioma': 0, 'meningioma': 1, 'notumor': 2, 'pituitary': 3}
+2026-04-01 00:13:41 | INFO | data_loader | Train samples : 4480
+2026-04-01 00:13:41 | INFO | data_loader | Val samples   : 1120
+2026-04-01 00:13:41 | INFO | data_loader | Test samples  : 1600
+2026-04-01 00:13:41 | INFO | data_loader | Classes       : {'glioma': 0, 'meningioma': 1, 'notumor': 2, 'pituitary': 3}
+2026-04-01 00:14:18 | INFO | data_loader | Train samples : 4480
+2026-04-01 00:14:18 | INFO | data_loader | Val samples   : 1120
+2026-04-01 00:14:18 | INFO | data_loader | Test samples  : 1600
+2026-04-01 00:14:18 | INFO | data_loader | Classes       : {'glioma': 0, 'meningioma': 1, 'notumor': 2, 'pituitary': 3}
+2026-04-01 00:20:40 | INFO | data_loader | Train samples : 4480
+2026-04-01 00:20:40 | INFO | data_loader | Val samples   : 1120
+2026-04-01 00:20:40 | INFO | data_loader | Test samples  : 1600
+2026-04-01 00:20:40 | INFO | data_loader | Classes       : {'glioma': 0, 'meningioma': 1, 'notumor': 2, 'pituitary': 3}
+2026-04-01 00:21:49 | INFO | data_loader | Train samples : 4480
+2026-04-01 00:21:49 | INFO | data_loader | Val samples   : 1120
+2026-04-01 00:21:49 | INFO | data_loader | Test samples  : 1600
+2026-04-01 00:21:49 | INFO | data_loader | Classes       : {'glioma': 0, 'meningioma': 1, 'notumor': 2, 'pituitary': 3}
+2026-04-01 11:32:15 | INFO | data_loader | Train samples : 4480
+2026-04-01 11:32:15 | INFO | data_loader | Val samples   : 1120
+2026-04-01 11:32:15 | INFO | data_loader | Test samples  : 1600
+2026-04-01 11:32:15 | INFO | data_loader | Classes       : {'glioma': 0, 'meningioma': 1, 'notumor': 2, 'pituitary': 3}
+2026-04-01 11:35:30 | INFO | data_loader | Train samples : 4480
+2026-04-01 11:35:30 | INFO | data_loader | Val samples   : 1120
+2026-04-01 11:35:30 | INFO | data_loader | Test samples  : 1600
+2026-04-01 11:35:30 | INFO | data_loader | Classes       : {'glioma': 0, 'meningioma': 1, 'notumor': 2, 'pituitary': 3}
+2026-04-01 11:45:39 | INFO | data_loader | Train samples : 4480
+2026-04-01 11:45:39 | INFO | data_loader | Val samples   : 1120
+2026-04-01 11:45:39 | INFO | data_loader | Test samples  : 1600
+2026-04-01 11:45:39 | INFO | data_loader | Classes       : {'glioma': 0, 'meningioma': 1, 'notumor': 2, 'pituitary': 3}
+2026-04-01 11:50:04 | INFO | data_loader | Train samples : 4480
+2026-04-01 11:50:04 | INFO | data_loader | Val samples   : 1120
+2026-04-01 11:50:04 | INFO | data_loader | Test samples  : 1600
+2026-04-01 11:50:04 | INFO | data_loader | Classes       : {'glioma': 0, 'meningioma': 1, 'notumor': 2, 'pituitary': 3}

logs/evaluate.log

@@ -0,0 +1,58 @@
+2026-03-31 23:02:54 | ERROR | evaluate | Model not found at ./saved_models\best_brain_tumor_model.h5. Run train.py first.
+2026-03-31 23:05:49 | INFO | evaluate | Loading model from ./saved_models\ft_best.h5
+2026-03-31 23:05:51 | INFO | evaluate | Evaluating best_model on test set ...
+2026-03-31 23:06:06 | INFO | evaluate | 
+Classification Report — best_model:
+              precision    recall  f1-score   support
+
+      glioma     0.2484    0.1900    0.2153       400
+  meningioma     0.2554    0.2375    0.2461       400
+     notumor     0.2568    0.2825    0.2690       400
+   pituitary     0.2759    0.3325    0.3016       400
+
+    accuracy                         0.2606      1600
+   macro avg     0.2591    0.2606    0.2580      1600
+weighted avg     0.2591    0.2606    0.2580      1600
+
+2026-03-31 23:06:06 | INFO | evaluate | Report saved → ./logs\best_model_report.txt
+2026-03-31 23:06:53 | INFO | evaluate | Confusion matrix saved → ./logs\best_model_confusion_matrix.png
+2026-03-31 23:06:56 | INFO | evaluate | best_model — Test accuracy: 0.8731 | Test loss: 0.5124
+2026-03-31 23:06:56 | INFO | evaluate | Evaluation complete.
+2026-03-31 23:12:49 | INFO | evaluate | Loading model from ./saved_models\ft_best.h5
+2026-03-31 23:12:51 | INFO | evaluate | Evaluating best_model on test set ...
+2026-03-31 23:12:57 | INFO | evaluate | 
+Classification Report — best_model:
+              precision    recall  f1-score   support
+
+      glioma     0.2320    0.1775    0.2011       400
+  meningioma     0.2500    0.2325    0.2409       400
+     notumor     0.2409    0.2650    0.2524       400
+   pituitary     0.2676    0.3225    0.2925       400
+
+    accuracy                         0.2494      1600
+   macro avg     0.2476    0.2494    0.2467      1600
+weighted avg     0.2476    0.2494    0.2467      1600
+
+2026-03-31 23:12:57 | INFO | evaluate | Report saved → ./logs\best_model_report.txt
+2026-03-31 23:13:00 | INFO | evaluate | Confusion matrix saved → ./logs\best_model_confusion_matrix.png
+2026-03-31 23:13:03 | INFO | evaluate | best_model — Test accuracy: 0.8731 | Test loss: 0.5124
+2026-03-31 23:13:03 | INFO | evaluate | Evaluation complete.
+2026-03-31 23:13:36 | INFO | evaluate | Loading model from ./saved_models\ft_best.h5
+2026-03-31 23:13:38 | INFO | evaluate | Evaluating best_model on test set ...
+2026-03-31 23:13:44 | INFO | evaluate | 
+Classification Report — best_model:
+              precision    recall  f1-score   support
+
+      glioma     0.9444    0.7225    0.8187       400
+  meningioma     0.8414    0.7825    0.8109       400
+     notumor     0.9045    0.9950    0.9476       400
+   pituitary     0.8237    0.9925    0.9002       400
+
+    accuracy                         0.8731      1600
+   macro avg     0.8785    0.8731    0.8694      1600
+weighted avg     0.8785    0.8731    0.8694      1600
+
+2026-03-31 23:13:44 | INFO | evaluate | Report saved → ./logs\best_model_report.txt
+2026-03-31 23:13:46 | INFO | evaluate | Confusion matrix saved → ./logs\best_model_confusion_matrix.png
+2026-03-31 23:13:49 | INFO | evaluate | best_model — Test accuracy: 0.8731 | Test loss: 0.5124
+2026-03-31 23:13:49 | INFO | evaluate | Evaluation complete.

logs/export_onnx.log

@@ -0,0 +1,88 @@
+2026-03-31 23:47:29 | INFO | export_onnx | Loading model from ./saved_models\best_brain_tumor_model.h5
+2026-03-31 23:48:32 | INFO | export_onnx | Loading model from ./saved_models\ft_best.h5
+2026-03-31 23:48:45 | INFO | export_onnx | Loading model from ./saved_models\ft_best.h5
+2026-03-31 23:51:06 | INFO | export_onnx | Loading model from ./saved_models\ft_best.h5
+2026-04-01 00:13:41 | INFO | export_onnx | Loading model from ./saved_models\ft_best.h5
+2026-04-01 00:13:43 | INFO | export_onnx | Exporting model to ONNX → ./onnx_models\model_fp32.onnx
+2026-04-01 00:13:48 | INFO | export_onnx | ONNX export successful — size: 9.14 MB
+2026-04-01 00:13:48 | WARNING | export_onnx | Dynamic quantization skipped: No module named 'onnx.reference'
+2026-04-01 00:13:48 | WARNING | export_onnx | Static quantization skipped: No module named 'onnx.reference'
+2026-04-01 00:13:48 | INFO | export_onnx | 
+Benchmarking model formats ...
+2026-04-01 00:14:18 | INFO | export_onnx | Loading model from ./saved_models\ft_best.h5
+2026-04-01 00:14:19 | INFO | export_onnx | Exporting model to ONNX → ./onnx_models\model_fp32.onnx
+2026-04-01 00:14:25 | INFO | export_onnx | ONNX export successful — size: 9.14 MB
+2026-04-01 00:14:25 | WARNING | export_onnx | Dynamic quantization skipped: No module named 'onnx.reference'
+2026-04-01 00:14:25 | WARNING | export_onnx | Static quantization skipped: No module named 'onnx.reference'
+2026-04-01 00:14:25 | INFO | export_onnx | 
+Benchmarking model formats ...
+2026-04-01 00:14:28 | INFO | export_onnx | TensorFlow (FP32) | acc=0.7000 | 10.53 ms/sample
+2026-04-01 00:14:28 | INFO | export_onnx | ONNX FP32              | acc=0.7000 | 3.02 ms/sample | 9.14 MB
+2026-04-01 00:14:28 | WARNING | export_onnx | Skipping ONNX Dynamic INT8 — path is None
+2026-04-01 00:14:28 | WARNING | export_onnx | Skipping ONNX Static INT8 — path is None
+2026-04-01 00:14:29 | INFO | export_onnx | Benchmark results saved → ./onnx_models\benchmark_results.json
+2026-04-01 00:14:29 | WARNING | export_onnx | ONNX export complete. Quantization skipped: No module named 'onnx.reference'
+2026-04-01 00:20:40 | INFO | export_onnx | Loading model from ./saved_models\ft_best.h5
+2026-04-01 00:20:42 | INFO | export_onnx | Exporting model to ONNX → ./onnx_models\model_fp32.onnx
+2026-04-01 00:20:48 | INFO | export_onnx | ONNX export successful — size: 9.10 MB
+2026-04-01 00:20:48 | INFO | export_onnx | Applying Dynamic Quantization → ./onnx_models\model_dynamic_int8.onnx
+2026-04-01 00:21:49 | INFO | export_onnx | Loading model from ./saved_models\ft_best.h5
+2026-04-01 00:21:51 | INFO | export_onnx | Exporting model to ONNX → ./onnx_models\model_fp32.onnx
+2026-04-01 00:21:57 | INFO | export_onnx | ONNX export successful — size: 9.10 MB
+2026-04-01 00:21:57 | INFO | export_onnx | Applying Dynamic Quantization → ./onnx_models\model_dynamic_int8.onnx
+2026-04-01 00:21:57 | INFO | export_onnx | Dynamic quantized model — size: 2.50 MB
+2026-04-01 00:21:57 | INFO | export_onnx | Applying Static Quantization → ./onnx_models\model_static_int8.onnx
+2026-04-01 00:21:59 | INFO | export_onnx | Calibration reader: 10 batches loaded
+2026-04-01 00:22:02 | INFO | export_onnx | Static quantized model — size: 2.51 MB
+2026-04-01 00:22:02 | INFO | export_onnx | 
+Benchmarking model formats ...
+2026-04-01 00:22:04 | INFO | export_onnx | TensorFlow (FP32) | acc=0.7000 | 9.38 ms/sample
+2026-04-01 00:22:05 | INFO | export_onnx | ONNX FP32                | acc=0.7000 | 5.42 ms/sample | 9.10 MB
+2026-04-01 11:32:15 | INFO | export_onnx | Loading model from ./saved_models\ft_best.h5
+2026-04-01 11:32:17 | INFO | export_onnx | Exporting model to ONNX → ./onnx_models\model_fp32.onnx
+2026-04-01 11:32:23 | INFO | export_onnx | ONNX export successful — size: 9.10 MB
+2026-04-01 11:32:23 | INFO | export_onnx | Applying Dynamic Quantization -> ./onnx_models\model_dynamic_int8.onnx
+2026-04-01 11:35:30 | INFO | export_onnx | Loading model from ./saved_models\ft_best.h5
+2026-04-01 11:35:32 | INFO | export_onnx | Exporting model to ONNX → ./onnx_models\model_fp32.onnx
+2026-04-01 11:35:37 | INFO | export_onnx | ONNX export successful — size: 9.10 MB
+2026-04-01 11:35:37 | INFO | export_onnx | Applying Dynamic Quantization → ./onnx_models\model_dynamic_int8.onnx
+2026-04-01 11:35:38 | INFO | export_onnx | Dynamic quantized model — size: 2.50 MB
+2026-04-01 11:35:38 | INFO | export_onnx | Applying Static Quantization → ./onnx_models\model_static_int8.onnx
+2026-04-01 11:35:40 | INFO | export_onnx | Calibration reader: 10 batches loaded
+2026-04-01 11:35:42 | INFO | export_onnx | Static quantized model — size: 2.51 MB
+2026-04-01 11:35:42 | INFO | export_onnx | 
+Benchmarking model formats ...
+2026-04-01 11:35:46 | INFO | export_onnx | TensorFlow (FP32) | acc=0.7000 | 9.62 ms/sample
+2026-04-01 11:35:47 | INFO | export_onnx | ONNX FP32                | acc=0.7000 | 5.07 ms/sample | 9.10 MB
+2026-04-01 11:45:39 | INFO | export_onnx | Loading model from ./saved_models\ft_best.h5
+2026-04-01 11:45:40 | INFO | export_onnx | Exporting model to ONNX → ./onnx_models\model_fp32.onnx
+2026-04-01 11:45:46 | INFO | export_onnx | ONNX export successful — size: 9.10 MB
+2026-04-01 11:45:46 | INFO | export_onnx | Applying Dynamic Quantization → ./onnx_models\model_dynamic_int8.onnx
+2026-04-01 11:45:47 | INFO | export_onnx | Dynamic quantized model — size: 2.50 MB
+2026-04-01 11:45:47 | INFO | export_onnx | Applying Static Quantization → ./onnx_models\model_static_int8.onnx
+2026-04-01 11:45:48 | INFO | export_onnx | Calibration reader: 10 batches loaded
+2026-04-01 11:45:51 | INFO | export_onnx | Static quantized model — size: 2.51 MB
+2026-04-01 11:45:51 | INFO | export_onnx | 
+Benchmarking model formats ...
+2026-04-01 11:45:53 | INFO | export_onnx | TensorFlow (FP32) | acc=0.7000 | 9.55 ms/sample
+2026-04-01 11:45:54 | INFO | export_onnx | ONNX FP32                | acc=0.7000 | 5.14 ms/sample | 9.10 MB
+2026-04-01 11:45:54 | WARNING | export_onnx | Skipping ONNX Dynamic INT8 due to runtime error: [ONNXRuntimeError] : 9 : NOT_IMPLEMENTED : Could not find an implementation for ConvInteger(10) node with name 'mobilenet_transfer/mobilenetv2_1.00_224/Conv1/Conv2D_quant'
+2026-04-01 11:45:55 | INFO | export_onnx | ONNX Static INT8         | acc=0.0050 | 4.53 ms/sample | 2.51 MB
+2026-04-01 11:45:55 | INFO | export_onnx | Benchmark results saved → ./onnx_models\benchmark_results.json
+2026-04-01 11:45:55 | INFO | export_onnx | ONNX export complete. Quantization attempted.
+2026-04-01 11:50:04 | INFO | export_onnx | Loading model from ./saved_models\ft_best.h5
+2026-04-01 11:50:06 | INFO | export_onnx | Exporting model to ONNX → ./onnx_models\model_fp32.onnx
+2026-04-01 11:50:11 | INFO | export_onnx | ONNX export successful — size: 9.10 MB
+2026-04-01 11:50:11 | INFO | export_onnx | Applying Dynamic Quantization → ./onnx_models\model_dynamic_int8.onnx
+2026-04-01 11:50:12 | INFO | export_onnx | Dynamic quantized model — size: 2.50 MB
+2026-04-01 11:50:12 | INFO | export_onnx | Applying Static Quantization → ./onnx_models\model_static_int8.onnx
+2026-04-01 11:50:19 | INFO | export_onnx | Calibration reader: 50 batches loaded
+2026-04-01 11:50:30 | INFO | export_onnx | Static quantized model — size: 2.51 MB
+2026-04-01 11:50:30 | INFO | export_onnx | 
+Benchmarking model formats ...
+2026-04-01 11:50:32 | INFO | export_onnx | TensorFlow (FP32) | acc=0.7000 | 9.15 ms/sample
+2026-04-01 11:50:33 | INFO | export_onnx | ONNX FP32                | acc=0.7000 | 5.29 ms/sample | 9.10 MB
+2026-04-01 11:50:33 | WARNING | export_onnx | Skipping ONNX Dynamic INT8 due to runtime error: [ONNXRuntimeError] : 9 : NOT_IMPLEMENTED : Could not find an implementation for ConvInteger(10) node with name 'mobilenet_transfer/mobilenetv2_1.00_224/Conv1/Conv2D_quant'
+2026-04-01 11:50:34 | INFO | export_onnx | ONNX Static INT8         | acc=0.0050 | 4.19 ms/sample | 2.51 MB
+2026-04-01 11:50:34 | INFO | export_onnx | Benchmark results saved → ./onnx_models\benchmark_results.json
+2026-04-01 11:50:34 | INFO | export_onnx | ONNX export complete. Quantization attempted.

logs/models.log

@@ -0,0 +1,48 @@
+2026-03-31 12:46:00 | INFO | models | Built Baseline CNN
+2026-03-31 12:57:32 | INFO | models | Built MobileNetV2 Transfer Learning model
+2026-03-31 13:08:18 | INFO | models | Fine-tuned MobileNetV2: last 20 layers unfrozen
+2026-03-31 13:13:19 | INFO | models | Built EfficientNetB0 Transfer Learning model
+2026-03-31 15:59:58 | INFO | models | Built Baseline CNN
+2026-03-31 16:11:02 | INFO | models | Built MobileNetV2 Transfer Learning model
+2026-03-31 16:22:01 | INFO | models | Fine-tuned MobileNetV2: last 20 layers unfrozen
+2026-03-31 16:27:01 | INFO | models | Built EfficientNetB0 Transfer Learning model
+2026-03-31 16:43:08 | INFO | models | Built Baseline CNN
+2026-03-31 16:53:39 | INFO | models | Built MobileNetV2 Transfer Learning model
+2026-03-31 17:04:25 | INFO | models | Fine-tuned MobileNetV2: last 20 layers unfrozen
+2026-03-31 17:09:23 | INFO | models | Built EfficientNetB0 Transfer Learning model
+2026-03-31 17:36:34 | INFO | models | Built Baseline CNN
+2026-03-31 17:47:07 | INFO | models | Built MobileNetV2 Transfer Learning model
+2026-03-31 17:54:34 | INFO | models | Fine-tuned MobileNetV2: last 20 layers unfrozen
+2026-03-31 18:03:37 | INFO | models | Built EfficientNetB0 Transfer Learning model
+2026-03-31 18:06:52 | INFO | models | Built Optuna CNN with params: {'filters_1': 32, 'filters_2': 64, 'filters_3': 256, 'dense_units': 128, 'dropout': 0.3528318576498196, 'lr': 0.0023163425192755226}
+2026-03-31 18:09:47 | INFO | models | Built Optuna CNN with params: {'filters_1': 64, 'filters_2': 128, 'filters_3': 128, 'dense_units': 256, 'dropout': 0.298909022597601, 'lr': 0.0012839511259207857}
+2026-03-31 18:13:54 | INFO | models | Built Optuna CNN with params: {'filters_1': 64, 'filters_2': 64, 'filters_3': 256, 'dense_units': 128, 'dropout': 0.29252720375744357, 'lr': 0.0001280007427686007}
+2026-03-31 18:19:00 | INFO | models | Built Optuna CNN with params: {'filters_1': 64, 'filters_2': 128, 'filters_3': 128, 'dense_units': 256, 'dropout': 0.4273282260839636, 'lr': 0.0011210111966337138}
+2026-03-31 18:23:41 | INFO | models | Built Optuna CNN with params: {'filters_1': 32, 'filters_2': 128, 'filters_3': 128, 'dense_units': 64, 'dropout': 0.22784649015605415, 'lr': 0.005766474167607917}
+2026-03-31 18:25:45 | INFO | models | Built Optuna CNN with params: {'filters_1': 64, 'filters_2': 128, 'filters_3': 256, 'dense_units': 64, 'dropout': 0.48880635124006017, 'lr': 0.0032352191388469636}
+2026-03-31 18:27:52 | INFO | models | Built Optuna CNN with params: {'filters_1': 64, 'filters_2': 128, 'filters_3': 128, 'dense_units': 64, 'dropout': 0.41843200212884657, 'lr': 0.00017082690675758604}
+2026-03-31 18:33:06 | INFO | models | Built Optuna CNN with params: {'filters_1': 32, 'filters_2': 64, 'filters_3': 256, 'dense_units': 64, 'dropout': 0.42332478729875544, 'lr': 0.004321482824942734}
+2026-03-31 18:35:11 | INFO | models | Built Optuna CNN with params: {'filters_1': 64, 'filters_2': 128, 'filters_3': 256, 'dense_units': 128, 'dropout': 0.35511716436262036, 'lr': 0.006308240405890077}
+2026-03-31 18:37:52 | INFO | models | Built Optuna CNN with params: {'filters_1': 64, 'filters_2': 128, 'filters_3': 128, 'dense_units': 256, 'dropout': 0.41542144036132356, 'lr': 0.00011919711923710529}
+2026-03-31 18:43:25 | INFO | models | Built Optuna CNN with params: {'filters_1': 64, 'filters_2': 128, 'filters_3': 128, 'dense_units': 256, 'dropout': 0.41542144036132356, 'lr': 0.00011919711923710529}
+2026-03-31 20:07:22 | INFO | models | Built Baseline CNN
+2026-03-31 20:18:34 | INFO | models | Built MobileNetV2 Transfer Learning model
+2026-03-31 20:30:54 | INFO | models | Fine-tuned MobileNetV2: last 20 layers unfrozen
+2026-03-31 20:34:10 | INFO | models | Built Baseline CNN
+2026-03-31 20:46:13 | INFO | models | Built MobileNetV2 Transfer Learning model
+2026-03-31 20:58:01 | INFO | models | Fine-tuned MobileNetV2: last 20 layers unfrozen
+2026-03-31 21:12:51 | INFO | models | Built Baseline CNN
+2026-03-31 21:24:33 | INFO | models | Built MobileNetV2 Transfer Learning model
+2026-03-31 21:33:02 | INFO | models | Fine-tuned MobileNetV2: last 20 layers unfrozen
+2026-03-31 21:44:07 | INFO | models | Built EfficientNetB0 Transfer Learning model
+2026-03-31 21:54:35 | INFO | models | Built Optuna CNN with params: {'filters_1': 32, 'filters_2': 128, 'filters_3': 128, 'dense_units': 64, 'dropout': 0.32019749083776056, 'lr': 0.00013123523142015807}
+2026-03-31 21:59:44 | INFO | models | Built Optuna CNN with params: {'filters_1': 32, 'filters_2': 128, 'filters_3': 128, 'dense_units': 64, 'dropout': 0.3608500202287982, 'lr': 0.006160897969691244}
+2026-03-31 22:02:36 | INFO | models | Built Optuna CNN with params: {'filters_1': 64, 'filters_2': 64, 'filters_3': 256, 'dense_units': 64, 'dropout': 0.36105752942364244, 'lr': 0.0049551985659201875}
+2026-03-31 22:05:22 | INFO | models | Built Optuna CNN with params: {'filters_1': 32, 'filters_2': 64, 'filters_3': 256, 'dense_units': 128, 'dropout': 0.23703993355843925, 'lr': 0.00038430793245279804}
+2026-03-31 22:10:37 | INFO | models | Built Optuna CNN with params: {'filters_1': 32, 'filters_2': 64, 'filters_3': 256, 'dense_units': 256, 'dropout': 0.4927392453904861, 'lr': 0.00046537997987104555}
+2026-03-31 22:15:47 | INFO | models | Built Optuna CNN with params: {'filters_1': 32, 'filters_2': 128, 'filters_3': 128, 'dense_units': 128, 'dropout': 0.29917774216119697, 'lr': 0.004167362541330431}
+2026-03-31 22:18:57 | INFO | models | Built Optuna CNN with params: {'filters_1': 64, 'filters_2': 128, 'filters_3': 128, 'dense_units': 128, 'dropout': 0.21910790415316955, 'lr': 0.001097875265927963}
+2026-03-31 22:24:20 | INFO | models | Built Optuna CNN with params: {'filters_1': 64, 'filters_2': 128, 'filters_3': 256, 'dense_units': 128, 'dropout': 0.2258892046075821, 'lr': 0.00022392987135907492}
+2026-03-31 22:29:43 | INFO | models | Built Optuna CNN with params: {'filters_1': 32, 'filters_2': 128, 'filters_3': 256, 'dense_units': 64, 'dropout': 0.26014293287733325, 'lr': 0.0028061362157403144}
+2026-03-31 22:33:27 | INFO | models | Built Optuna CNN with params: {'filters_1': 32, 'filters_2': 128, 'filters_3': 128, 'dense_units': 256, 'dropout': 0.34722069690590884, 'lr': 0.0025020125205854928}
+2026-03-31 22:39:09 | INFO | models | Built Optuna CNN with params: {'filters_1': 64, 'filters_2': 128, 'filters_3': 256, 'dense_units': 128, 'dropout': 0.2258892046075821, 'lr': 0.00022392987135907492}

logs/predict.log

@@ -0,0 +1,96 @@
+2026-04-01 00:27:54 | INFO | predict | Loading TF model from ./saved_models\best_brain_tumor_model.h5
+2026-04-01 00:27:54 | INFO | predict | Loading ONNX FP32 from ./onnx_models\model_fp32.onnx
+2026-04-01 00:27:54 | INFO | predict | Loading ONNX Dynamic INT8 from ./onnx_models\model_dynamic_int8.onnx
+2026-04-01 00:27:55 | INFO | predict | Loading ONNX Static INT8 from ./onnx_models\model_static_int8.onnx
+2026-04-01 00:37:17 | INFO | predict | Loading TF model from ./saved_models\best_brain_tumor_model.h5
+2026-04-01 00:37:17 | INFO | predict | Loading ONNX FP32 from ./onnx_models\model_fp32.onnx
+2026-04-01 00:37:17 | INFO | predict | Loading ONNX Dynamic INT8 from ./onnx_models\model_dynamic_int8.onnx
+2026-04-01 00:37:17 | INFO | predict | Loading ONNX Static INT8 from ./onnx_models\model_static_int8.onnx
+2026-04-01 00:42:17 | INFO | predict | Loading TF model from ./saved_models\ft_best.h5
+2026-04-01 00:42:19 | INFO | predict | Loading ONNX FP32 from ./onnx_models\model_fp32.onnx
+2026-04-01 00:42:19 | INFO | predict | Loading ONNX Dynamic INT8 from ./onnx_models\model_dynamic_int8.onnx
+2026-04-01 00:42:19 | INFO | predict | Loading ONNX Static INT8 from ./onnx_models\model_static_int8.onnx
+2026-04-01 00:50:24 | INFO | predict | Loading TF model from ./saved_models\ft_best.h5
+2026-04-01 00:50:26 | INFO | predict | Loading ONNX FP32 from ./onnx_models\model_fp32.onnx
+2026-04-01 00:50:26 | INFO | predict | Loading ONNX Dynamic INT8 from ./onnx_models\model_dynamic_int8.onnx
+2026-04-01 00:50:26 | INFO | predict | Loading ONNX Static INT8 from ./onnx_models\model_static_int8.onnx
+2026-04-01 00:53:52 | INFO | predict | Loading TF model from ./saved_models\ft_best.h5
+2026-04-01 00:53:53 | INFO | predict | Loading ONNX FP32 from ./onnx_models\model_fp32.onnx
+2026-04-01 00:53:53 | INFO | predict | Loading ONNX Dynamic INT8 from ./onnx_models\model_dynamic_int8.onnx
+2026-04-01 00:53:53 | INFO | predict | Loading ONNX Static INT8 from ./onnx_models\model_static_int8.onnx
+2026-04-01 00:54:31 | INFO | predict | Loading TF model from ./saved_models\ft_best.h5
+2026-04-01 00:54:32 | INFO | predict | Loading ONNX FP32 from ./onnx_models\model_fp32.onnx
+2026-04-01 00:54:32 | INFO | predict | Loading ONNX Dynamic INT8 from ./onnx_models\model_dynamic_int8.onnx
+2026-04-01 00:54:32 | INFO | predict | Loading ONNX Static INT8 from ./onnx_models\model_static_int8.onnx
+2026-04-01 00:56:42 | INFO | predict | Loading TF model from ./saved_models\ft_best.h5
+2026-04-01 00:56:44 | INFO | predict | Loading ONNX FP32 from ./onnx_models\model_fp32.onnx
+2026-04-01 00:56:44 | INFO | predict | Loading ONNX Dynamic INT8 from ./onnx_models\model_dynamic_int8.onnx
+2026-04-01 00:56:44 | INFO | predict | Loading ONNX Static INT8 from ./onnx_models\model_static_int8.onnx
+2026-04-01 00:59:49 | INFO | predict | Loading TF model from ./saved_models\ft_best.h5
+2026-04-01 00:59:51 | INFO | predict | Loading ONNX FP32 from ./onnx_models\model_fp32.onnx
+2026-04-01 00:59:51 | INFO | predict | Loading ONNX Dynamic INT8 from ./onnx_models\model_dynamic_int8.onnx
+2026-04-01 00:59:51 | INFO | predict | Loading ONNX Static INT8 from ./onnx_models\model_static_int8.onnx
+2026-04-01 01:00:17 | INFO | predict | Loading TF model from ./saved_models\ft_best.h5
+2026-04-01 01:00:18 | INFO | predict | Loading ONNX FP32 from ./onnx_models\model_fp32.onnx
+2026-04-01 01:00:18 | INFO | predict | Loading ONNX Dynamic INT8 from ./onnx_models\model_dynamic_int8.onnx
+2026-04-01 01:00:18 | INFO | predict | Loading ONNX Static INT8 from ./onnx_models\model_static_int8.onnx
+2026-04-01 01:01:53 | INFO | predict | Loading TF model from ./saved_models\ft_best.h5
+2026-04-01 01:01:54 | INFO | predict | Loading ONNX FP32 from ./onnx_models\model_fp32.onnx
+2026-04-01 01:01:54 | INFO | predict | Loading ONNX Dynamic INT8 from ./onnx_models\model_dynamic_int8.onnx
+2026-04-01 01:01:55 | INFO | predict | Loading ONNX Static INT8 from ./onnx_models\model_static_int8.onnx
+2026-04-01 11:18:46 | INFO | predict | best_brain_tumor_model.h5 not found, using ft_best.h5
+2026-04-01 11:18:46 | INFO | predict | Loading TF model from ./saved_models\ft_best.h5
+2026-04-01 11:18:47 | INFO | predict | Loading onnx_fp32 from ./onnx_models\model_fp32.onnx
+2026-04-01 11:18:47 | INFO | predict | onnx_fp32 loaded successfully.
+2026-04-01 11:18:47 | INFO | predict | Loading onnx_dynamic from ./onnx_models\model_dynamic_int8.onnx
+2026-04-01 11:18:47 | INFO | predict | Loading onnx_static from ./onnx_models\model_static_int8.onnx
+2026-04-01 11:18:47 | INFO | predict | onnx_static loaded successfully.
+2026-04-01 11:18:59 | INFO | predict | best_brain_tumor_model.h5 not found, using ft_best.h5
+2026-04-01 11:18:59 | INFO | predict | Loading TF model from ./saved_models\ft_best.h5
+2026-04-01 11:19:01 | INFO | predict | Loading onnx_fp32 from ./onnx_models\model_fp32.onnx
+2026-04-01 11:19:01 | INFO | predict | onnx_fp32 loaded successfully.
+2026-04-01 11:19:01 | INFO | predict | Loading onnx_dynamic from ./onnx_models\model_dynamic_int8.onnx
+2026-04-01 11:19:01 | INFO | predict | Loading onnx_static from ./onnx_models\model_static_int8.onnx
+2026-04-01 11:19:01 | INFO | predict | onnx_static loaded successfully.
+2026-04-01 11:20:13 | INFO | predict | best_brain_tumor_model.h5 not found, using ft_best.h5
+2026-04-01 11:20:13 | INFO | predict | Loading TF model from ./saved_models\ft_best.h5
+2026-04-01 11:20:15 | INFO | predict | Loading onnx_fp32 from ./onnx_models\model_fp32.onnx
+2026-04-01 11:20:15 | INFO | predict | onnx_fp32 loaded successfully.
+2026-04-01 11:20:15 | INFO | predict | Loading onnx_dynamic from ./onnx_models\model_dynamic_int8.onnx
+2026-04-01 11:20:15 | INFO | predict | Loading onnx_static from ./onnx_models\model_static_int8.onnx
+2026-04-01 11:20:15 | INFO | predict | onnx_static loaded successfully.
+2026-04-01 11:20:41 | INFO | predict | best_brain_tumor_model.h5 not found, using ft_best.h5
+2026-04-01 11:20:41 | INFO | predict | Loading TF model from ./saved_models\ft_best.h5
+2026-04-01 11:20:43 | INFO | predict | Loading onnx_fp32 from ./onnx_models\model_fp32.onnx
+2026-04-01 11:20:43 | INFO | predict | onnx_fp32 loaded successfully.
+2026-04-01 11:20:43 | INFO | predict | Loading onnx_dynamic from ./onnx_models\model_dynamic_int8.onnx
+2026-04-01 11:20:43 | INFO | predict | Loading onnx_static from ./onnx_models\model_static_int8.onnx
+2026-04-01 11:20:43 | INFO | predict | onnx_static loaded successfully.
+2026-04-01 11:20:59 | INFO | predict | Loading TF model from ./saved_models\ft_best.h5
+2026-04-01 11:21:01 | INFO | predict | Loading ONNX FP32 from ./onnx_models\model_fp32.onnx
+2026-04-01 11:21:01 | INFO | predict | Loading ONNX Dynamic INT8 from ./onnx_models\model_dynamic_int8.onnx
+2026-04-01 11:21:01 | INFO | predict | Loading ONNX Static INT8 from ./onnx_models\model_static_int8.onnx
+2026-04-01 11:28:21 | INFO | predict | Loading TF model from ./saved_models\ft_best.h5
+2026-04-01 11:28:22 | INFO | predict | Loading onnx_fp32 from ./onnx_models\model_fp32.onnx
+2026-04-01 11:28:22 | INFO | predict | Loading onnx_dynamic from ./onnx_models\model_dynamic_int8.onnx
+2026-04-01 11:28:23 | INFO | predict | Loading onnx_static from ./onnx_models\model_static_int8.onnx
+2026-04-01 11:28:29 | INFO | predict | Loading TF model from ./saved_models\ft_best.h5
+2026-04-01 11:28:31 | INFO | predict | Loading onnx_fp32 from ./onnx_models\model_fp32.onnx
+2026-04-01 11:28:31 | INFO | predict | Loading onnx_dynamic from ./onnx_models\model_dynamic_int8.onnx
+2026-04-01 11:28:31 | INFO | predict | Loading onnx_static from ./onnx_models\model_static_int8.onnx
+2026-04-01 11:28:38 | INFO | predict | Loading TF model from ./saved_models\ft_best.h5
+2026-04-01 11:28:40 | INFO | predict | Loading onnx_fp32 from ./onnx_models\model_fp32.onnx
+2026-04-01 11:28:40 | INFO | predict | Loading onnx_dynamic from ./onnx_models\model_dynamic_int8.onnx
+2026-04-01 11:28:40 | INFO | predict | Loading onnx_static from ./onnx_models\model_static_int8.onnx
+2026-04-01 11:46:37 | INFO | predict | Loading TF model from ./saved_models\ft_best.h5
+2026-04-01 11:46:39 | INFO | predict | Loading ONNX FP32 from ./onnx_models\model_fp32.onnx
+2026-04-01 11:46:39 | INFO | predict | Loading ONNX Dynamic INT8 from ./onnx_models\model_dynamic_int8.onnx
+2026-04-01 11:46:39 | INFO | predict | Loading ONNX Static INT8 from ./onnx_models\model_static_int8.onnx
+2026-04-01 11:51:09 | INFO | predict | Loading TF model from ./saved_models\ft_best.h5
+2026-04-01 11:51:10 | INFO | predict | Loading ONNX FP32 from ./onnx_models\model_fp32.onnx
+2026-04-01 11:51:10 | INFO | predict | Loading ONNX Dynamic INT8 from ./onnx_models\model_dynamic_int8.onnx
+2026-04-01 11:51:10 | INFO | predict | Loading ONNX Static INT8 from ./onnx_models\model_static_int8.onnx
+2026-04-01 12:06:18 | INFO | predict | Loading TF model from ./saved_models\ft_best.h5
+2026-04-01 12:06:20 | INFO | predict | Loading ONNX FP32 from ./onnx_models\model_fp32.onnx
+2026-04-01 12:06:20 | INFO | predict | Loading ONNX Dynamic INT8 from ./onnx_models\model_dynamic_int8.onnx
+2026-04-01 12:06:20 | INFO | predict | Loading ONNX Static INT8 from ./onnx_models\model_static_int8.onnx

logs/train.log

@@ -0,0 +1,86 @@
+2026-03-31 12:45:57 | INFO | train | ==================================================
+2026-03-31 12:45:57 | INFO | train | Starting training pipeline
+2026-03-31 12:45:57 | INFO | train | ==================================================
+2026-03-31 12:57:30 | INFO | train | Baseline CNN training complete.
+2026-03-31 13:08:17 | INFO | train | Transfer Learning training complete.
+2026-03-31 13:13:09 | INFO | train | Fine-Tuned training complete.
+2026-03-31 15:59:57 | INFO | train | ==================================================
+2026-03-31 15:59:57 | INFO | train | Starting full training pipeline
+2026-03-31 15:59:57 | INFO | train | ==================================================
+2026-03-31 16:11:00 | INFO | train | Baseline CNN training complete.
+2026-03-31 16:22:00 | INFO | train | Transfer Learning training complete.
+2026-03-31 16:26:58 | INFO | train | Fine-Tuned training complete.
+2026-03-31 16:43:07 | INFO | train | ==================================================
+2026-03-31 16:43:07 | INFO | train | Starting full training pipeline
+2026-03-31 16:43:07 | INFO | train | ==================================================
+2026-03-31 16:53:37 | INFO | train | Baseline CNN training complete.
+2026-03-31 17:04:24 | INFO | train | Transfer Learning training complete.
+2026-03-31 17:09:20 | INFO | train | Fine-Tuned training complete.
+2026-03-31 17:09:57 | INFO | train |   EfficientNet weights saved (val_acc=0.2500)
+2026-03-31 17:12:19 | INFO | train | Best EfficientNet weights restored.
+2026-03-31 17:36:33 | INFO | train | ==================================================
+2026-03-31 17:36:33 | INFO | train | Starting full training pipeline
+2026-03-31 17:36:33 | INFO | train | ==================================================
+2026-03-31 17:47:05 | INFO | train | Baseline CNN training complete.
+2026-03-31 17:54:34 | INFO | train | Transfer Learning training complete.
+2026-03-31 18:03:34 | INFO | train | Fine-Tuned training complete.
+2026-03-31 18:04:11 | INFO | train |   EfficientNet weights saved (val_acc=0.2500)
+2026-03-31 18:06:31 | INFO | train | Best EfficientNet weights restored.
+2026-03-31 18:06:49 | INFO | train | EfficientNetB0 training complete.
+2026-03-31 18:43:24 | INFO | train | Optuna best val_accuracy : 0.8446
+2026-03-31 18:43:24 | INFO | train | Optuna best params       : {'filters_1': 64, 'filters_2': 128, 'filters_3': 128, 'dense_units': 256, 'dropout': 0.41542144036132356, 'lr': 0.00011919711923710529}
+2026-03-31 18:56:54 | INFO | train | Optuna Best CNN training complete.
+2026-03-31 18:56:54 | INFO | train | 
+=============================================
+2026-03-31 18:56:54 | INFO | train | Model                        Val Acc
+2026-03-31 18:56:54 | INFO | train | =============================================
+2026-03-31 18:56:54 | INFO | train | Baseline CNN                  0.9045
+2026-03-31 18:56:54 | INFO | train | Transfer Learning             0.9250
+2026-03-31 18:56:54 | INFO | train | EfficientNetB0                0.2500
+2026-03-31 18:56:54 | INFO | train | Optuna Best CNN               0.9089
+2026-03-31 18:56:54 | INFO | train | =============================================
+2026-03-31 19:32:15 | INFO | train | Training pipeline complete.
+2026-03-31 20:07:21 | INFO | train | MLflow → DagsHub: https://dagshub.com/shoaib.shahriar01/brain-tumor-classification.mlflow
+2026-03-31 20:07:21 | INFO | train | ==================================================
+2026-03-31 20:07:21 | INFO | train | Starting full training pipeline
+2026-03-31 20:07:21 | INFO | train | ==================================================
+2026-03-31 20:18:32 | INFO | train | Baseline CNN training complete.
+2026-03-31 20:30:53 | INFO | train | Transfer Learning training complete.
+2026-03-31 20:34:09 | INFO | train | MLflow → DagsHub: https://dagshub.com/shoaib.shahriar01/brain-tumor-classification.mlflow
+2026-03-31 20:34:10 | INFO | train | ==================================================
+2026-03-31 20:34:10 | INFO | train | Starting full training pipeline
+2026-03-31 20:34:10 | INFO | train | ==================================================
+2026-03-31 20:46:11 | INFO | train | Baseline CNN training complete.
+2026-03-31 20:58:00 | INFO | train | Transfer Learning training complete.
+2026-03-31 21:04:20 | INFO | train | Fine-Tuned training complete.
+2026-03-31 21:12:50 | INFO | train | MLflow → DagsHub: https://dagshub.com/shoaib.shahriar01/brain-tumor-classification.mlflow
+2026-03-31 21:12:50 | INFO | train | ==================================================
+2026-03-31 21:12:50 | INFO | train | Starting full training pipeline
+2026-03-31 21:12:50 | INFO | train | ==================================================
+2026-03-31 21:24:31 | INFO | train | Baseline CNN training complete.
+2026-03-31 21:33:01 | INFO | train | Transfer Learning training complete.
+2026-03-31 21:44:03 | INFO | train | Fine-Tuned training complete.
+2026-03-31 21:44:42 | INFO | train |   EfficientNet weights saved (val_acc=0.8643)
+2026-03-31 21:45:11 | INFO | train |   EfficientNet weights saved (val_acc=0.8991)
+2026-03-31 21:46:35 | INFO | train |   EfficientNet weights saved (val_acc=0.9107)
+2026-03-31 21:48:03 | INFO | train |   EfficientNet weights saved (val_acc=0.9152)
+2026-03-31 21:49:39 | INFO | train |   EfficientNet weights saved (val_acc=0.9295)
+2026-03-31 21:51:05 | INFO | train |   EfficientNet weights saved (val_acc=0.9357)
+2026-03-31 21:52:02 | INFO | train |   EfficientNet weights saved (val_acc=0.9393)
+2026-03-31 21:54:11 | INFO | train | Best EfficientNet weights restored.
+2026-03-31 21:54:32 | INFO | train | EfficientNet weights logged to MLflow → ./saved_models\effnet_final_weights.h5
+2026-03-31 21:54:32 | INFO | train | EfficientNetB0 training complete.
+2026-03-31 22:39:09 | INFO | train | Optuna best val_accuracy : 0.8348
+2026-03-31 22:39:09 | INFO | train | Optuna best params       : {'filters_1': 64, 'filters_2': 128, 'filters_3': 256, 'dense_units': 128, 'dropout': 0.2258892046075821, 'lr': 0.00022392987135907492}
+2026-03-31 22:53:50 | INFO | train | Optuna Best CNN training complete.
+2026-03-31 22:53:50 | INFO | train | 
+=============================================
+2026-03-31 22:53:50 | INFO | train | Model                        Val Acc
+2026-03-31 22:53:50 | INFO | train | =============================================
+2026-03-31 22:53:50 | INFO | train | Baseline CNN                  0.9009
+2026-03-31 22:53:50 | INFO | train | Transfer Learning             0.9214
+2026-03-31 22:53:50 | INFO | train | Fine-Tuned                    0.9366
+2026-03-31 22:53:50 | INFO | train | EfficientNetB0                0.9393 << best
+2026-03-31 22:53:50 | INFO | train | Optuna Best CNN               0.9054
+2026-03-31 22:53:50 | INFO | train | =============================================
+2026-03-31 22:54:07 | INFO | train | Training pipeline complete.

onnx_models/benchmark_results.json

@@ -0,0 +1,17 @@
+{
+    "TensorFlow (FP32)": {
+        "latency_ms": 9.146038293838501,
+        "accuracy": 0.7,
+        "size_mb": null
+    },
+    "ONNX FP32": {
+        "latency_ms": 5.294694900512695,
+        "accuracy": 0.7,
+        "size_mb": 9.096985816955566
+    },
+    "ONNX Static INT8": {
+        "latency_ms": 4.193357229232788,
+        "accuracy": 0.005,
+        "size_mb": 2.507014274597168
+    }
+}

onnx_models/model_dynamic_int8.onnx

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

onnx_models/model_fp32.onnx

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

onnx_models/model_static_int8.onnx

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

predict.py

@@ -0,0 +1,164 @@
+# predict.py — inference engine: TF | ONNX FP32 | Dynamic INT8 | Static INT8
+
+import os
+import numpy as np
+import cv2
+import tensorflow as tf
+import onnxruntime as ort
+from tensorflow.keras.preprocessing.image import load_img
+
+from src.utils import get_logger, get_gradcam_heatmap, get_last_conv_layer
+
+logger = get_logger("predict")
+
+
+class BrainTumorPredictor:
+    """
+    Unified predictor supporting TF model, ONNX FP32,
+    ONNX Dynamic INT8, and ONNX Static INT8.
+    """
+
+    BACKENDS = ["tensorflow", "onnx_fp32", "onnx_dynamic", "onnx_static"]
+
+    def __init__(self, cfg: dict, backend: str = "tensorflow"):
+        if backend not in self.BACKENDS:
+            raise ValueError(f"backend must be one of {self.BACKENDS}")
+
+        self.backend = backend
+        self.image_size = tuple(cfg["data"]["image_size"])
+        self.class_names = cfg["data"]["classes"]
+        self.save_dir = cfg["models"]["save_dir"]
+        self.onnx_dir = cfg["models"]["onnx_dir"]
+
+        self.tf_model = None
+        self.ort_session = None
+        self._load(backend)
+
+    def _load(self, backend: str):
+        if backend == "tensorflow":
+            path = os.path.join(self.save_dir, "ft_best.h5")
+            logger.info(f"Loading TF model from {path}")
+            self.tf_model = tf.keras.models.load_model(path, compile=False)
+
+        elif backend == "onnx_fp32":
+            path = os.path.join(self.onnx_dir, "model_fp32.onnx")
+            logger.info(f"Loading ONNX FP32 from {path}")
+            self.ort_session = ort.InferenceSession(path, providers=["CPUExecutionProvider"])
+
+        elif backend == "onnx_dynamic":
+            path = os.path.join(self.onnx_dir, "model_dynamic_int8.onnx")
+            logger.info(f"Loading ONNX Dynamic INT8 from {path}")
+            try:
+                self.ort_session = ort.InferenceSession(path, providers=["CPUExecutionProvider"])
+            except Exception as e:
+                raise RuntimeError(
+                    f"ONNX Dynamic INT8 model is not supported in this ONNX Runtime build: {e}"
+                )
+
+        elif backend == "onnx_static":
+            path = os.path.join(self.onnx_dir, "model_static_int8.onnx")
+            logger.info(f"Loading ONNX Static INT8 from {path}")
+            try:
+                self.ort_session = ort.InferenceSession(path, providers=["CPUExecutionProvider"])
+            except Exception as e:
+                raise RuntimeError(
+                    f"ONNX Static INT8 model is not supported in this ONNX Runtime build: {e}"
+                )
+
+    def preprocess(self, image_path: str) -> tuple:
+        img = load_img(image_path, target_size=self.image_size)
+        arr = np.array(img) / 255.0
+        img_input = np.expand_dims(arr, axis=0).astype(np.float32)
+        return img, arr, img_input
+
+    def predict(self, image_path: str) -> dict:
+        _, _, img_input = self.preprocess(image_path)
+
+        if self.backend == "tensorflow":
+            probs = self.tf_model.predict(img_input, verbose=0)[0]
+        else:
+            inp_name = self.ort_session.get_inputs()[0].name
+            out_name = self.ort_session.get_outputs()[0].name
+            probs = self.ort_session.run([out_name], {inp_name: img_input})[0][0]
+
+        pred_idx = int(np.argmax(probs))
+        pred_class = self.class_names[pred_idx]
+        confidence = float(probs[pred_idx]) * 100
+
+        all_probs = {cls: float(p) * 100 for cls, p in zip(self.class_names, probs)}
+
+        return {
+            "predicted_class": pred_class,
+            "confidence": round(confidence, 2),
+            "all_probabilities": all_probs,
+            "backend": self.backend,
+        }
+
+    def predict_with_gradcam(self, image_path: str) -> dict:
+        if self.backend != "tensorflow":
+            raise RuntimeError("Grad-CAM is only supported with tensorflow backend.")
+
+        result = self.predict(image_path)
+        _, arr, img_input = self.preprocess(image_path)
+
+        last_conv = get_last_conv_layer(self.tf_model)
+        heatmap, _ = get_gradcam_heatmap(self.tf_model, img_input, last_conv)
+
+        heatmap_resized = cv2.resize(heatmap, self.image_size)
+        heatmap_colored = cv2.cvtColor(
+            cv2.applyColorMap(np.uint8(255 * heatmap_resized), cv2.COLORMAP_JET),
+            cv2.COLOR_BGR2RGB
+        )
+        overlay = cv2.addWeighted(np.uint8(255 * arr), 0.6, heatmap_colored, 0.4, 0)
+
+        result["gradcam_overlay"] = overlay
+        result["heatmap"] = heatmap_resized
+        return result
+
+
+if __name__ == "__main__":
+    import argparse
+    import matplotlib.pyplot as plt
+    from src.utils import load_config
+
+    parser = argparse.ArgumentParser(description="Brain Tumor MRI Predictor")
+    parser.add_argument("--image", required=True)
+    parser.add_argument("--backend", default="tensorflow", choices=BrainTumorPredictor.BACKENDS)
+    parser.add_argument("--gradcam", action="store_true")
+    args = parser.parse_args()
+
+    cfg = load_config("config.yaml")
+    predictor = BrainTumorPredictor(cfg, backend=args.backend)
+
+    if args.gradcam and args.backend == "tensorflow":
+        result = predictor.predict_with_gradcam(args.image)
+
+        fig, axes = plt.subplots(1, 3, figsize=(13, 4))
+        img = load_img(args.image, target_size=tuple(cfg["data"]["image_size"]))
+        axes[0].imshow(img)
+        axes[0].set_title("Input MRI")
+        axes[0].axis("off")
+
+        axes[1].imshow(result["heatmap"], cmap="jet")
+        axes[1].set_title("Grad-CAM")
+        axes[1].axis("off")
+
+        axes[2].imshow(result["gradcam_overlay"])
+        axes[2].set_title(f"Pred: {result['predicted_class']} ({result['confidence']:.1f}%)")
+        axes[2].axis("off")
+
+        plt.tight_layout()
+        plt.show()
+    else:
+        result = predictor.predict(args.image)
+
+    print("\n" + "=" * 42)
+    print(f"  PREDICTION : {result['predicted_class'].upper()}")
+    print(f"  CONFIDENCE : {result['confidence']:.2f}%")
+    print(f"  BACKEND    : {result['backend']}")
+    print("=" * 42)
+    print("  All probabilities:")
+    for cls, prob in sorted(result["all_probabilities"].items(), key=lambda x: -x[1]):
+        bar = "█" * int(prob / 4)
+        marker = " ← predicted" if cls == result["predicted_class"] else ""
+        print(f"  {cls:<15} {prob:5.1f}%  {bar}{marker}")

requirements.txt

@@ -0,0 +1,16 @@
+fastapi==0.115.0
+uvicorn[standard]==0.30.6
+python-multipart==0.0.9
+pydantic==2.8.2
+
+tensorflow==2.10.0
+numpy==1.23.5
+protobuf==3.19.6
+
+onnxruntime==1.18.1
+
+opencv-python-headless==4.7.0.72
+Pillow==10.3.0
+PyYAML==6.0.1
+
+matplotlib==3.7.5

save_model.py

@@ -0,0 +1,64 @@
+# save_model.py — save best model, metadata, and Grad-CAM artifacts
+
+import os
+import json
+import numpy as np
+import tensorflow as tf
+import mlflow
+
+from src.utils import get_logger, load_config, generate_gradcam_overlay, get_last_conv_layer
+from src.data_loader import get_data_generators
+
+logger = get_logger("save_model")
+
+
+def save_best_model(model, model_name: str, results: dict,
+                    train_data, cfg: dict):
+    save_dir    = cfg["models"]["save_dir"]
+    os.makedirs(save_dir, exist_ok=True)
+    image_size  = tuple(cfg["data"]["image_size"])
+    class_names = cfg["data"]["classes"]
+
+    # H5 format
+    h5_path = os.path.join(save_dir, "best_brain_tumor_model.h5")
+    model.save(h5_path)
+    logger.info(f"Model saved (H5) → {h5_path}")
+
+    # SavedModel format
+    sm_path = os.path.join(save_dir, "best_brain_tumor_model")
+    model.save(sm_path)
+    logger.info(f"Model saved (SavedModel) → {sm_path}")
+
+    # Metadata
+    metadata = {
+        "best_model"   : model_name,
+        "class_names"  : class_names,
+        "class_indices": train_data.class_indices,
+        "image_size"   : list(image_size),
+        "all_results"  : {k: float(v) for k, v in results.items()},
+    }
+    meta_path = os.path.join(save_dir, "model_metadata.json")
+    with open(meta_path, "w") as f:
+        json.dump(metadata, f, indent=4)
+    logger.info(f"Metadata saved → {meta_path}")
+
+    return h5_path, sm_path, meta_path
+
+
+def log_gradcam_artifacts(model, train_dir: str, class_names: list,
+                           image_size: tuple, run_id: str, logs_dir: str):
+    last_conv = get_last_conv_layer(model)
+    logger.info(f"Generating Grad-CAM for all {len(class_names)} classes ...")
+
+    for class_name in class_names:
+        folder     = os.path.join(train_dir, class_name)
+        sample_img = os.path.join(folder, os.listdir(folder)[0])
+        save_path  = os.path.join(logs_dir, f"gradcam_{class_name}.png")
+
+        generate_gradcam_overlay(model, sample_img, last_conv,
+                                 image_size, class_names, save_path=save_path)
+
+        with mlflow.start_run(run_id=run_id):
+            mlflow.log_artifact(save_path, artifact_path=f"gradcam/{class_name}")
+
+        logger.info(f"  {class_name} Grad-CAM logged.")

saved_models/ft_best.h5

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

src/data_loader.py

@@ -0,0 +1,65 @@
+# data_loader.py — dataset loading and augmentation
+
+from tensorflow.keras.preprocessing.image import ImageDataGenerator
+from src.utils import get_logger
+
+logger = get_logger("data_loader")
+
+
+def get_data_generators(cfg: dict):
+    data_cfg = cfg["data"]
+    aug_cfg  = cfg["augmentation"]
+
+    image_size  = tuple(data_cfg["image_size"])
+    batch_size  = data_cfg["batch_size"]
+    val_split   = data_cfg["validation_split"]
+    train_dir   = data_cfg["train_dir"]
+    test_dir    = data_cfg["test_dir"]
+
+    train_gen = ImageDataGenerator(
+        rescale=1./255,
+        validation_split=val_split,
+        rotation_range=aug_cfg["rotation_range"],
+        width_shift_range=aug_cfg["width_shift_range"],
+        height_shift_range=aug_cfg["height_shift_range"],
+        zoom_range=aug_cfg["zoom_range"],
+        horizontal_flip=aug_cfg["horizontal_flip"],
+        brightness_range=aug_cfg["brightness_range"],
+    )
+
+    test_gen = ImageDataGenerator(rescale=1./255)
+
+    train_data = train_gen.flow_from_directory(
+        train_dir,
+        target_size=image_size,
+        batch_size=batch_size,
+        class_mode="categorical",
+        subset="training",
+        seed=cfg["project"]["seed"],
+        shuffle=True
+    )
+
+    val_data = train_gen.flow_from_directory(
+        train_dir,
+        target_size=image_size,
+        batch_size=batch_size,
+        class_mode="categorical",
+        subset="validation",
+        seed=cfg["project"]["seed"],
+        shuffle=False
+    )
+
+    test_data = test_gen.flow_from_directory(
+        test_dir,
+        target_size=image_size,
+        batch_size=batch_size,
+        class_mode="categorical",
+        shuffle=False
+    )
+
+    logger.info(f"Train samples : {train_data.samples}")
+    logger.info(f"Val samples   : {val_data.samples}")
+    logger.info(f"Test samples  : {test_data.samples}")
+    logger.info(f"Classes       : {train_data.class_indices}")
+
+    return train_data, val_data, test_data

src/export_onnx.py

@@ -0,0 +1,282 @@
+# export_onnx.py — ONNX export + optional quantization + benchmark
+
+import os
+import time
+import json
+import numpy as np
+import tensorflow as tf
+import onnx
+import onnxruntime as ort
+
+from src.utils import get_logger, load_config
+from data_loader import get_data_generators
+
+logger = get_logger("export_onnx")
+
+
+# ---------------------------------------------------------------------------
+# Optional ONNX Runtime quantization import
+# ---------------------------------------------------------------------------
+
+QUANTIZATION_AVAILABLE = True
+QUANT_IMPORT_ERROR = None
+
+try:
+    from onnxruntime.quantization import (
+        quantize_dynamic,
+        quantize_static,
+        QuantType,
+        CalibrationDataReader,
+        QuantFormat,
+    )
+except Exception as e:
+    QUANTIZATION_AVAILABLE = False
+    QUANT_IMPORT_ERROR = str(e)
+
+    class CalibrationDataReader:
+        """Fallback placeholder when quantization imports are unavailable."""
+        pass
+
+
+# ---------------------------------------------------------------------------
+# TF → ONNX export
+# ---------------------------------------------------------------------------
+
+def export_to_onnx(model, onnx_path: str, image_size: tuple = (150, 150)):
+    import tf2onnx
+    import tf2onnx.convert
+
+    os.makedirs(os.path.dirname(onnx_path), exist_ok=True)
+
+    input_signature = [
+        tf.TensorSpec(
+            shape=(None, *image_size, 3),
+            dtype=tf.float32,
+            name="input",
+        )
+    ]
+
+    logger.info(f"Exporting model to ONNX → {onnx_path}")
+    tf2onnx.convert.from_keras(
+        model,
+        input_signature=input_signature,
+        opset=13,
+        output_path=onnx_path,
+    )
+
+    onnx_model = onnx.load(onnx_path)
+    onnx.checker.check_model(onnx_model)
+
+    size_mb = os.path.getsize(onnx_path) / (1024 * 1024)
+    logger.info(f"ONNX export successful — size: {size_mb:.2f} MB")
+    return onnx_path
+
+
+# ---------------------------------------------------------------------------
+# Dynamic Quantization (optional)
+# ---------------------------------------------------------------------------
+
+def dynamic_quantize(onnx_path: str, output_path: str):
+    if not QUANTIZATION_AVAILABLE:
+        logger.warning(f"Dynamic quantization skipped: {QUANT_IMPORT_ERROR}")
+        return None
+
+    logger.info(f"Applying Dynamic Quantization → {output_path}")
+    quantize_dynamic(
+        model_input=onnx_path,
+        model_output=output_path,
+        weight_type=QuantType.QInt8,
+    )
+
+    size_mb = os.path.getsize(output_path) / (1024 * 1024)
+    logger.info(f"Dynamic quantized model — size: {size_mb:.2f} MB")
+    return output_path
+
+
+# ---------------------------------------------------------------------------
+# Static Quantization (optional)
+# ---------------------------------------------------------------------------
+
+class MRICalibrationReader(CalibrationDataReader):
+    """Feeds calibration batches to the static quantizer."""
+
+    def __init__(self, data_generator, n_batches: int = 10):
+        self.data = []
+        self.index = 0
+
+        for i, (batch_x, _) in enumerate(data_generator):
+            if i >= n_batches:
+                break
+            self.data.append(batch_x.astype(np.float32))
+
+        logger.info(f"Calibration reader: {len(self.data)} batches loaded")
+
+    def get_next(self):
+        if self.index >= len(self.data):
+            return None
+
+        batch = {"input": self.data[self.index]}
+        self.index += 1
+        return batch
+
+
+def static_quantize(onnx_path: str, output_path: str, train_data, n_batches: int = 10):
+    if not QUANTIZATION_AVAILABLE:
+        logger.warning(f"Static quantization skipped: {QUANT_IMPORT_ERROR}")
+        return None
+
+    logger.info(f"Applying Static Quantization → {output_path}")
+    reader = MRICalibrationReader(train_data, n_batches=n_batches)
+
+    quantize_static(
+        model_input=onnx_path,
+        model_output=output_path,
+        calibration_data_reader=reader,
+        quant_format=QuantFormat.QDQ,
+        activation_type=QuantType.QInt8,
+        weight_type=QuantType.QInt8,
+    )
+
+    size_mb = os.path.getsize(output_path) / (1024 * 1024)
+    logger.info(f"Static quantized model — size: {size_mb:.2f} MB")
+    return output_path
+
+
+# ---------------------------------------------------------------------------
+# ONNX Runtime inference helper
+# ---------------------------------------------------------------------------
+
+def onnx_predict(onnx_path: str, img_array: np.ndarray) -> np.ndarray:
+    sess = ort.InferenceSession(onnx_path, providers=["CPUExecutionProvider"])
+    input_name = sess.get_inputs()[0].name
+    output_name = sess.get_outputs()[0].name
+    return sess.run([output_name], {input_name: img_array.astype(np.float32)})[0]
+
+
+# ---------------------------------------------------------------------------
+# Benchmark
+# ---------------------------------------------------------------------------
+
+def benchmark_models(tf_model, paths: dict, test_data, n_samples: int = 200) -> dict:
+    logger.info("\nBenchmarking model formats ...")
+
+    X_all, y_all = [], []
+    total = 0
+
+    for batch_x, batch_y in test_data:
+        X_all.append(batch_x)
+        y_all.append(batch_y)
+        total += len(batch_x)
+        if total >= n_samples:
+            break
+
+    X = np.concatenate(X_all, axis=0)[:n_samples].astype(np.float32)
+    y = np.concatenate(y_all, axis=0)[:n_samples]
+    y_true = np.argmax(y, axis=1)
+
+    results = {}
+
+    # TensorFlow model
+    t0 = time.time()
+    preds = tf_model.predict(X, verbose=0)
+    tf_ms = (time.time() - t0) * 1000 / len(X)
+    tf_acc = (np.argmax(preds, axis=1) == y_true).mean()
+
+    results["TensorFlow (FP32)"] = {
+        "latency_ms": float(tf_ms),
+        "accuracy": float(tf_acc),
+        "size_mb": None,
+    }
+    logger.info(f"TensorFlow (FP32) | acc={tf_acc:.4f} | {tf_ms:.2f} ms/sample")
+
+    # ONNX models
+    for name, path in paths.items():
+        if path is None:
+            logger.warning(f"Skipping {name} — path is None")
+            continue
+        if not os.path.exists(path):
+            logger.warning(f"Skipping {name} — file not found: {path}")
+            continue
+
+        try:
+            t0 = time.time()
+            preds = onnx_predict(path, X)
+            ms = (time.time() - t0) * 1000 / len(X)
+            acc = (np.argmax(preds, axis=1) == y_true).mean()
+            size = os.path.getsize(path) / (1024 * 1024)
+
+            results[name] = {
+                "latency_ms": float(ms),
+                "accuracy": float(acc),
+                "size_mb": float(size),
+            }
+            logger.info(f"{name:<24} | acc={acc:.4f} | {ms:.2f} ms/sample | {size:.2f} MB")
+
+        except Exception as e:
+            logger.warning(f"Skipping {name} due to runtime error: {e}")
+
+    return results
+
+
+def print_benchmark_table(results: dict):
+    print("\n" + "=" * 70)
+    print(f"{'Format':<26} {'Accuracy':>10} {'Latency(ms)':>13} {'Size(MB)':>12}")
+    print("=" * 70)
+    for name, r in results.items():
+        size = f"{r['size_mb']:.2f}" if r["size_mb"] is not None else "—"
+        print(f"{name:<26} {r['accuracy']:>10.4f} {r['latency_ms']:>13.2f} {size:>12}")
+    print("=" * 70)
+
+
+# ---------------------------------------------------------------------------
+# Main
+# ---------------------------------------------------------------------------
+
+if __name__ == "__main__":
+    cfg = load_config("config.yaml")
+    image_size = tuple(cfg["data"]["image_size"])
+    onnx_dir = cfg["models"]["onnx_dir"]
+    save_dir = cfg["models"]["save_dir"]
+
+    os.makedirs(onnx_dir, exist_ok=True)
+
+    train_data, val_data, test_data = get_data_generators(cfg)
+
+    # Load best saved model
+    model_path = os.path.join(save_dir, "ft_best.h5")
+    logger.info(f"Loading model from {model_path}")
+    model = tf.keras.models.load_model(model_path, compile=False)
+
+    # Output paths
+    onnx_fp32_path = os.path.join(onnx_dir, "model_fp32.onnx")
+    onnx_dynamic_path = os.path.join(onnx_dir, "model_dynamic_int8.onnx")
+    onnx_static_path = os.path.join(onnx_dir, "model_static_int8.onnx")
+
+    # Export FP32 ONNX
+    export_to_onnx(model, onnx_fp32_path, image_size)
+
+    # Quantization
+    dynamic_path = dynamic_quantize(onnx_fp32_path, onnx_dynamic_path)
+    static_path = static_quantize(onnx_fp32_path, onnx_static_path, train_data, n_batches=50)
+
+    # Benchmark available formats
+    paths = {
+        "ONNX FP32": onnx_fp32_path,
+        "ONNX Dynamic INT8": dynamic_path,
+        "ONNX Static INT8": static_path,
+    }
+
+    results = benchmark_models(model, paths, test_data)
+    print_benchmark_table(results)
+
+    # Save benchmark results
+    bench_path = os.path.join(onnx_dir, "benchmark_results.json")
+    with open(bench_path, "w") as f:
+        json.dump(results, f, indent=4)
+
+    logger.info(f"Benchmark results saved → {bench_path}")
+
+    if QUANTIZATION_AVAILABLE:
+        logger.info("ONNX export complete. Quantization attempted.")
+    else:
+        logger.warning(f"ONNX export complete. Quantization skipped: {QUANT_IMPORT_ERROR}")

src/models.py

@@ -0,0 +1,98 @@
+# models.py — all model architectures
+
+from tensorflow.keras import layers, models, optimizers
+from tensorflow.keras.applications import MobileNetV2, EfficientNetB0
+from tensorflow.keras.layers import GlobalAveragePooling2D, Dense, Dropout, BatchNormalization
+from src.utils import get_logger
+import tensorflow as tf
+logger = get_logger("models")
+
+
+def build_baseline_cnn(num_classes: int = 4, image_size: tuple = (150, 150)) -> models.Sequential:
+    model = models.Sequential([
+        layers.Input(shape=(*image_size, 3)),
+        layers.Conv2D(32,  (3,3), activation="relu"),
+        layers.MaxPooling2D(2,2),
+        layers.Conv2D(64,  (3,3), activation="relu"),
+        layers.MaxPooling2D(2,2),
+        layers.Conv2D(128, (3,3), activation="relu"),
+        layers.MaxPooling2D(2,2),
+        layers.Flatten(),
+        layers.Dense(128, activation="relu"),
+        layers.Dense(num_classes, activation="softmax"),
+    ], name="baseline_cnn")
+    logger.info("Built Baseline CNN")
+    return model
+
+
+def build_mobilenet_tl(num_classes: int = 4, image_size: tuple = (150, 150)) -> models.Sequential:
+    base = MobileNetV2(weights="imagenet", include_top=False, input_shape=(*image_size, 3))
+    base.trainable = False
+    model = models.Sequential([
+        base,
+        GlobalAveragePooling2D(),
+        Dense(128, activation="relu"),
+        Dense(num_classes, activation="softmax"),
+    ], name="mobilenet_transfer")
+    logger.info("Built MobileNetV2 Transfer Learning model")
+    return model
+
+
+def build_mobilenet_finetuned(base_model, unfreeze_last: int = 20) -> models.Sequential:
+    base_model.trainable = True
+    for layer in base_model.layers[:-unfreeze_last]:
+        layer.trainable = False
+    logger.info(f"Fine-tuned MobileNetV2: last {unfreeze_last} layers unfrozen")
+    return base_model
+
+
+def build_efficientnet(num_classes: int = 4, image_size: tuple = (150, 150)) -> models.Model:
+    inputs = tf.keras.Input(shape=(*image_size, 3))
+    x = tf.keras.layers.Rescaling(scale=255.0)(inputs)  # if generator gives [0,1]
+
+    base = EfficientNetB0(
+        weights="imagenet",
+        include_top=False,
+        input_shape=(*image_size, 3)
+    )
+    base.trainable = False
+
+    x = base(x, training=False)
+    x = GlobalAveragePooling2D()(x)
+    x = Dense(256, activation="relu")(x)
+    x = Dropout(0.3)(x)
+    output = Dense(num_classes, activation="softmax")(x)
+
+    model = models.Model(inputs=inputs, outputs=output, name="efficientnet_b0")
+    logger.info("Built EfficientNetB0 Transfer Learning model")
+    return model
+
+
+def build_optuna_cnn(params: dict, num_classes: int = 4, image_size: tuple = (150, 150)) -> models.Sequential:
+    model = models.Sequential([
+        layers.Input(shape=(*image_size, 3)),
+        layers.Conv2D(params["filters_1"], (3,3), activation="relu"),
+        BatchNormalization(),
+        layers.MaxPooling2D(2,2),
+        layers.Conv2D(params["filters_2"], (3,3), activation="relu"),
+        BatchNormalization(),
+        layers.MaxPooling2D(2,2),
+        layers.Conv2D(params["filters_3"], (3,3), activation="relu"),
+        BatchNormalization(),
+        layers.MaxPooling2D(2,2),
+        layers.Flatten(),
+        Dense(params["dense_units"], activation="relu"),
+        Dropout(params["dropout"]),
+        Dense(num_classes, activation="softmax"),
+    ], name="optuna_best_cnn")
+    logger.info(f"Built Optuna CNN with params: {params}")
+    return model
+
+
+def compile_model(model, lr: float = 1e-3):
+    model.compile(
+        optimizer = optimizers.Adam(learning_rate=lr),
+        loss      = "categorical_crossentropy",
+        metrics   = ["accuracy"]
+    )
+    return model

src/utils.py

@@ -0,0 +1,321 @@
+# utils.py — shared helpers used across all modules
+
+import os
+import yaml
+import logging
+import numpy as np
+import matplotlib.pyplot as plt
+import cv2
+import tensorflow as tf
+from tensorflow.keras.preprocessing.image import load_img
+
+# ---------------------------------------------------------------------------
+# Logger
+# ---------------------------------------------------------------------------
+
+def get_logger(name: str, log_dir: str = "./logs") -> logging.Logger:
+    os.makedirs(log_dir, exist_ok=True)
+    logger = logging.getLogger(name)
+    if logger.handlers:
+        return logger
+
+    logger.setLevel(logging.INFO)
+    fmt = logging.Formatter(
+        "%(asctime)s | %(levelname)s | %(name)s | %(message)s",
+        datefmt="%Y-%m-%d %H:%M:%S"
+    )
+
+    ch = logging.StreamHandler()
+    ch.setFormatter(fmt)
+    logger.addHandler(ch)
+
+    fh = logging.FileHandler(
+        os.path.join(log_dir, f"{name}.log"), encoding="utf-8"
+    )
+    fh.setFormatter(fmt)
+    logger.addHandler(fh)
+
+    return logger
+
+
+# ---------------------------------------------------------------------------
+# Config loader
+# ---------------------------------------------------------------------------
+
+def load_config(path: str = "config.yaml") -> dict:
+    with open(path) as f:
+        return yaml.safe_load(f)
+
+
+# ---------------------------------------------------------------------------
+# Plotting
+# ---------------------------------------------------------------------------
+
+def plot_history(history, title: str, save_path: str = None):
+    fig, axes = plt.subplots(1, 2, figsize=(13, 4))
+
+    axes[0].plot(history.history["accuracy"],     label="Train")
+    axes[0].plot(history.history["val_accuracy"], label="Val")
+    axes[0].set_title(f"{title} - Accuracy")
+    axes[0].set_xlabel("Epoch")
+    axes[0].legend()
+
+    axes[1].plot(history.history["loss"],     label="Train")
+    axes[1].plot(history.history["val_loss"], label="Val")
+    axes[1].set_title(f"{title} - Loss")
+    axes[1].set_xlabel("Epoch")
+    axes[1].legend()
+
+    plt.tight_layout()
+    if save_path:
+        plt.savefig(save_path, bbox_inches="tight", dpi=100)
+    plt.show()
+    plt.close()
+
+
+def plot_comparison(results: dict, save_path: str = None):
+    plt.figure(figsize=(10, 4))
+    colors = [
+        "crimson" if v == max(results.values()) else "steelblue"
+        for v in results.values()
+    ]
+    bars = plt.bar(results.keys(), results.values(), color=colors)
+    plt.bar_label(bars, fmt="%.4f", padding=3)
+    plt.ylim(min(results.values()) - 0.05, 1.0)
+    plt.title("Model Comparison - Validation Accuracy (red = best)")
+    plt.ylabel("Val Accuracy")
+    plt.xticks(rotation=15)
+    plt.tight_layout()
+    if save_path:
+        plt.savefig(save_path, bbox_inches="tight", dpi=100)
+    plt.show()
+    plt.close()
+
+
+# ---------------------------------------------------------------------------
+# Grad-CAM helpers
+# ---------------------------------------------------------------------------
+
+def _collect_all_layers(model) -> list:
+    """
+    Flatten all layers from a model including layers inside nested sub-models.
+    Returns a flat list of (layer_object, parent_model) tuples.
+    """
+    result = []
+
+    def _recurse(m):
+        for layer in m.layers:
+            result.append(layer)
+            if hasattr(layer, "layers") and len(layer.layers) > 0:
+                _recurse(layer)
+
+    _recurse(model)
+    return result
+
+
+def get_last_conv_layer(model) -> str:
+    """
+    Return the name of the last Conv2D layer found anywhere inside the model,
+    including inside nested sub-models (MobileNetV2, EfficientNetB0 etc.).
+    """
+    all_layers  = _collect_all_layers(model)
+    conv_layers = [l for l in all_layers if isinstance(l, tf.keras.layers.Conv2D)]
+
+    if not conv_layers:
+        raise ValueError("No Conv2D layer found in model.")
+
+    return conv_layers[-1].name
+
+
+def _build_gradcam_model(model, last_conv_layer_name: str):
+    """
+    Build a Grad-CAM sub-model that outputs:
+      [conv_layer_output, final_model_predictions]
+
+    Works for both:
+      - Plain CNNs: Conv2D layers are direct children of the model
+      - Nested models: Conv2D is inside a sub-model (MobileNetV2, EfficientNetB0)
+
+    Strategy: find which sub-model owns the target conv layer, build a
+    feature extractor from that sub-model's input to [conv_output, sub_output],
+    then chain it with the remaining head layers of the outer model.
+    """
+    all_layers = _collect_all_layers(model)
+
+    # Find the layer object
+    target_layer = None
+    for layer in all_layers:
+        if layer.name == last_conv_layer_name:
+            target_layer = layer
+            break
+
+    if target_layer is None:
+        raise ValueError(f"Layer '{last_conv_layer_name}' not found in model.")
+
+    # Check if the conv layer is a direct child of the outer model
+    direct_names = [l.name for l in model.layers]
+
+    if last_conv_layer_name in direct_names:
+        # Plain CNN — simple case
+        grad_model = tf.keras.models.Model(
+            inputs  = model.input,
+            outputs = [model.get_layer(last_conv_layer_name).output, model.output]
+        )
+        return grad_model, None   # None = no separate head needed
+
+    # Nested model case — find which direct child sub-model contains the layer
+    owner_submodel = None
+    for layer in model.layers:
+        if hasattr(layer, "layers"):
+            sub_names = [l.name for l in _collect_all_layers(layer)]
+            if last_conv_layer_name in sub_names:
+                owner_submodel = layer
+                break
+
+    if owner_submodel is None:
+        raise ValueError(
+            f"Could not find parent sub-model for layer '{last_conv_layer_name}'."
+        )
+
+    # Build: sub-model input -> [conv_output, sub_model_output]
+    sub_grad_model = tf.keras.models.Model(
+        inputs  = owner_submodel.input,
+        outputs = [
+            owner_submodel.get_layer(last_conv_layer_name).output,
+            owner_submodel.output,
+        ]
+    )
+
+    # Collect head layers (everything after the sub-model in the outer model)
+    head_layers = []
+    found = False
+    for layer in model.layers:
+        if found:
+            head_layers.append(layer)
+        if layer.name == owner_submodel.name:
+            found = True
+
+    return sub_grad_model, head_layers
+
+
+def get_gradcam_heatmap(model, img_array: np.ndarray, last_conv_layer_name: str):
+    """
+    Compute Grad-CAM heatmap.
+
+    Parameters
+    ----------
+    model               : compiled Keras model
+    img_array           : preprocessed image, shape (1, H, W, 3), values in [0,1]
+    last_conv_layer_name: name of the target Conv2D layer
+
+    Returns
+    -------
+    heatmap   : np.ndarray shape (H_conv, W_conv), values in [0,1]
+    pred_idx  : int, predicted class index
+    """
+    grad_model, head_layers = _build_gradcam_model(model, last_conv_layer_name)
+
+    with tf.GradientTape() as tape:
+
+        if head_layers is None:
+            # Plain CNN — single forward pass
+            conv_outputs, predictions = grad_model(img_array)
+        else:
+            # Nested model — two-stage forward pass
+            conv_outputs, sub_output = grad_model(img_array)
+
+            # Run through head layers sequentially
+            x = sub_output
+            for layer in head_layers:
+                x = layer(x)
+            predictions = x
+
+        pred_idx = tf.argmax(predictions[0])
+        loss      = predictions[:, pred_idx]
+
+        # Watch conv_outputs so we can compute gradients w.r.t. it
+        tape.watch(conv_outputs)
+
+    # Recompute with watched tensor inside tape scope
+    with tf.GradientTape() as tape2:
+        tape2.watch(conv_outputs)
+
+        if head_layers is None:
+            conv_out_val, preds = grad_model(img_array)
+        else:
+            conv_out_val, sub_out = grad_model(img_array)
+            x = sub_out
+            for layer in head_layers:
+                x = layer(x)
+            preds = x
+
+        pred_idx  = int(tf.argmax(preds[0]))
+        class_loss = preds[:, pred_idx]
+
+    grads = tape2.gradient(class_loss, conv_out_val)
+
+    if grads is None:
+        raise ValueError(
+            "Gradients are None. The conv layer output is not part of the "
+            "computation graph. Try a different layer name."
+        )
+
+    pooled_grads = tf.reduce_mean(grads, axis=(0, 1, 2))
+    heatmap      = conv_out_val[0] @ pooled_grads[..., tf.newaxis]
+    heatmap      = tf.squeeze(heatmap)
+    heatmap      = tf.maximum(heatmap, 0)
+    heatmap      = heatmap / (tf.math.reduce_max(heatmap) + 1e-8)
+
+    return heatmap.numpy(), pred_idx
+
+
+# ---------------------------------------------------------------------------
+# Full Grad-CAM visualisation
+# ---------------------------------------------------------------------------
+
+def generate_gradcam_overlay(model, img_path: str, last_conv_layer: str,
+                              image_size: tuple, class_names: list,
+                              save_path: str = None):
+    img       = load_img(img_path, target_size=image_size)
+    img_array = np.array(img) / 255.0
+    img_input = np.expand_dims(img_array, axis=0).astype(np.float32)
+
+    heatmap, pred_idx = get_gradcam_heatmap(model, img_input, last_conv_layer)
+
+    heatmap_resized = cv2.resize(heatmap, image_size)
+    heatmap_colored = cv2.cvtColor(
+        cv2.applyColorMap(np.uint8(255 * heatmap_resized), cv2.COLORMAP_JET),
+        cv2.COLOR_BGR2RGB
+    )
+    overlay = cv2.addWeighted(
+        np.uint8(255 * img_array), 0.6, heatmap_colored, 0.4, 0
+    )
+
+    probs = model.predict(img_input, verbose=0)[0]
+    conf  = probs[pred_idx] * 100
+
+    fig, axes = plt.subplots(1, 3, figsize=(13, 4))
+    axes[0].imshow(img)
+    axes[0].set_title("Original MRI")
+    axes[0].axis("off")
+
+    axes[1].imshow(heatmap_resized, cmap="jet")
+    axes[1].set_title("Grad-CAM Heatmap")
+    axes[1].axis("off")
+
+    axes[2].imshow(overlay)
+    axes[2].set_title(f"Pred: {class_names[pred_idx]} ({conf:.1f}%)")
+    axes[2].axis("off")
+
+    plt.suptitle(
+        f"Grad-CAM - {class_names[pred_idx].upper()}",
+        fontsize=14, fontweight="bold"
+    )
+    plt.tight_layout()
+
+    if save_path:
+        plt.savefig(save_path, bbox_inches="tight", dpi=100)
+    plt.show()
+    plt.close()
+
+    return pred_idx, conf, overlay

static/index.html

@@ -0,0 +1,679 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+<meta charset="UTF-8"/>
+<meta name="viewport" content="width=device-width, initial-scale=1.0"/>
+<title>NeuroScan — Brain Tumor Classification</title>
+<link href="https://fonts.googleapis.com/css2?family=DM+Mono:ital,wght@0,300;0,400;0,500;1,300&family=Syne:wght@400;600;700;800&display=swap" rel="stylesheet"/>
+<style>
+*,*::before,*::after{box-sizing:border-box;margin:0;padding:0}
+:root{
+  --bg:#0a0c10;
+  --bg2:#11141a;
+  --bg3:#181c24;
+  --bg4:#1e2330;
+  --border:#ffffff12;
+  --border2:#ffffff20;
+  --text:#e8eaf0;
+  --text2:#8b90a0;
+  --text3:#555b6e;
+  --accent:#00e5ff;
+  --accent2:#00b4cc;
+  --accent-dim:#00e5ff18;
+  --green:#00e676;
+  --green-dim:#00e67615;
+  --amber:#ffab40;
+  --amber-dim:#ffab4015;
+  --red:#ff5252;
+  --red-dim:#ff525215;
+  --purple:#ce93d8;
+  --purple-dim:#ce93d815;
+  --radius:10px;
+  --shadow:0 4px 24px #00000060;
+}
+html{scroll-behavior:smooth}
+body{background:var(--bg);color:var(--text);font-family:'DM Mono',monospace;font-size:14px;line-height:1.7;min-height:100vh;overflow-x:hidden}
+body::before{
+  content:'';position:fixed;inset:0;
+  background:repeating-linear-gradient(0deg,transparent,transparent 2px,#00000018 2px,#00000018 4px);
+  pointer-events:none;z-index:9999;opacity:.35
+}
+.shell{max-width:1100px;margin:0 auto;padding:0 24px 80px}
+header{
+  padding:40px 0 32px;
+  border-bottom:1px solid var(--border);
+  display:flex;align-items:center;justify-content:space-between;gap:16px;
+  flex-wrap:wrap
+}
+.logo{display:flex;align-items:center;gap:14px}
+.logo-mark{
+  width:42px;height:42px;border-radius:8px;
+  background:linear-gradient(135deg,var(--accent),#0066ff);
+  display:grid;place-items:center;font-size:20px;flex-shrink:0
+}
+.logo-text{font-family:'Syne',sans-serif;font-size:22px;font-weight:800;
+  background:linear-gradient(90deg,var(--accent),#80d8ff);
+  -webkit-background-clip:text;-webkit-text-fill-color:transparent;background-clip:text
+}
+.logo-sub{font-size:11px;color:var(--text3);letter-spacing:.12em;text-transform:uppercase;margin-top:-2px}
+.header-badges{display:flex;gap:8px;flex-wrap:wrap}
+.badge{
+  padding:4px 10px;border-radius:20px;font-size:11px;letter-spacing:.06em;
+  border:1px solid var(--border2);color:var(--text2);background:var(--bg3)
+}
+.badge.live{border-color:#00e67640;color:var(--green);background:var(--green-dim)}
+.badge.live::before{content:'● ';font-size:8px}
+.section-title{
+  font-family:'Syne',sans-serif;font-size:12px;font-weight:600;
+  letter-spacing:.14em;text-transform:uppercase;
+  color:var(--accent);margin-bottom:16px;
+  display:flex;align-items:center;gap:8px
+}
+.section-title::before{content:'';width:20px;height:1px;background:var(--accent)}
+.grid-2{display:grid;grid-template-columns:1fr 1fr;gap:20px}
+.grid-3{display:grid;grid-template-columns:repeat(3,1fr);gap:16px}
+@media(max-width:700px){.grid-2,.grid-3{grid-template-columns:1fr}}
+.card{
+  background:var(--bg2);border:1px solid var(--border);
+  border-radius:var(--radius);padding:24px;
+}
+.card-sm{padding:16px 20px}
+#upload-zone{
+  border:2px dashed var(--border2);border-radius:var(--radius);
+  padding:48px 24px;text-align:center;cursor:pointer;
+  transition:border-color .2s,background .2s;position:relative
+}
+#upload-zone:hover,#upload-zone.drag{border-color:var(--accent);background:var(--accent-dim)}
+#upload-zone input{position:absolute;inset:0;opacity:0;cursor:pointer;width:100%;height:100%}
+.upload-icon{font-size:36px;margin-bottom:12px;opacity:.5}
+.upload-label{font-family:'Syne',sans-serif;font-size:15px;font-weight:600;color:var(--text)}
+.upload-hint{font-size:12px;color:var(--text3);margin-top:6px}
+#preview-area{display:none;gap:12px;flex-direction:column}
+.preview-img-wrap{position:relative;border-radius:8px;overflow:hidden;background:var(--bg3)}
+.preview-img-wrap img{width:100%;display:block;border-radius:8px;max-height:260px;object-fit:contain}
+.img-filename{font-size:11px;color:var(--text3);margin-top:6px;word-break:break-all}
+.backend-grid{display:grid;grid-template-columns:1fr 1fr;gap:8px;margin-bottom:20px}
+.backend-btn{
+  padding:10px 12px;border-radius:8px;border:1px solid var(--border2);
+  background:var(--bg3);color:var(--text2);cursor:pointer;
+  font-family:'DM Mono',monospace;font-size:12px;text-align:left;
+  transition:border-color .15s,background .15s,color .15s;line-height:1.4
+}
+.backend-btn:hover{border-color:var(--accent2);color:var(--text)}
+.backend-btn.active{border-color:var(--accent);background:var(--accent-dim);color:var(--accent)}
+.backend-btn.disabled{
+  opacity:.35;cursor:not-allowed;pointer-events:none
+}
+.backend-btn .b-name{font-weight:500;display:block}
+.backend-btn .b-tag{font-size:10px;opacity:.6;margin-top:2px}
+#analyse-btn{
+  width:100%;padding:14px;border-radius:8px;border:none;cursor:pointer;
+  font-family:'Syne',sans-serif;font-size:14px;font-weight:700;
+  letter-spacing:.08em;text-transform:uppercase;
+  background:linear-gradient(90deg,var(--accent),#0080ff);
+  color:#000;transition:opacity .2s,transform .1s
+}
+#analyse-btn:hover{opacity:.9}
+#analyse-btn:active{transform:scale(.98)}
+#analyse-btn:disabled{opacity:.35;cursor:not-allowed}
+#results-panel{display:none}
+.prediction-hero{
+  display:flex;align-items:center;gap:16px;
+  padding:20px;border-radius:8px;margin-bottom:20px
+}
+.prediction-hero.glioma{background:var(--red-dim);border:1px solid #ff525230}
+.prediction-hero.meningioma{background:var(--amber-dim);border:1px solid #ffab4030}
+.prediction-hero.notumor{background:var(--green-dim);border:1px solid #00e67630}
+.prediction-hero.pituitary{background:var(--purple-dim);border:1px solid #ce93d830}
+.pred-class{
+  font-family:'Syne',sans-serif;font-size:22px;font-weight:800;
+  text-transform:uppercase;letter-spacing:.06em
+}
+.pred-class.glioma{color:var(--red)}
+.pred-class.meningioma{color:var(--amber)}
+.pred-class.notumor{color:var(--green)}
+.pred-class.pituitary{color:var(--purple)}
+.pred-conf{font-size:13px;color:var(--text2);margin-top:2px}
+.pred-badge{
+  margin-left:auto;padding:6px 14px;border-radius:20px;
+  font-size:11px;font-weight:500;flex-shrink:0
+}
+.pred-badge.high{background:var(--green-dim);color:var(--green);border:1px solid #00e67640}
+.pred-badge.mid{background:var(--amber-dim);color:var(--amber);border:1px solid #ffab4040}
+.pred-badge.low{background:var(--red-dim);color:var(--red);border:1px solid #ff525240}
+.prob-row{margin-bottom:10px}
+.prob-header{display:flex;justify-content:space-between;margin-bottom:4px;font-size:12px}
+.prob-name{color:var(--text2)}
+.prob-val{color:var(--text)}
+.prob-track{height:6px;background:var(--bg4);border-radius:3px;overflow:hidden}
+.prob-fill{height:100%;border-radius:3px;transition:width .8s cubic-bezier(.4,0,.2,1)}
+.prob-fill.glioma{background:var(--red)}
+.prob-fill.meningioma{background:var(--amber)}
+.prob-fill.notumor{background:var(--green)}
+.prob-fill.pituitary{background:var(--purple)}
+.stats-row{display:grid;grid-template-columns:repeat(3,1fr);gap:12px;margin-top:16px}
+.stat-card{
+  background:var(--bg3);border:1px solid var(--border);
+  border-radius:8px;padding:14px;text-align:center
+}
+.stat-val{font-family:'Syne',sans-serif;font-size:18px;font-weight:700;color:var(--accent)}
+.stat-lbl{font-size:11px;color:var(--text3);margin-top:2px;text-transform:uppercase;letter-spacing:.08em}
+.gradcam-grid{display:grid;grid-template-columns:1fr 1fr;gap:12px;margin-top:16px}
+.gradcam-item{text-align:center}
+.gradcam-item img{width:100%;border-radius:8px;display:block}
+.gradcam-lbl{font-size:11px;color:var(--text3);margin-top:6px;text-transform:uppercase;letter-spacing:.08em}
+.model-table{width:100%;border-collapse:collapse;font-size:12px}
+.model-table th{color:var(--text3);font-weight:400;text-align:left;padding:8px 10px;
+  border-bottom:1px solid var(--border);text-transform:uppercase;letter-spacing:.08em}
+.model-table td{padding:10px;border-bottom:1px solid var(--border)}
+.model-table tr:last-child td{border-bottom:none}
+.model-table tr:hover td{background:var(--bg3)}
+.tag{
+  padding:2px 8px;border-radius:4px;font-size:10px;
+  background:var(--accent-dim);color:var(--accent);border:1px solid var(--accent)30
+}
+.tag.green{background:var(--green-dim);color:var(--green);border-color:#00e67630}
+.tag.amber{background:var(--amber-dim);color:var(--amber);border-color:#ffab4030}
+.spinner{display:none;width:20px;height:20px;border:2px solid #ffffff20;
+  border-top-color:var(--accent);border-radius:50%;animation:spin .7s linear infinite}
+@keyframes spin{to{transform:rotate(360deg)}}
+.btn-inner{display:flex;align-items:center;justify-content:center;gap:10px}
+#toast{
+  position:fixed;bottom:28px;right:28px;z-index:1000;
+  padding:12px 20px;border-radius:8px;font-size:13px;
+  background:var(--bg3);border:1px solid var(--border2);
+  transform:translateY(80px);opacity:0;transition:transform .3s,opacity .3s
+}
+#toast.show{transform:translateY(0);opacity:1}
+#toast.error{border-color:#ff525240;color:var(--red)}
+#toast.success{border-color:#00e67640;color:var(--green)}
+.tabs{display:flex;gap:4px;border-bottom:1px solid var(--border);margin-bottom:20px}
+.tab{
+  padding:8px 16px;cursor:pointer;font-size:12px;
+  color:var(--text3);border-bottom:2px solid transparent;
+  margin-bottom:-1px;transition:color .15s,border-color .15s;
+  text-transform:uppercase;letter-spacing:.08em
+}
+.tab.active{color:var(--accent);border-bottom-color:var(--accent)}
+.tab-panel{display:none}
+.tab-panel.active{display:block}
+.info-block{
+  background:var(--bg3);border:1px solid var(--border);
+  border-radius:8px;padding:14px 16px;font-size:12px;color:var(--text2);
+  line-height:1.8;margin-top:16px
+}
+.info-block strong{color:var(--text)}
+.divider{height:1px;background:var(--border);margin:28px 0}
+.compare-row{
+  display:flex;align-items:center;gap:12px;padding:10px 0;
+  border-bottom:1px solid var(--border)
+}
+.compare-row:last-child{border-bottom:none}
+.compare-name{width:180px;flex-shrink:0;font-size:12px;color:var(--text2)}
+.compare-bar-wrap{flex:1;height:8px;background:var(--bg4);border-radius:4px;overflow:hidden}
+.compare-bar{height:100%;border-radius:4px;background:var(--accent);transition:width .9s}
+.compare-val{width:60px;text-align:right;font-size:12px;color:var(--text);flex-shrink:0}
+@keyframes fadeUp{from{opacity:0;transform:translateY(12px)}to{opacity:1;transform:none}}
+.fade-in{animation:fadeUp .4s ease both}
+</style>
+</head>
+<body>
+<div class="shell">
+
+  <header>
+    <div class="logo">
+      <div class="logo-mark">🧠</div>
+      <div>
+        <div class="logo-text">NeuroScan</div>
+        <div class="logo-sub">Brain Tumor Classification · v1.0</div>
+      </div>
+    </div>
+    <div class="header-badges">
+      <span class="badge live" id="api-status">API Connected</span>
+      <span class="badge">TF 2.10</span>
+      <span class="badge">ONNX FP32</span>
+      <span class="badge">Grad-CAM XAI</span>
+    </div>
+  </header>
+
+  <div style="height:36px"></div>
+
+  <div class="grid-2" style="align-items:start">
+
+    <div>
+      <div class="section-title">MRI Input</div>
+      <div class="card" style="margin-bottom:20px">
+        <div id="upload-zone">
+          <input type="file" id="file-input" accept="image/*"/>
+          <div class="upload-icon">⬆</div>
+          <div class="upload-label">Drop MRI image here</div>
+          <div class="upload-hint">PNG, JPG, JPEG — any brain MRI scan</div>
+        </div>
+        <div id="preview-area" style="margin-top:16px">
+          <div class="preview-img-wrap">
+            <img id="preview-img" src="" alt="MRI preview"/>
+          </div>
+          <div class="img-filename" id="img-filename"></div>
+        </div>
+      </div>
+
+      <div class="section-title">Inference Backend</div>
+      <div class="card" style="margin-bottom:20px">
+        <div class="backend-grid">
+          <button class="backend-btn active" data-backend="tensorflow" onclick="selectBackend(this)">
+            <span class="b-name">TensorFlow</span>
+            <span class="b-tag">FP32 · Grad-CAM</span>
+          </button>
+          <button class="backend-btn" data-backend="onnx_fp32" onclick="selectBackend(this)">
+            <span class="b-name">ONNX FP32</span>
+            <span class="b-tag">Full precision</span>
+          </button>
+          <button class="backend-btn" id="dynamic-btn" data-backend="onnx_dynamic" onclick="selectBackend(this)">
+            <span class="b-name">Dynamic INT8</span>
+            <span class="b-tag">Quantized · faster</span>
+          </button>
+          <button class="backend-btn" data-backend="onnx_static" onclick="selectBackend(this)">
+            <span class="b-name">Static INT8</span>
+            <span class="b-tag">Calibrated · smallest</span>
+          </button>
+        </div>
+
+        <div id="gradcam-toggle-wrap" style="display:flex;align-items:center;gap:10px;margin-bottom:20px">
+          <label style="display:flex;align-items:center;gap:8px;cursor:pointer;font-size:12px;color:var(--text2)">
+            <div style="position:relative;width:36px;height:20px">
+              <input type="checkbox" id="gradcam-toggle" style="opacity:0;position:absolute;width:100%;height:100%;cursor:pointer;margin:0" onchange="updateGradcamUI()"/>
+              <div id="toggle-track" style="width:36px;height:20px;background:var(--bg4);border-radius:10px;border:1px solid var(--border2);transition:background .2s"></div>
+              <div id="toggle-thumb" style="position:absolute;top:3px;left:3px;width:14px;height:14px;background:var(--text3);border-radius:50%;transition:transform .2s,background .2s"></div>
+            </div>
+            Show Grad-CAM heatmap
+          </label>
+          <span id="gradcam-note" style="font-size:11px;color:var(--text3)">(TF backend only)</span>
+        </div>
+
+        <button id="analyse-btn" onclick="analyse()" disabled>
+          <div class="btn-inner">
+            <div class="spinner" id="spinner"></div>
+            <span id="btn-label">Upload an image first</span>
+          </div>
+        </button>
+      </div>
+
+      <div class="section-title">Quantization Info</div>
+      <div class="card card-sm">
+        <div class="tabs">
+          <div class="tab active" onclick="switchTab(this,'q-dynamic')">Dynamic INT8</div>
+          <div class="tab" onclick="switchTab(this,'q-static')">Static INT8</div>
+          <div class="tab" onclick="switchTab(this,'q-compare')">Compare</div>
+        </div>
+        <div id="q-dynamic" class="tab-panel active">
+          <div class="info-block">
+            <strong>Dynamic Quantization</strong> converts model <strong>weights</strong> to INT8 at export time. Activations remain FP32 at runtime and are quantized on-the-fly. No calibration data needed.
+          </div>
+        </div>
+        <div id="q-static" class="tab-panel">
+          <div class="info-block">
+            <strong>Static Quantization</strong> quantizes both <strong>weights and activations</strong> to INT8. Requires calibration data. It can be smaller and faster, but accuracy may vary by architecture.
+          </div>
+        </div>
+        <div id="q-compare" class="tab-panel">
+          <div id="benchmark-data" style="padding:4px 0">
+            <div style="color:var(--text3);font-size:12px">Loading benchmark...</div>
+          </div>
+        </div>
+      </div>
+    </div>
+
+    <div>
+      <div class="section-title">Analysis Results</div>
+
+      <div id="placeholder" class="card" style="text-align:center;padding:60px 24px">
+        <div style="font-size:48px;opacity:.2;margin-bottom:16px">🔬</div>
+        <div style="font-family:'Syne',sans-serif;font-size:15px;color:var(--text3)">
+          Upload an MRI scan and click analyse
+        </div>
+        <div style="font-size:12px;color:var(--text3);margin-top:8px;opacity:.6">
+          Supports glioma · meningioma · no tumor · pituitary
+        </div>
+      </div>
+
+      <div id="results-panel" class="fade-in">
+        <div id="pred-hero" class="prediction-hero card">
+          <div>
+            <div class="pred-class" id="pred-class-text"></div>
+            <div class="pred-conf" id="pred-conf-text"></div>
+          </div>
+          <div class="pred-badge" id="pred-badge"></div>
+        </div>
+
+        <div class="card" style="margin-bottom:16px">
+          <div class="section-title">Class Probabilities</div>
+          <div id="prob-bars"></div>
+          <div class="stats-row" id="stats-row">
+            <div class="stat-card">
+              <div class="stat-val" id="stat-conf">—</div>
+              <div class="stat-lbl">Confidence</div>
+            </div>
+            <div class="stat-card">
+              <div class="stat-val" id="stat-latency">—</div>
+              <div class="stat-lbl">Latency</div>
+            </div>
+            <div class="stat-card">
+              <div class="stat-val" id="stat-backend">—</div>
+              <div class="stat-lbl">Backend</div>
+            </div>
+          </div>
+        </div>
+
+        <div class="card" id="gradcam-card" style="display:none;margin-bottom:16px">
+          <div class="section-title">Grad-CAM Explanation</div>
+          <div class="gradcam-grid">
+            <div class="gradcam-item">
+              <img id="gradcam-overlay-img" src="" alt="Grad-CAM overlay"/>
+              <div class="gradcam-lbl">Activation Overlay</div>
+            </div>
+            <div class="gradcam-item">
+              <img id="gradcam-heatmap-img" src="" alt="Heatmap"/>
+              <div class="gradcam-lbl">Raw Heatmap</div>
+            </div>
+          </div>
+          <div class="info-block" style="margin-top:12px">
+            <strong>Grad-CAM</strong> highlights regions the model focused on.
+          </div>
+        </div>
+
+        <div class="card card-sm">
+          <div class="section-title">Class Reference</div>
+          <table class="model-table">
+            <thead><tr>
+              <th>Class</th><th>Description</th><th>Severity</th>
+            </tr></thead>
+            <tbody>
+              <tr><td><span style="color:var(--red)">Glioma</span></td>
+                  <td style="color:var(--text2)">Tumor of glial cells</td>
+                  <td><span class="tag">High</span></td></tr>
+              <tr><td><span style="color:var(--amber)">Meningioma</span></td>
+                  <td style="color:var(--text2)">Tumor of meninges</td>
+                  <td><span class="tag amber">Medium</span></td></tr>
+              <tr><td><span style="color:var(--green)">No Tumor</span></td>
+                  <td style="color:var(--text2)">Normal brain MRI</td>
+                  <td><span class="tag green">None</span></td></tr>
+              <tr><td><span style="color:var(--purple)">Pituitary</span></td>
+                  <td style="color:var(--text2)">Pituitary gland tumor</td>
+                  <td><span class="tag amber">Medium</span></td></tr>
+            </tbody>
+          </table>
+        </div>
+      </div>
+    </div>
+
+  </div>
+
+  <div class="divider"></div>
+
+  <div class="section-title">Model Performance Comparison</div>
+  <div class="card">
+    <div id="model-compare">
+      <div style="color:var(--text3);font-size:12px">Loading model info...</div>
+    </div>
+  </div>
+
+</div>
+
+<div id="toast"></div>
+
+<script>
+const API = '';
+let selectedBackend = 'tensorflow';
+let selectedFile = null;
+let healthInfo = null;
+
+async function checkHealth(){
+  try{
+    const r = await fetch(`${API}/health`);
+    if(!r.ok) throw new Error();
+    const d = await r.json();
+    healthInfo = d;
+    document.getElementById('api-status').textContent = `API · ${d.loaded_backends.length} backends`;
+
+    const failed = d.failed_backends || {};
+    if (failed.onnx_dynamic) {
+      const btn = document.getElementById('dynamic-btn');
+      if (btn) {
+        btn.classList.add('disabled');
+        btn.title = 'Dynamic INT8 is not available in this runtime';
+      }
+      if (selectedBackend === 'onnx_dynamic') {
+        selectedBackend = 'tensorflow';
+        document.querySelectorAll('.backend-btn').forEach(b => b.classList.remove('active'));
+        document.querySelector('.backend-btn[data-backend="tensorflow"]').classList.add('active');
+      }
+    }
+  } catch(e){
+    const el = document.getElementById('api-status');
+    el.textContent = 'API Offline';
+    el.classList.remove('live');
+  }
+}
+
+async function loadModelInfo(){
+  try{
+    const r = await fetch(`${API}/models/info`);
+    if(!r.ok) throw new Error();
+    const d = await r.json();
+    const results = d.all_results || {};
+    const values = Object.values(results);
+    const max = values.length ? Math.max(...values) : null;
+    let html = '';
+    for(const [name, acc] of Object.entries(results)){
+      const pct = (acc*100).toFixed(2);
+      const isB = acc === max;
+      html += `<div class="compare-row">
+        <div class="compare-name">${name}${isB ? ' <span class="tag green">best</span>' : ''}</div>
+        <div class="compare-bar-wrap"><div class="compare-bar" style="width:${pct}%;background:${isB?'var(--green)':'var(--accent)'}"></div></div>
+        <div class="compare-val">${pct}%</div>
+      </div>`;
+    }
+    document.getElementById('model-compare').innerHTML = html || '<div style="color:var(--text3);font-size:12px">No data</div>';
+  } catch(e){
+    document.getElementById('model-compare').innerHTML = '<div style="color:var(--text3);font-size:12px">Run train.py to generate model info.</div>';
+  }
+}
+
+async function loadBenchmark(){
+  try{
+    const r = await fetch(`${API}/benchmark`);
+    if(!r.ok) throw new Error();
+    const d = await r.json();
+    let html = '<table class="model-table"><thead><tr><th>Format</th><th>Accuracy</th><th>Latency</th><th>Size</th></tr></thead><tbody>';
+    for(const [name, v] of Object.entries(d)){
+      const acc = v.accuracy !== undefined ? (v.accuracy*100).toFixed(2)+'%' : '—';
+      const lat = v.latency_ms !== undefined ? v.latency_ms.toFixed(1)+' ms' : '—';
+      const size = v.size_mb !== null && v.size_mb !== undefined ? v.size_mb.toFixed(1)+' MB' : '—';
+      html += `<tr><td>${name}</td><td>${acc}</td><td>${lat}</td><td>${size}</td></tr>`;
+    }
+    html += '</tbody></table>';
+    document.getElementById('benchmark-data').innerHTML = html;
+  } catch(e){
+    document.getElementById('benchmark-data').innerHTML = '<div style="color:var(--text3);font-size:12px">Run export_onnx.py to generate benchmark data.</div>';
+  }
+}
+
+const fileInput  = document.getElementById('file-input');
+const uploadZone = document.getElementById('upload-zone');
+
+fileInput.addEventListener('change', e => {
+  if(e.target.files[0]) handleFile(e.target.files[0]);
+});
+uploadZone.addEventListener('dragover', e => { e.preventDefault(); uploadZone.classList.add('drag'); });
+uploadZone.addEventListener('dragleave', () => uploadZone.classList.remove('drag'));
+uploadZone.addEventListener('drop', e => {
+  e.preventDefault();
+  uploadZone.classList.remove('drag');
+  if(e.dataTransfer.files[0]) handleFile(e.dataTransfer.files[0]);
+});
+
+function handleFile(file){
+  selectedFile = file;
+  const reader = new FileReader();
+  reader.onload = ev => {
+    document.getElementById('preview-img').src = ev.target.result;
+    document.getElementById('img-filename').textContent = file.name;
+    document.getElementById('preview-area').style.display = 'flex';
+    document.getElementById('analyse-btn').disabled = false;
+    document.getElementById('btn-label').textContent = 'Analyse MRI';
+  };
+  reader.readAsDataURL(file);
+}
+
+function selectBackend(btn){
+  if (btn.classList.contains('disabled')) return;
+  document.querySelectorAll('.backend-btn').forEach(b => b.classList.remove('active'));
+  btn.classList.add('active');
+  selectedBackend = btn.dataset.backend;
+  updateGradcamUI();
+}
+
+function updateGradcamUI(){
+  const isTF = selectedBackend === 'tensorflow';
+  const toggle = document.getElementById('gradcam-toggle');
+  const track = document.getElementById('toggle-track');
+  const thumb = document.getElementById('toggle-thumb');
+  const note = document.getElementById('gradcam-note');
+  note.style.opacity = isTF ? '0' : '1';
+  if(!isTF){ toggle.checked = false; }
+  toggle.disabled = !isTF;
+  const on = toggle.checked && isTF;
+  track.style.background = on ? 'var(--accent2)' : 'var(--bg4)';
+  thumb.style.transform = on ? 'translateX(16px)' : 'none';
+  thumb.style.background = on ? '#000' : 'var(--text3)';
+}
+
+document.getElementById('gradcam-toggle').addEventListener('change', updateGradcamUI);
+
+async function analyse(){
+  if(!selectedFile) return;
+
+  const btn = document.getElementById('analyse-btn');
+  const spinner = document.getElementById('spinner');
+  const label = document.getElementById('btn-label');
+  btn.disabled = true;
+  spinner.style.display = 'block';
+  label.textContent = 'Analysing...';
+
+  const useGradcam = document.getElementById('gradcam-toggle').checked && selectedBackend === 'tensorflow';
+
+  const formData = new FormData();
+  formData.append('file', selectedFile);
+
+  const endpoint = useGradcam
+    ? `${API}/predict/gradcam`
+    : selectedBackend === 'tensorflow' ? `${API}/predict`
+    : selectedBackend === 'onnx_fp32' ? `${API}/predict/onnx`
+    : selectedBackend === 'onnx_dynamic' ? `${API}/predict/dynamic`
+    : `${API}/predict/static`;
+
+  try{
+    const r = await fetch(endpoint, { method:'POST', body: formData });
+    if(!r.ok){
+      let message = 'API error';
+      try{
+        const err = await r.json();
+        message = err.detail || message;
+      } catch(_) {}
+      throw new Error(message);
+    }
+    const data = await r.json();
+    renderResults(data, useGradcam);
+    showToast('Analysis complete', 'success');
+  } catch(e){
+    showToast(`Error: ${e.message}`, 'error');
+  } finally{
+    btn.disabled = false;
+    spinner.style.display = 'none';
+    label.textContent = 'Analyse MRI';
+  }
+}
+
+function renderResults(data, hasGradcam){
+  const cls = data.predicted_class.toLowerCase().replace(' ','');
+  const conf = data.confidence;
+  const confPct = `${conf.toFixed(1)}%`;
+
+  document.getElementById('placeholder').style.display = 'none';
+  document.getElementById('results-panel').style.display = 'block';
+  document.getElementById('results-panel').classList.add('fade-in');
+
+  const hero = document.getElementById('pred-hero');
+  hero.className = `prediction-hero card ${cls}`;
+
+  const classText = document.getElementById('pred-class-text');
+  classText.className = `pred-class ${cls}`;
+  classText.textContent = data.predicted_class.toUpperCase();
+
+  document.getElementById('pred-conf-text').textContent =
+    `Confidence: ${confPct} · via ${data.backend}`;
+
+  const badge = document.getElementById('pred-badge');
+  const level = conf >= 80 ? 'high' : conf >= 50 ? 'mid' : 'low';
+  badge.className = `pred-badge ${level}`;
+  badge.textContent = conf >= 80 ? 'High confidence' : conf >= 50 ? 'Moderate' : 'Low confidence';
+
+  const probs = data.all_probabilities;
+  let barsHtml = '';
+  for(const [name, p] of Object.entries(probs).sort((a,b) => b[1]-a[1])){
+    const clsKey = name.toLowerCase().replace(' ','');
+    const pct = p.toFixed(1);
+    barsHtml += `<div class="prob-row">
+      <div class="prob-header">
+        <span class="prob-name">${name}</span>
+        <span class="prob-val">${pct}%</span>
+      </div>
+      <div class="prob-track">
+        <div class="prob-fill ${clsKey}" style="width:${p}%"></div>
+      </div>
+    </div>`;
+  }
+  document.getElementById('prob-bars').innerHTML = barsHtml;
+
+  document.getElementById('stat-conf').textContent = confPct;
+  document.getElementById('stat-latency').textContent = data.latency_ms ? `${data.latency_ms}ms` : '—';
+  const backendShort = {
+    tensorflow:'TF FP32',
+    onnx_fp32:'ONNX FP32',
+    onnx_dynamic:'Dynamic INT8',
+    onnx_static:'Static INT8'
+  }[data.backend] || data.backend;
+  document.getElementById('stat-backend').textContent = backendShort;
+
+  const gcCard = document.getElementById('gradcam-card');
+  if(hasGradcam && data.gradcam_b64){
+    document.getElementById('gradcam-overlay-img').src = `data:image/png;base64,${data.gradcam_b64}`;
+    document.getElementById('gradcam-heatmap-img').src = `data:image/png;base64,${data.heatmap_b64}`;
+    gcCard.style.display = 'block';
+  } else {
+    gcCard.style.display = 'none';
+  }
+}
+
+function switchTab(tab, panelId){
+  const parent = tab.closest('.card');
+  parent.querySelectorAll('.tab').forEach(t => t.classList.remove('active'));
+  parent.querySelectorAll('.tab-panel').forEach(p => p.classList.remove('active'));
+  tab.classList.add('active');
+  document.getElementById(panelId).classList.add('active');
+}
+
+function showToast(msg, type='success'){
+  const t = document.getElementById('toast');
+  t.textContent = msg;
+  t.className = `show ${type}`;
+  setTimeout(() => t.className = '', 3500);
+}
+
+checkHealth();
+loadModelInfo();
+loadBenchmark();
+updateGradcamUI();
+</script>
+</body>
+</html>

train.py

@@ -0,0 +1,406 @@
+# train.py — training loop with MLflow + DagsHub tracking
+
+import os
+import numpy as np
+import tensorflow as tf
+import mlflow
+import mlflow.keras
+from mlflow.models.signature import infer_signature
+from tensorflow.keras.callbacks import EarlyStopping, ReduceLROnPlateau, ModelCheckpoint
+from tensorflow.keras import optimizers
+
+from src.utils import get_logger, load_config, plot_history, plot_comparison
+from src.data_loader import get_data_generators
+from src.models import (build_baseline_cnn, build_mobilenet_tl, build_mobilenet_finetuned,
+                    build_efficientnet, build_optuna_cnn, compile_model)
+import optuna
+
+logger = get_logger("train")
+
+
+# ---------------------------------------------------------------------------
+# MLflow setup
+# ---------------------------------------------------------------------------
+
+def setup_mlflow(cfg: dict):
+    ml = cfg["mlflow"]
+    os.environ["MLFLOW_TRACKING_USERNAME"] = ml["dagshub_username"]
+    os.environ["MLFLOW_TRACKING_PASSWORD"] = ml["dagshub_token"]
+    uri = f"https://dagshub.com/{ml['dagshub_username']}/{ml['dagshub_repo']}.mlflow"
+    mlflow.set_tracking_uri(uri)
+    mlflow.set_experiment(ml["experiment_name"])
+    logger.info(f"MLflow → DagsHub: {uri}")
+
+
+def log_epoch_metrics(history):
+    """Log per-epoch metrics to the active MLflow run."""
+    for epoch, (ta, va, tl, vl) in enumerate(zip(
+        history.history["accuracy"], history.history["val_accuracy"],
+        history.history["loss"],     history.history["val_loss"],
+    )):
+        mlflow.log_metrics({
+            "train_accuracy" : float(ta),
+            "val_accuracy"   : float(va),
+            "train_loss"     : float(tl),
+            "val_loss"       : float(vl),
+        }, step=epoch)
+
+
+def get_callbacks(cfg: dict, checkpoint_path: str):
+    """
+    Standard callbacks for all models.
+    save_format='h5' is required to avoid EagerTensor JSON
+    serialization crash with EfficientNet in TF 2.10.
+    """
+    t = cfg["training"]
+    return [
+        EarlyStopping(
+            monitor             = "val_accuracy",
+            patience            = t["early_stopping_patience"],
+            restore_best_weights= True,
+            verbose             = 1,
+        ),
+        ReduceLROnPlateau(
+            monitor  = "val_loss",
+            factor   = t["reduce_lr_factor"],
+            patience = t["reduce_lr_patience"],
+            min_lr   = t["min_lr"],
+            verbose  = 1,
+        ),
+        ModelCheckpoint(
+            filepath        = checkpoint_path,
+            monitor         = "val_accuracy",
+            save_best_only  = True,
+            save_format     = "h5",          # ← fixes EagerTensor crash
+            verbose         = 0,
+        ),
+    ]
+
+
+# ---------------------------------------------------------------------------
+# Training functions
+# ---------------------------------------------------------------------------
+
+def train_baseline(cfg, train_data, val_data):
+    image_size = tuple(cfg["data"]["image_size"])
+    epochs     = cfg["training"]["epochs"]
+    save_dir   = cfg["models"]["save_dir"]
+    os.makedirs(save_dir, exist_ok=True)
+
+    model = compile_model(build_baseline_cnn(image_size=image_size))
+
+    with mlflow.start_run(run_name="Baseline_CNN"):
+        mlflow.log_params({
+            "model_type" : "Baseline CNN",
+            "filters"    : "32-64-128",
+            "optimizer"  : "adam",
+            "lr"         : 0.001,
+            "epochs"     : epochs,
+            "batch_size" : cfg["data"]["batch_size"],
+        })
+        history = model.fit(
+            train_data, epochs=epochs, validation_data=val_data,
+            callbacks=get_callbacks(cfg, f"{save_dir}/baseline_best.h5")
+        )
+        log_epoch_metrics(history)
+        mlflow.log_metrics({
+            "best_val_accuracy" : float(max(history.history["val_accuracy"])),
+            "best_val_loss"     : float(min(history.history["val_loss"])),
+        })
+        mlflow.keras.log_model(model, "baseline_cnn")
+        logger.info("Baseline CNN training complete.")
+    return model, history
+
+
+def train_transfer_learning(cfg, train_data, val_data):
+    image_size = tuple(cfg["data"]["image_size"])
+    epochs     = cfg["training"]["epochs"]
+    save_dir   = cfg["models"]["save_dir"]
+
+    model = compile_model(build_mobilenet_tl(image_size=image_size))
+
+    with mlflow.start_run(run_name="Transfer_Learning_MobileNetV2"):
+        mlflow.log_params({
+            "model_type"  : "MobileNetV2 TL",
+            "base_frozen" : True,
+            "optimizer"   : "adam",
+            "lr"          : 0.001,
+            "epochs"      : epochs,
+        })
+        history = model.fit(
+            train_data, epochs=epochs, validation_data=val_data,
+            callbacks=get_callbacks(cfg, f"{save_dir}/tl_best.h5")
+        )
+        log_epoch_metrics(history)
+        mlflow.log_metrics({
+            "best_val_accuracy" : float(max(history.history["val_accuracy"])),
+            "best_val_loss"     : float(min(history.history["val_loss"])),
+        })
+        mlflow.keras.log_model(model, "transfer_learning")
+        logger.info("Transfer Learning training complete.")
+    return model, history
+
+
+def train_finetuned(cfg, tl_model, train_data, val_data):
+    epochs   = cfg["training"]["epochs"]
+    save_dir = cfg["models"]["save_dir"]
+
+    build_mobilenet_finetuned(tl_model.layers[0], unfreeze_last=20)
+    compile_model(tl_model, lr=1e-5)
+
+    with mlflow.start_run(run_name="Fine_Tuned_MobileNetV2"):
+        mlflow.log_params({
+            "model_type"      : "MobileNetV2 Fine-Tuned",
+            "unfrozen_layers" : 20,
+            "lr"              : 1e-5,
+            "epochs"          : epochs,
+        })
+        history = tl_model.fit(
+            train_data, epochs=epochs, validation_data=val_data,
+            callbacks=get_callbacks(cfg, f"{save_dir}/ft_best.h5")
+        )
+        log_epoch_metrics(history)
+        mlflow.log_metrics({
+            "best_val_accuracy" : float(max(history.history["val_accuracy"])),
+            "best_val_loss"     : float(min(history.history["val_loss"])),
+        })
+        mlflow.keras.log_model(tl_model, "fine_tuned")
+        logger.info("Fine-Tuned training complete.")
+    return tl_model, history
+
+
+def train_efficientnet(cfg, train_data, val_data):
+    """
+    EfficientNetB0 in TF 2.10 crashes ModelCheckpoint because its internal
+    rescaling layer stores weights as EagerTensors which cannot be JSON-serialized
+    during checkpoint saving.
+
+    Fix: use a custom callback that calls model.save_weights() instead of
+    model.save() — weights-only saving never touches the model config JSON,
+    so EagerTensors are never serialized.
+    """
+    image_size = tuple(cfg["data"]["image_size"])
+    epochs     = cfg["training"]["epochs"]
+    save_dir   = cfg["models"]["save_dir"]
+    t          = cfg["training"]
+
+    model = build_efficientnet(image_size=image_size)
+    model.compile(
+        optimizer = optimizers.Adam(learning_rate=0.001),
+        loss      = "categorical_crossentropy",
+        metrics   = ["accuracy"],
+    )
+
+    # ── Custom checkpoint: saves weights only (no JSON config serialization) ──
+    weights_path   = os.path.join(save_dir, "effnet_best_weights.h5")
+    best_val_acc   = [0.0]    # mutable container so inner class can write to it
+
+    class WeightsCheckpoint(tf.keras.callbacks.Callback):
+        def on_epoch_end(self, epoch, logs=None):
+            va = float(logs.get("val_accuracy", 0.0))
+            if va > best_val_acc[0]:
+                best_val_acc[0] = va
+                self.model.save_weights(weights_path)
+                logger.info(f"  EfficientNet weights saved (val_acc={va:.4f})")
+
+    with mlflow.start_run(run_name="EfficientNetB0_TL"):
+        mlflow.log_params({
+            "model_type"  : "EfficientNetB0",
+            "base_frozen" : True,
+            "lr"          : 0.001,
+            "epochs"      : epochs,
+        })
+
+        history = model.fit(
+            train_data,
+            epochs          = epochs,
+            validation_data = val_data,
+            callbacks       = [
+                EarlyStopping(
+                    monitor              = "val_accuracy",
+                    patience             = t["early_stopping_patience"],
+                    restore_best_weights = True,
+                    verbose              = 1,
+                ),
+                ReduceLROnPlateau(
+                    monitor  = "val_loss",
+                    factor   = t["reduce_lr_factor"],
+                    patience = t["reduce_lr_patience"],
+                    min_lr   = t["min_lr"],
+                    verbose  = 1,
+                ),
+                WeightsCheckpoint(),   # ← replaces ModelCheckpoint entirely
+            ],
+        )
+
+        log_epoch_metrics(history)
+        mlflow.log_metrics({
+            "best_val_accuracy" : float(max(history.history["val_accuracy"])),
+            "best_val_loss"     : float(min(history.history["val_loss"])),
+        })
+
+        # Restore best weights
+        if os.path.exists(weights_path):
+            model.load_weights(weights_path)
+            logger.info("Best EfficientNet weights restored.")
+
+        # mlflow.keras.log_model crashes for EfficientNetB0 in TF 2.10 because
+        # mlflow internally calls model.save() which hits the same EagerTensor
+        # JSON bug. Workaround: save weights manually and log as artifact.
+        final_weights_path = os.path.join(save_dir, "effnet_final_weights.h5")
+        model.save_weights(final_weights_path)
+        mlflow.log_artifact(final_weights_path, artifact_path="efficientnet_weights")
+        mlflow.set_tag("efficientnet_note",
+                       "Logged as weights-only artifact due to TF2.10 EagerTensor bug")
+        logger.info(f"EfficientNet weights logged to MLflow → {final_weights_path}")
+        logger.info("EfficientNetB0 training complete.")
+    return model, history
+
+
+# ---------------------------------------------------------------------------
+# Optuna hyperparameter search
+# ---------------------------------------------------------------------------
+
+def run_optuna(cfg, train_data, val_data):
+    image_size = tuple(cfg["data"]["image_size"])
+    n_trials   = cfg["optuna"]["n_trials"]
+
+    def objective(trial):
+        params = {
+            "filters_1"   : trial.suggest_categorical("filters_1",   [32, 64]),
+            "filters_2"   : trial.suggest_categorical("filters_2",   [64, 128]),
+            "filters_3"   : trial.suggest_categorical("filters_3",   [128, 256]),
+            "dense_units" : trial.suggest_categorical("dense_units", [64, 128, 256]),
+            "dropout"     : trial.suggest_float("dropout", 0.2, 0.5),
+            "lr"          : trial.suggest_float("lr", 1e-4, 1e-2, log=True),
+        }
+
+        with mlflow.start_run(run_name=f"trial_{trial.number:02d}", nested=True):
+            mlflow.log_params(params)
+
+            m = compile_model(
+                build_optuna_cnn(params, image_size=image_size),
+                lr=params["lr"]
+            )
+            h = m.fit(
+                train_data,
+                epochs          = 10,
+                validation_data = val_data,
+                callbacks       = [EarlyStopping(monitor="val_accuracy",
+                                                 patience=3,
+                                                 restore_best_weights=True)],
+                verbose         = 0,
+            )
+
+            best_val = float(max(h.history["val_accuracy"]))
+            mlflow.log_metric("best_val_accuracy", best_val)
+
+            for ep, (ta, va, tl, vl) in enumerate(zip(
+                h.history["accuracy"], h.history["val_accuracy"],
+                h.history["loss"],     h.history["val_loss"],
+            )):
+                mlflow.log_metrics({
+                    "train_accuracy" : float(ta),
+                    "val_accuracy"   : float(va),
+                    "train_loss"     : float(tl),
+                    "val_loss"       : float(vl),
+                }, step=ep)
+
+        return best_val
+
+    optuna.logging.set_verbosity(optuna.logging.WARNING)
+    study = optuna.create_study(direction="maximize")
+
+    with mlflow.start_run(run_name="Optuna_Search_Parent"):
+        mlflow.log_params({
+            "n_trials"  : n_trials,
+            "direction" : "maximize",
+            "objective" : "val_accuracy",
+        })
+        study.optimize(objective, n_trials=n_trials)
+        mlflow.log_metric("best_val_accuracy", float(study.best_value))
+        mlflow.log_metric("best_trial_number", study.best_trial.number)
+        mlflow.log_params({f"best_{k}": v for k, v in study.best_params.items()})
+
+    logger.info(f"Optuna best val_accuracy : {study.best_value:.4f}")
+    logger.info(f"Optuna best params       : {study.best_params}")
+    return study
+
+
+def train_optuna_best(cfg, study, train_data, val_data):
+    image_size = tuple(cfg["data"]["image_size"])
+    epochs     = cfg["training"]["epochs"]
+    save_dir   = cfg["models"]["save_dir"]
+    p          = study.best_params
+
+    model = compile_model(
+        build_optuna_cnn(p, image_size=image_size),
+        lr=p["lr"]
+    )
+
+    with mlflow.start_run(run_name="Optuna_Best_CNN_Final") as run:
+        mlflow.log_params({
+            **p,
+            "model_type" : "Optuna Best CNN",
+            "epochs"     : epochs,
+        })
+        history = model.fit(
+            train_data, epochs=epochs, validation_data=val_data,
+            callbacks=get_callbacks(cfg, f"{save_dir}/optuna_best.h5")
+        )
+        log_epoch_metrics(history)
+        mlflow.log_metrics({
+            "best_val_accuracy" : float(max(history.history["val_accuracy"])),
+            "best_val_loss"     : float(min(history.history["val_loss"])),
+        })
+        sample    = train_data[0][0][:1]
+        signature = infer_signature(sample, model.predict(sample))
+        mlflow.keras.log_model(model, "optuna_best_cnn", signature=signature)
+        best_run_id = run.info.run_id
+
+    logger.info("Optuna Best CNN training complete.")
+    return model, history, best_run_id
+
+
+# ---------------------------------------------------------------------------
+# Main
+# ---------------------------------------------------------------------------
+
+if __name__ == "__main__":
+    cfg = load_config("config.yaml")
+    setup_mlflow(cfg)
+
+    train_data, val_data, test_data = get_data_generators(cfg)
+
+    logger.info("=" * 50)
+    logger.info("Starting full training pipeline")
+    logger.info("=" * 50)
+
+    baseline_model, history_base   = train_baseline(cfg, train_data, val_data)
+    tl_model,       history_tl     = train_transfer_learning(cfg, train_data, val_data)
+    ft_model,       history_ft     = train_finetuned(cfg, tl_model, train_data, val_data)
+    eff_model,      history_eff    = train_efficientnet(cfg, train_data, val_data)
+    study                          = run_optuna(cfg, train_data, val_data)
+    optuna_model, history_optuna, best_run_id = train_optuna_best(
+        cfg, study, train_data, val_data
+    )
+
+    results = {
+        "Baseline CNN"      : float(max(history_base.history["val_accuracy"])),
+        "Transfer Learning" : float(max(history_tl.history["val_accuracy"])),
+        "Fine-Tuned"        : float(max(history_ft.history["val_accuracy"])),
+        "EfficientNetB0"    : float(max(history_eff.history["val_accuracy"])),
+        "Optuna Best CNN"   : float(max(history_optuna.history["val_accuracy"])),
+    }
+
+    logger.info("\n" + "=" * 45)
+    logger.info(f"{'Model':<25} {'Val Acc':>10}")
+    logger.info("=" * 45)
+    for name, acc in results.items():
+        mark = " << best" if acc == max(results.values()) else ""
+        logger.info(f"{name:<25} {acc:>10.4f}{mark}")
+    logger.info("=" * 45)
+
+    os.makedirs("./logs", exist_ok=True)
+    plot_comparison(results, save_path="./logs/model_comparison.png")
+    logger.info("Training pipeline complete.")