text stringlengths 0 4.99k |
|---|
def make_gradcam_heatmap(img_array, model, last_conv_layer_name, pred_index=None): |
# First, we create a model that maps the input image to the activations |
# of the last conv layer as well as the output predictions |
grad_model = tf.keras.models.Model( |
[model.inputs], [model.get_layer(last_conv_layer_name).output, model.output] |
) |
# Then, we compute the gradient of the top predicted class for our input image |
# with respect to the activations of the last conv layer |
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] |
# This is the gradient of the output neuron (top predicted or chosen) |
# with regard to the output feature map of the last conv layer |
grads = tape.gradient(class_channel, last_conv_layer_output) |
# This is a vector where each entry is the mean intensity of the gradient |
# over a specific feature map channel |
pooled_grads = tf.reduce_mean(grads, axis=(0, 1, 2)) |
# We multiply each channel in the feature map array |
# by \"how important this channel is\" with regard to the top predicted class |
# then sum all the channels to obtain the heatmap class activation |
last_conv_layer_output = last_conv_layer_output[0] |
heatmap = last_conv_layer_output @ pooled_grads[..., tf.newaxis] |
heatmap = tf.squeeze(heatmap) |
# For visualization purpose, we will also normalize the heatmap between 0 & 1 |
heatmap = tf.maximum(heatmap, 0) / tf.math.reduce_max(heatmap) |
return heatmap.numpy() |
Let's test-drive it |
# Prepare image |
img_array = preprocess_input(get_img_array(img_path, size=img_size)) |
# Make model |
model = model_builder(weights=\"imagenet\") |
# Remove last layer's softmax |
model.layers[-1].activation = None |
# Print what the top predicted class is |
preds = model.predict(img_array) |
print(\"Predicted:\", decode_predictions(preds, top=1)[0]) |
# Generate class activation heatmap |
heatmap = make_gradcam_heatmap(img_array, model, last_conv_layer_name) |
# Display heatmap |
plt.matshow(heatmap) |
plt.show() |
Predicted: [('n02504458', 'African_elephant', 9.862388)] |
png |
Create a superimposed visualization |
def save_and_display_gradcam(img_path, heatmap, cam_path=\"cam.jpg\", alpha=0.4): |
# Load the original image |
img = keras.preprocessing.image.load_img(img_path) |
img = keras.preprocessing.image.img_to_array(img) |
# Rescale heatmap to a range 0-255 |
heatmap = np.uint8(255 * heatmap) |
# Use jet colormap to colorize heatmap |
jet = cm.get_cmap(\"jet\") |
# Use RGB values of the colormap |
jet_colors = jet(np.arange(256))[:, :3] |
jet_heatmap = jet_colors[heatmap] |
# Create an image with RGB colorized heatmap |
jet_heatmap = keras.preprocessing.image.array_to_img(jet_heatmap) |
jet_heatmap = jet_heatmap.resize((img.shape[1], img.shape[0])) |
jet_heatmap = keras.preprocessing.image.img_to_array(jet_heatmap) |
# Superimpose the heatmap on original image |
superimposed_img = jet_heatmap * alpha + img |
superimposed_img = keras.preprocessing.image.array_to_img(superimposed_img) |
# Save the superimposed image |
superimposed_img.save(cam_path) |
# Display Grad CAM |
display(Image(cam_path)) |
save_and_display_gradcam(img_path, heatmap) |
jpeg |
Let's try another image |
We will see how the grad cam explains the model's outputs for a multi-label image. Let's try an image with a cat and a dog together, and see how the grad cam behaves. |
img_path = keras.utils.get_file( |
\"cat_and_dog.jpg\", |
\"https://storage.googleapis.com/petbacker/images/blog/2017/dog-and-cat-cover.jpg\", |
) |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.