added XAI endpoint

app.py

@@ -101,4 +101,70 @@ async def predict(file: UploadFile = File(...)):
 
     # Encode the image back to JPEG
     _, buffer = cv2.imencode('.jpg', image_cv)
+    return StreamingResponse(io.BytesIO(buffer.tobytes()), media_type="image/jpeg")
+
+
+def get_top_prediction(detections):
+    """Extracts the index of the most confident detection."""
+    scores = detections['detection_scores'][0].numpy()
+    if len(scores) > 0 and scores[0] > 0.4:
+        # Returns index 0 (top score) and the class ID
+        return 0, int(detections['detection_classes'][0].numpy()[0])
+    return None, None
+
+    
+@app.post("/explain")
+async def explain(file: UploadFile = File(...)):
+    # 1. Prepare Image
+    contents = await file.read()
+    image_pil = Image.open(io.BytesIO(contents)).convert("RGB")
+    image_np = np.array(image_pil).astype(np.float32)
+    input_tensor = tf.convert_to_tensor(np.expand_dims(image_np, 0), dtype=tf.float32)
+
+    # 2. Gradient Tape for Saliency
+    with tf.GradientTape() as tape:
+        tape.watch(input_tensor)
+        
+        # Manually run the forward pass through the detection model
+        image, shapes = detection_model.preprocess(input_tensor)
+        prediction_dict = detection_model.predict(image, shapes)
+        
+        # 'class_predictions_with_background' is standard for TFOD SSD/FasterRCNN models
+        # It usually has shape [1, num_anchors, num_classes]
+        raw_scores = prediction_dict['class_predictions_with_background'][0]
+        
+        # We need a reference detection to know which class to compute gradients for
+        detections = detection_model.postprocess(prediction_dict, shapes)
+        _, top_class = get_top_prediction(detections)
+
+        if top_class is None:
+            return {"error": "No object detected with sufficient confidence to explain."}
+
+        # Focus loss on the max score for that specific class across all anchors
+        loss = tf.reduce_max(raw_scores[:, top_class])
+
+    # 3. Compute Gradients
+    grads = tape.gradient(loss, input_tensor)
+    # Take absolute max across color channels
+    saliency = np.max(np.abs(grads.numpy()), axis=-1)[0]
+
+    # 4. Normalize and Create Heatmap
+    # Using 95th percentile to reduce noise/outliers
+    v_min, v_max = np.percentile(saliency, (5, 95))
+    saliency = np.clip((saliency - v_min) / (v_max - v_min + 1e-8), 0, 1)
+    
+    # Create the JET heatmap (Blue = low, Red = high)
+    heatmap = cv2.applyColorMap(np.uint8(255 * saliency), cv2.COLORMAP_JET)
+    
+    # 5. Overlay on original image (Convert original to BGR first)
+    original_bgr = cv2.cvtColor(image_np.astype(np.uint8), cv2.COLOR_RGB2BGR)
+    overlay = cv2.addWeighted(original_bgr, 0.6, heatmap, 0.4, 0)
+
+    # Add text label for what we are explaining
+    class_name = category_index.get(top_class + 1, {}).get('name', 'unknown')
+    cv2.putText(overlay, f"Explaining: {class_name}", (10, 30), 
+                cv2.FONT_HERSHEY_SIMPLEX, 0.8, (255, 255, 255), 2)
+
+    # 6. Stream Result
+    _, buffer = cv2.imencode('.jpg', overlay)
     return StreamingResponse(io.BytesIO(buffer.tobytes()), media_type="image/jpeg")