Upload 3 files

app.py

@@ -0,0 +1,258 @@
+import os
+import io
+import base64
+import numpy as np
+import cv2
+import tensorflow as tf
+from tensorflow import keras
+from tensorflow.keras import layers
+from PIL import Image
+import matplotlib.cm as cm
+from flask import Flask, render_template, request, jsonify
+
+app = Flask(__name__)
+
+GLOBAL_MODEL = None
+GRAD_MODEL = None
+
+def rebuild_and_load_model(weights_path):
+    """Rebuilds the topology and applies an aggressive structural fallback strategy 
+    if a shape/axis mismatch occurs during weight mapping."""
+    global GLOBAL_MODEL, GRAD_MODEL
+    
+    keras.backend.clear_session()
+    
+    if not os.path.exists(weights_path):
+        raise FileNotFoundError(f"No weights file found at target path: {weights_path}")
+    
+    # 1. Build standard outer model architecture
+    base_model = tf.keras.applications.EfficientNetB0(
+        include_top=False, weights='imagenet', input_shape=(224, 224, 3)
+    )
+    base_model.trainable = False 
+
+    inputs = keras.Input(shape=(224, 224, 3))
+    x = base_model(inputs, training=False)
+    x = layers.GlobalAveragePooling2D()(x)
+    x = layers.Dropout(0.2)(x)
+    outputs = layers.Dense(4, activation='softmax')(x)
+
+    model = keras.Model(inputs, outputs)
+    
+    # 2. Aggressive Fallback Weight Loading Strategy
+    try:
+        print("--> Strategy A: Attempting full top-level model weight mapping...")
+        model.load_weights(weights_path)
+        print("--> Strategy A Successful: Full model weights matched.")
+    except ValueError as e:
+        print(f"--> Strategy A Failed due to axis/shape mismatch: {e}")
+        print("--> Strategy B: Attempting direct injection into the inner Backbone layer...")
+        try:
+            # This handles cases where only the 'base_model' weights were exported during training
+            base_model.load_weights(weights_path)
+            print("--> Strategy B Successful: Backbone layers updated successfully.")
+        except Exception as strategy_b_error:
+            print(f"--> Strategy B Failed: {strategy_b_error}")
+            print("--> Strategy C: Attempting relaxed name-matching mapping fallback...")
+            try:
+                model.load_weights(weights_path, by_name=True)
+                print("--> Strategy C Successful: Named layers updated.")
+            except Exception as strategy_c_error:
+                raise ValueError(
+                    f"All structural loading mapping routes failed.\n"
+                    f"Primary Error: {e}\n"
+                    f"Sub-Graph Error: {strategy_b_error}"
+                )
+
+    GLOBAL_MODEL = model
+    
+    # 3. Build Safe Grad-CAM tensor mapping
+    backbone_output_tensor = None
+    for i, layer in enumerate(model.layers):
+        if 'efficientnet' in layer.name.lower():
+            backbone_output_tensor = model.layers[i+1].input
+            break
+
+    if backbone_output_tensor is None:
+        raise ValueError("Could not trace EfficientNet backbone connections cleanly.")
+
+    GRAD_MODEL = keras.Model(inputs=model.inputs, outputs=[backbone_output_tensor, model.output])
+    print(f"--> App Pipeline fully mounted and online from path: {weights_path}")
+
+def get_base64_image(img_ndarray):
+    """Converts standard BGR/RGB image array to clean Base64 strings."""
+    encoding_buffer = cv2.imencode('.png', img_ndarray)[1]
+    base64_string = base64.b64encode(encoding_buffer).decode('utf-8')
+    return f"data:image/png;base64,{base64_string}"
+
+@app.route('/', methods=['GET'])
+def index():
+    return render_template('index.html')
+
+@app.route('/configure', methods=['POST'])
+def configure():
+    try:
+        data = request.get_json()
+        model_path = data.get('model_path', 'best_model_weights.h5')
+        rebuild_and_load_model(model_path)
+        return jsonify({"status": "success", "message": f"Successfully mounted weights: {os.path.basename(model_path)}"})
+    except Exception as e:
+        return jsonify({"status": "error", "message": str(e)}), 400
+    
+# =========================================================================
+# CONFIGURATION: CLASS BOUNDARY THRESHOLDS (Scale: 0.0 to 1.0)
+# =========================================================================
+CLASS_THRESHOLDS = {
+    0: 0.85,  # Class 0 requires a harsh 85% confidence threshold
+    1: 0.60,  # Class 1 requires 60%
+    2: 0.70,  # Class 2 requires 70%
+    3: 0.50   # Class 3 requires 50%
+}
+
+@app.route('/predict', methods=['POST'])
+def predict():
+    global GLOBAL_MODEL, GRAD_MODEL
+    
+    if GLOBAL_MODEL is None or GRAD_MODEL is None:
+        return jsonify({"status": "error", "message": "Model uninitialized. Mount a valid weights file first."}), 400
+        
+    if 'image' not in request.files:
+        return jsonify({"status": "error", "message": "No file uploaded."}), 400
+        
+    file = request.files['image']
+    if file.filename == '':
+        return jsonify({"status": "error", "message": "Empty file."}), 400
+
+    try:
+        in_memory_file = io.BytesIO(file.read())
+        pil_img = Image.open(in_memory_file).convert('RGB')
+        
+        orig_w, orig_h = pil_img.size
+        raw_cv_img = cv2.cvtColor(np.array(pil_img), cv2.COLOR_RGB2BGR)
+        
+        resized_img = pil_img.resize((224, 224))
+        img_array = np.array(resized_img).astype(np.float32)
+        img_tensor = np.expand_dims(img_array, axis=0)
+        
+        # Calculate Grad-CAM maps
+        with tf.GradientTape() as tape:
+            last_conv_layer_outputs, predictions = GRAD_MODEL(img_tensor)
+            pred_idx = tf.argmax(predictions[0])
+            top_class_channel = predictions[:, pred_idx]
+
+        grads = tape.gradient(top_class_channel, last_conv_layer_outputs)
+        pooled_grads = tf.reduce_mean(grads, axis=(0, 1, 2))
+        
+        last_conv_layer_outputs = last_conv_layer_outputs[0]
+        heatmap = last_conv_layer_outputs @ pooled_grads[..., tf.newaxis]
+        heatmap = tf.squeeze(heatmap)
+        
+        heatmap = tf.maximum(heatmap, 0) / (tf.math.reduce_max(heatmap) + 1e-10)
+        heatmap_np = heatmap.numpy()
+        
+        heatmap_resized = cv2.resize(heatmap_np, (orig_w, orig_h))
+        heatmap_colored = cm.jet(heatmap_resized)[..., :3] * 255
+        heatmap_colored = cv2.cvtColor(heatmap_colored.astype(np.uint8), cv2.COLOR_RGB2BGR)
+        
+        alpha = 0.4
+        superimposed_img = cv2.addWeighted(heatmap_colored, alpha, raw_cv_img, (1.0 - alpha), 0)
+        
+        # --- THRESHOLD EVALUATION BLOCK ---
+        raw_confidence = float(predictions[0][pred_idx])
+        target_idx = int(pred_idx)
+        required_minimum = CLASS_THRESHOLDS.get(target_idx, 0.50)
+        
+        confidence_percentage = raw_confidence * 100
+        threshold_percentage = required_minimum * 100
+        
+        if raw_confidence < required_minimum:
+            predicted_label = f"Uncertain / Low Confidence (Best Guess: Class {target_idx})"
+            passed_threshold = False
+        else:
+            predicted_label = f"Class {target_idx}"
+            passed_threshold = True
+        
+        return jsonify({
+            "status": "success",
+            "prediction": predicted_label,
+            "confidence": f"{confidence_percentage:.2f}%",
+            "passed_threshold": passed_threshold,
+            "threshold_required": f"{threshold_percentage:.2f}%",
+            "original_image": get_base64_image(raw_cv_img),
+            "gradcam_image": get_base64_image(superimposed_img)
+        })
+        
+    except Exception as e:
+        return jsonify({"status": "error", "message": str(e)}), 500
+
+# @app.route('/predict', methods=['POST'])
+# def predict():
+#     global GLOBAL_MODEL, GRAD_MODEL
+    
+#     if GLOBAL_MODEL is None or GRAD_MODEL is None:
+#         return jsonify({"status": "error", "message": "Model uninitialized. Mount a valid weights file first."}), 400
+        
+#     if 'image' not in request.files:
+#         return jsonify({"status": "error", "message": "No file uploaded."}), 400
+        
+#     file = request.files['image']
+#     if file.filename == '':
+#         return jsonify({"status": "error", "message": "Empty file."}), 400
+
+#     try:
+#         in_memory_file = io.BytesIO(file.read())
+#         pil_img = Image.open(in_memory_file).convert('RGB')
+        
+#         orig_w, orig_h = pil_img.size
+#         raw_cv_img = cv2.cvtColor(np.array(pil_img), cv2.COLOR_RGB2BGR)
+        
+#         resized_img = pil_img.resize((224, 224))
+#         img_array = np.array(resized_img).astype(np.float32)
+#         img_tensor = np.expand_dims(img_array, axis=0)
+        
+#         # Calculate Grad-CAM maps
+#         with tf.GradientTape() as tape:
+#             last_conv_layer_outputs, predictions = GRAD_MODEL(img_tensor)
+#             pred_idx = tf.argmax(predictions[0])
+#             top_class_channel = predictions[:, pred_idx]
+
+#         grads = tape.gradient(top_class_channel, last_conv_layer_outputs)
+#         pooled_grads = tf.reduce_mean(grads, axis=(0, 1, 2))
+        
+#         last_conv_layer_outputs = last_conv_layer_outputs[0]
+#         heatmap = last_conv_layer_outputs @ pooled_grads[..., tf.newaxis]
+#         heatmap = tf.squeeze(heatmap)
+        
+#         heatmap = tf.maximum(heatmap, 0) / (tf.math.reduce_max(heatmap) + 1e-10)
+#         heatmap_np = heatmap.numpy()
+        
+#         heatmap_resized = cv2.resize(heatmap_np, (orig_w, orig_h))
+#         heatmap_colored = cm.jet(heatmap_resized)[..., :3] * 255
+#         heatmap_colored = cv2.cvtColor(heatmap_colored.astype(np.uint8), cv2.COLOR_RGB2BGR)
+        
+#         alpha = 0.4
+#         superimposed_img = cv2.addWeighted(heatmap_colored, alpha, raw_cv_img, (1.0 - alpha), 0)
+        
+#         confidence = float(predictions[0][pred_idx]) * 100
+#         predicted_label = f"Class {pred_idx}"
+        
+#         return jsonify({
+#             "status": "success",
+#             "prediction": predicted_label,
+#             "confidence": f"{confidence:.2f}%",
+#             "original_image": get_base64_image(raw_cv_img),
+#             "gradcam_image": get_base64_image(superimposed_img)
+#         })
+        
+#     except Exception as e:
+#         return jsonify({"status": "error", "message": str(e)}), 500
+
+if __name__ == '__main__':
+    default_weights = 'best_model_weights (2).h5'
+    if os.path.exists(default_weights):
+        try:
+            rebuild_and_load_model(default_weights)
+        except Exception as e:
+            print(f"Automatic startup loading bypassed: {e}")
+            
+    app.run(debug=True, port=5000)

best_model_weights (2).h5

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

requirements.txt

@@ -0,0 +1,7 @@
+Flask==3.0.2
+tensorflow-cpu==2.15.0      # CRITICAL: Barebones CPU distribution saves ~400MB RAM
+numpy==1.26.4
+opencv-python-headless==4.9.0.80  # CRITICAL: Bypasses server GUI package dependencies
+Pillow==10.2.0
+matplotlib==3.8.3
+gunicorn==21.2.0            # High-performance production web server