Update api.py

api.py

@@ -8,6 +8,7 @@ import os
 import google.generativeai as genai
 from pydantic import BaseModel
 from ultralytics import YOLO
+import matplotlib.pyplot as plt
 
 from langchain.document_loaders import TextLoader  # Or a custom loader for .docs
 from langchain.text_splitter import RecursiveCharacterTextSplitter
@@ -194,6 +195,72 @@ def predict_crop_disease(input_data):
 
     return prediction[0] #predicted_label[0]
 
+    def make_gradcam_heatmap(img_array, model, last_conv_layer_name, pred_index=None):
+    grad_model = tf.keras.models.Model(
+        [model.inputs], [model.get_layer(last_conv_layer_name).output, model.output]
+    )
+
+    with tf.GradientTape() as tape:
+        last_conv_layer_output, preds = grad_model(img_array)
+        if pred_index is None:
+            pred_index = tf.argmax(preds[0])
+        class_channel = preds[:, pred_index]
+
+    grads = tape.gradient(class_channel, last_conv_layer_output)
+    pooled_grads = tf.reduce_mean(grads, axis=(0, 1, 2))
+    last_conv_layer_output = last_conv_layer_output[0]
+    heatmap = last_conv_layer_output @ pooled_grads[..., tf.newaxis]
+    heatmap = tf.squeeze(heatmap)
+    heatmap = tf.maximum(heatmap, 0) / tf.math.reduce_max(heatmap)
+    return heatmap.numpy()
+
+
+def display_gradcam(img, heatmap, alpha=0.4):
+    # Create heatmap from the given heatmap values
+    heatmap = np.uint8(255 * heatmap)
+    jet = plt.cm.get_cmap("jet")
+    jet_colors = jet(np.arange(256))[:, :3]
+    jet_heatmap = jet_colors[heatmap]
+    jet_heatmap = tf.keras.preprocessing.image.array_to_img(jet_heatmap)
+    jet_heatmap = jet_heatmap.resize((img.shape[1], img.shape[0]))
+    jet_heatmap = tf.keras.preprocessing.image.img_to_array(jet_heatmap)
+    
+    # Superimpose the heatmap onto the original image
+    superimposed_img = jet_heatmap * alpha + img
+    superimposed_img = tf.keras.preprocessing.image.array_to_img(superimposed_img)
+
+    # Save the image to a BytesIO object instead of showing it with plt.imshow()
+    img_byte_arr = BytesIO()
+    superimposed_img.save(img_byte_arr, format='PNG')
+    img_byte_arr = img_byte_arr.getvalue()
+
+    # Return the image as base64
+    return base64.b64encode(img_byte_arr).decode('utf-8')
+
+
+def calculate_activation_ratio(heatmap, threshold=0.45):
+  """Calculates the ratio of activated to non-activated pixels in a heatmap.
+
+  Args:
+    heatmap: A NumPy array representing the Grad-CAM heatmap.
+    threshold: The threshold for classifying pixels as activated or not.
+
+  Returns:
+    The ratio of activated pixels to non-activated pixels.
+  """
+  activated_pixels = np.sum(heatmap > threshold)
+  total_pixels = heatmap.size
+  non_activated_pixels = total_pixels - activated_pixels
+
+  if non_activated_pixels == 0:
+    return 1.0  # Avoid division by zero if all pixels are activated
+
+  return activated_pixels / non_activated_pixels
+
+# Example usage within the existing code (assuming heatmap is calculated as before):
+
+last_conv_layer_name = "block3_conv2"
+
 app = FastAPI()
 
 @app.post("/classify")
@@ -206,9 +273,19 @@ async def classify(image: UploadFile = File(...)):
         predictions = model.predict(img_array)
         predicted_class_idx = np.argmax(predictions)
         predicted_class_idx = int(predicted_class_idx)
-        return {"prediction": predicted_class_idx}
+
+        heatmap = make_gradcam_heatmap(img_array, model, last_conv_layer_name)
+        base64_image = display_gradcam(img, heatmap, alpha)
+        
+        # Return the base64 encoded image in the response
+
+        # Calculate and print the activation ratio
+        ratio = calculate_activation_ratio(heatmap)
+        
+        return {"prediction": predicted_class_idx,"gradcam": base64_image,"ration":ratio}
     else:
         return {"error": "No image provided"}
+        
 
 yolomodel = YOLO("yolo11m.pt")
 @app.post("/multiclassify")