Update app.py

app.py

@@ -24,30 +24,46 @@ def img_pros(img):
 
 #function for creating model
 #returns model, its inputs, Xception's last conv output, the whole model's outputs
-def create_model_mod():
+def create_model_mod(classes, activation):
     inputs = keras.Input(shape = (160,160,3))
     #normalizing pixel values
     r = Rescaling(scale = 1./255)(inputs)
     x = base_model(r, training = False)
     gap = keras.layers.GlobalAveragePooling2D()(x)
-    outputs = keras.layers.Dense(1,activation = 'linear')(gap)
+    outputs = keras.layers.Dense(classes ,activation = activation)(gap)
     model = keras.Model(inputs, outputs)
     
+    if activation == "linear":
+        loss_s = keras.losses.BinaryCrossentropy(from_logits = True)
+    else:
+        loss_s = keras.losses.BinaryCrossentropy()
+    
     model.compile(
-    loss = keras.losses.BinaryCrossentropy(from_logits = True),
+    loss = loss_s,
     optimizer = keras.optimizers.Adam(0.001),
     metrics = ["accuracy"]
     )
     
     return model, inputs, x, outputs
 
-def create_heatmap(model, imgs):
-    #predicting the images and getting the conv outputs and predictions
+    
+#create heatmaps of the given images
+#returns the heatmaps and the raw score of predicted class of each image
+def create_heatmap(model, imgs, class_index):
+    model.layers[-1].activation = None
+    
+    #predicting the images and getting the conv outputs and predictions from the gradcam model
     with tf.GradientTape() as tape:
-        maps, preds = model(imgs);
+    maps, preds = model(imgs);
+    
+    # class_channel = tf.expand_dims(preds[:,class_index],axis = 1)
+    class_channel = preds[:, class_index]
     
     #computing gradients of predictions w.r.t the feature maps
-    grads = tape.gradient(preds, maps)
+    if class_index == -1:
+        grads = tape.gradient(preds, maps)
+    else:
+        grads = tape.gradient(class_channel, maps)
     
     # global average pooling of each feature map
     gap_grads = tf.reduce_mean(grads, axis=(0, 1, 2))
@@ -64,6 +80,8 @@ def create_heatmap(model, imgs):
     
     return heatmap, preds.numpy()
 
+
+#superimpose function buth for a single input image
 def superimpose_single(heatmap, img, alpha = 0.4):
     heatmap = np.uint8(255 * heatmap)
     
@@ -85,37 +103,47 @@ def superimpose_single(heatmap, img, alpha = 0.4):
     
     return superimposed_img
 
-def gen_grad_img_single(weights, img, alpha = 0.4):
-    model_mod, input, x, output = create_model_mod()
-    model_mod.load_weights(weights)
-    grad_model = Model(input, [x, output])
-    heatmaps, y_pred = create_heatmap(grad_model, img)
+#for generating single gradcam image
+def gen_grad_img_single(grad_model, img, class_index, alpha = 0.4):
+    heatmaps, y_pred = create_heatmap(grad_model, img, class_index)
     
     # for i in range(len(y_pred)):
-    #   if y_pred[i] > 0.5: y_pred[i] = 1
-    #   else: y_pred[i] = 0
+    #     if y_pred[i] > 0.5: y_pred[i] = 1
+    #     else: y_pred[i] = 0
     
     img = superimpose_single(heatmaps, img[0])
     return np.array(img).astype('uint8'), y_pred
 
 
+def gen_grad_both(grad_model, imgs, y_true, size, cols, font_size):
+    img_c, y_pred_c = gen_grad_img_single(grad_model, imgs, 0)
+    img_d, y_pred_d = gen_grad_img_single(grad_model, imgs, 1)
+    y_pred_c = np.around(y_pred_c,3)
+    y_pred_d = np.around(y_pred_d,3)
+    # show_imgs([img_c, img_d], [y_true, y_true], [size[0], size[1]], cols, [y_pred_c, y_pred_d], font_size = font_size)
+    
+    infer = ""
+    if y_pred_c[0] > y_pred_c[1]: infer = "cat"
+    else: infer = "dog"
+        
+    return [img_c, img_d], y_pred_c, infer
+
 weights = "weights.h5"
-# img, y_pred = gen_grad_img_single(weights, img)
 
 def get_grad(img):
     img = img_pros(img)
-    grad_img, y_pred = gen_grad_img_single(weights, img)
-    pred_class = ""
-    if y_pred[0] > 0.5: pred_class = "cat"
-    else: pred_class = "dog"
+    grad_imgs, y_pred, infer = gen_grad_img_single(weights, img)
+    # pred_class = ""
+    # if y_pred[0] > 0.5: pred_class = "cat"
+    # else: pred_class = "dog"
         
-    text = "Raw Score: " + str(y_pred[0]) + "\nClassification: " + pred_class
-    return grad_img, text
+    text = "Raw Score: " + str(y_pred[0]) + "\nClassification: " + infer
+    return grad_imgs, text
 
 demo = gr.Interface(
   fn = get_grad,
   inputs = gr.Image(type = "pil", shape = (224,224)),
-  outputs = [gr.Image(type = "numpy", width = 320, height = 320), gr.Textbox(label = 'Prediction', info = '(threshold: 0.5)')], 
+  outputs = [gr.Image(type = "numpy", width = 320, height = 320), gr.Image(type = "numpy", width = 320, height = 320), gr.Textbox(label = 'Prediction', info = '(threshold: 0.5)')], 
   description = "Visual Explanations from Deep Networks",
   title = "Gradient-Weighted Class Activation Mapping (Grad-CAM)"
    )