Weight each feature map by how much the score depends on it, add them up, and keep the positive part. That is the heatmap.
Overview
The question
A network says "cat". Which part of the image made it say that?
Grad-CAM answers with a heatmap, and it does so using quantities the network makes anyway during backpropagation. This Is why it works on any convolutional architecture without retraining or modification.
Grad-CAM
This module needs JavaScript: the
images are computed in the page rather than downloaded.
Worth knowing
The weights are the gradient of the class score with respect to each feature map, averaged over its spatial positions.
A weight says how much raising that map's activations would raise the score — how much the class depends on it.
The final ReLU is deliberate: it keeps evidence for the class and discards evidence against it.
The heatmap is the size of the feature map, usually 7×7, and is upsampled to the image. It is coarse by construction.
Grad-CAM
A heatmap of which regions a network used, built from grads it already finds.
The recipe
Take the feature maps from the last convolutional layer — often 512 or 2048 of them, each perhaps 7×7. Then:
Find the grad of the class score for each feature map.
Mean each grad over its spatial spots. That number is the map's weight.
Sum the feature maps, weighted by those numbers.
Apply a ReLU.
Upsample the result to the image size.
Steps 3 and 4 are what the visualisation shows. Three synthetic feature maps sit on the left, each with its own weight slider. The mixed heatmap is on the right. The maps are made up. The weighting math is just Grad-CAM's.
What a weight means
The grad of the score for a feature map answers: if this map's activations rose slightly, how much would the class score rise?
A large plus weight means the class depends heavily on that map, so wherever it's active is evidence for the class.
A minus weight means the opposite — that feature argues *against* this class. Set one of the sliders minus and watch what happens to the heatmap: the region belonging to that map doesn't go dark, it simply stops adding, because of the ReLU.
Why the ReLU is there
This is the step people skip and then misread the output.
Without the ReLU the heatmap would hold minus regions, meaning "this area argued against the class". Grad-CAM discards them on purpose, because the question being asked is *what supported this guess* — and a visualisation mixing support and opposition in one colour scale is very easy to misread.
The consequence is that Grad-CAM never shows you evidence against a class. Drag all three sliders minus: the heatmap is empty, not inverted. If you want to know what argued against a guess, this is the wrong tool, and running it on the competing class is often the hands-on answer.
Its limits
detail. The heatmap has the spatial size of the last convolutional layer, often 7×7. Upsampling to 224×224 makes a smooth blob, and that smoothness is interpolation rather than evidence. Grad-CAM can't tell you which pixel mattered, only which seventh of the image.
One layer. It shows the last convolutional layer. Earlier layers see different things, and the choice of layer changes the answer.
Plausibility isn't correctness. A heatmap over the animal's face looks lifelike whether or not the model used the face. Grad-CAM shows what the grads say, and there's published work on saliency methods that give sensible-looking maps for at random was reset networks — so a reasonable-looking heatmap isn't evidence the model is thinking well.
It doesn't live each architecture unchanged. Transformers have no final convolutional layer, so focus rollout or a variant is used instead.
Relatives
CAM, the predecessor, needed the architecture to end in global mean pooling followed by one dense layer, and read the weights straight from that layer. Grad-CAM's part was getting the same weights from grads instead, which removed the architectural need.
Grad-CAM++ handles a few instances of the same class better. Score-CAM drops grads fully, measuring each map's importance by occluding with it and seeing what the score does. Slower, and immune to grad saturation.
The weighting, one cell at a time
Grad-CAM's heatmap is a weighted sum of feature maps followed by a ReLU, and doing one cell by hand drops the mystery. Three maps, with weights that are the spatial-mean grads of the class score, mixed at a single location:
contribution
value
map 1 activation 0.8 × weight +2.0
+1.60
map 2 activation 0.5 × weight −1.0
−0.50
map 3 activation 0.2 × weight +0.5
+0.10
sum → ReLU
1.20
At a cell where the negatively-weighted map dominates the sum comes out minus — say −0.65 — and the ReLU clips it to 0. That clip is the step people skip and then misread: Grad-CAM on purpose discards evidence *against* the class, because the question is what supported this guess, and a map mixing support and opposition on one colour scale is easy to misread. The consequence is that a Grad-CAM heatmap can never show you what argued against a class — drag each weight minus and it goes empty, not inverted. And to see the opposing evidence you run it on the competing class instead. The map is also only 7×7 before upsampling, so the smooth blob over the animal's face is interpolation, not pixel-level proof.
Grad-CAM's real caution is that plausibility isn't correctness. A heatmap over an animal's face looks lifelike whether or not the model used the face, and published work has made sensible-looking saliency maps for *at random was reset* networks — so a reasonable heatmap is a hypothesis about the model, not a verification of it. It also shows just one layer, often the last convolutional one, and the choice of layer changes the answer. So A Grad-CAM result is really "what the grads at this layer say", not "what the model used". Its ancestor CAM needed the network to end in global mean pooling and read the weights straight from that layer. Grad-CAM's part was getting the same weights from grads, which removed the architectural need and is why it works on almost any CNN.
Where it goes wrong with Grad-CAM
Reading the smooth blob as pixel-level evidence. It's 7×7, interpolated.
Showing the wrong class. Run it on the predicted class *and* on the class you expected. The difference is often the helpful part.
Treating it as proof. A plausible heatmap is a hypothesis about the model, not a verification of it.
Choosing a layer without saying so. The layer is a param, and the answer depends on it.
Questions people ask about Grad-CAM
What does Grad-CAM show? A heat map of the image regions that most increased the score for a chosen class, built from the last convolutional layer's feature maps.
How is it calculated? Take the gradient of the class score with respect to each feature map, average it spatially to get a weight per channel, and sum the weighted maps. A ReLU keeps only positive influence.
Why use the last convolutional layer? It balances high-level meaning with some remaining spatial layout. Earlier layers localise better but say less about the class, and later dense layers have lost the layout.
Is a Grad-CAM heat map an explanation of the model? It shows where the model looked, not why. A good-looking map can still hide shortcut features, and the map is low resolution.
How does Grad-CAM differ from the original CAM? CAM needs a global average pooling architecture. Grad-CAM uses gradients, so it works on any CNN without changing it.
Can I use it to debug a model? Yes. If maps highlight the background, watermarks or borders instead of the object, the model has likely learned a dataset artefact.
Asking the gradient which pixels mattered
Grad-CAM makes a heatmap over the image for a chosen class. Each step of it's math you can follow. This builds one end to end on a small network, then checks the two things people forget to check -- whether the map changes with the class. Whether it can be trusted when the guess is wrong.
example_01.pyNumPy
import numpy as np
rng = np.random.default_rng(21)
C, H, W = 6, 5, 5
fmap = np.abs(rng.normal(0, 0.15, (C, H, W)))
fmap[0, 0:2, 0:2] += 2.2; fmap[1, 3:5, 3:5] += 2.0
fmap[2, 2, :] += 1.6; fmap[3, :, 2] += 1.5
NAMES = ["top-left blob", "bot-right blob", "horiz band",
"vert band", "noise", "noise"]
print("LAST CONV LAYER: %d channels of %dx%d." % (C, H, W))
print("%-8s %-18s %8s %10s" % ("ch", "responds to", "max", "where"))
for c in range(C):
r, k = np.unravel_index(fmap[c].argmax(), (H, W))
print("%-8d %-18s %8.2f %10s" % (c, NAMES[c], fmap[c].max(), "(%d,%d)" % (r, k)))
print()
gap = fmap.mean(axis=(1, 2))
Wc = np.zeros((2, C))
Wc[0] = [5.0, -0.5, 0.3, 0.1, 0.0, 0.0]
Wc[1] = [-0.4, 1.6, 0.2, 0.1, 0.0, 0.0]
logits = Wc @ gap
p = np.exp(logits - logits.max()); p = p / p.sum()
print("HEAD: GAP then linear to 2 classes.")
print(" logits: A=%.4f B=%.4f" % (logits[0], logits[1]))
print(" softmax: A=%.4f B=%.4f -> model says %s."
% (p[0], p[1], "A" if p[0] > p[1] else "B"))
Output
The next block runs Grad-CAM step by step for both classes, showing how the weighted sum of feature maps produces a different heatmap for each class.
example_02.pyNumPy
import numpy as np
rng = np.random.default_rng(21)
C, H, W = 6, 5, 5
fmap = np.abs(rng.normal(0, 0.15, (C, H, W)))
fmap[0, 0:2, 0:2] += 2.2; fmap[1, 3:5, 3:5] += 2.0
fmap[2, 2, :] += 1.6; fmap[3, :, 2] += 1.5
NAMES = ["top-left blob", "bot-right blob", "horiz band",
"vert band", "noise", "noise"]
Wc = np.zeros((2, C))
Wc[0] = [5.0, -0.5, 0.3, 0.1, 0.0, 0.0]
Wc[1] = [-0.4, 1.6, 0.2, 0.1, 0.0, 0.0]
def gradcam(k):
alpha = np.array([Wc[k, c] / float(H*W) for c in range(C)])
cam = np.tensordot(alpha, fmap, axes=(0, 0))
return alpha, cam, np.maximum(cam, 0)
ramp = " .:-=+*#%@"
for k, cname in ((0, "A"), (1, "B")):
alpha, cam, cam_relu = gradcam(k)
print("CLASS %s:" % cname)
print(" alpha (channel weights): " + " ".join("%+.4f" % v for v in alpha))
hi = cam_relu.max() + 1e-9
for row in cam_relu:
print(" " + "".join(ramp[min(9, int(9*v/hi))]*2 for v in row))
r, c_ = np.unravel_index(cam_relu.argmax(), (H, W))
print(" peak at (%d,%d), %d/%d cells zeroed by ReLU."
% (r, c_, int((cam <= 0).sum()), cam.size))
_, _, camA = gradcam(0); _, _, camB = gradcam(1)
ra, ca = np.unravel_index(camA.argmax(), (H, W))
rb, cb = np.unravel_index(camB.argmax(), (H, W))
def norm(a):
v = a.reshape(-1)-a.mean(); return v/(np.linalg.norm(v)+1e-12)
print("CLASS TEST: A peaks at (%d,%d)=%s, B at (%d,%d)=%s."
% (ra, ca, NAMES[0], rb, cb, NAMES[1]))
print(" correlation: %.4f -- genuinely different maps." % float(norm(camA)@norm(camB)))
print(" a method whose map barely changes with the class tells you about")
print(" the IMAGE, not the DECISION.")
Output
The next block shows how coarse the map really is, and warns that Grad-CAM explains the class you ask for even when the model rejected it.
example_03.pyNumPy
import numpy as np
rng = np.random.default_rng(21)
C, H, W = 6, 5, 5
fmap = np.abs(rng.normal(0, 0.15, (C, H, W)))
fmap[0, 0:2, 0:2] += 2.2; fmap[1, 3:5, 3:5] += 2.0
fmap[2, 2, :] += 1.6; fmap[3, :, 2] += 1.5
Wc = np.zeros((2, C))
Wc[0] = [5.0, -0.5, 0.3, 0.1, 0.0, 0.0]
Wc[1] = [-0.4, 1.6, 0.2, 0.1, 0.0, 0.0]
gap = fmap.mean(axis=(1, 2)); logits = Wc @ gap
p = np.exp(logits - logits.max()); p = p / p.sum()
def gradcam(k):
alpha = np.array([Wc[k, c] / float(H*W) for c in range(C)])
cam = np.tensordot(alpha, fmap, axes=(0, 0))
return np.maximum(cam, 0)
camA, camB = gradcam(0), gradcam(1)
print("HOW BIG IS THE MAP, REALLY:")
print("%-20s %10s %12s %12s" % ("backbone", "input", "conv map", "upsample"))
for name, side, grid in (("VGG-16",224,14),("ResNet-50",224,7),("this toy",40,5)):
print("%-20s %10s %12s %12s"
% (name, "%dx%d"%(side,side), "%dx%d"%(grid,grid), "%dx"%(side//grid)))
print(" ResNet-50: 49 values blown up to 50176 pixels.")
print()
print("THE WARNING. Grad-CAM explains ANY class, even a rejected one:")
print("%-24s %12s %12s" % ("", "class A", "class B"))
print("%-24s %12.4f %12.4f" % ("probability", p[0], p[1]))
print("%-24s %12.3f %12.3f" % ("peak strength", camA.max(), camB.max()))
loser = 1 if p[0] > p[1] else 0
print(" class %s has p=%.4f but a clean heatmap." % ("AB"[loser], p[loser]))
print(" after min-max normalisation (which every figure uses):")
for label, cam in (("A (p=%.2f)"%p[0], camA), ("B (p=%.2f)"%p[1], camB)):
nm = cam / (cam.max()+1e-12)
print(" %-16s peak %.3f, mean %.3f" % (label, nm.max(), nm.mean()))
print(" the two are indistinguishable. the heatmap is not a confidence")
print(" measure -- always report the class and probability alongside it.")
Output
Check yourself
0 of 3
Answer without scrolling back up.
Where does a feature map's weight come from?
It answers how much raising that map's activations would raise the class score. Getting it from gradients is what freed Grad-CAM from CAM's architectural requirement.
What does the final ReLU do?
Drag all the weights negative and the heatmap is empty rather than inverted. Grad-CAM cannot show what argued against a prediction; run it on the competing class instead.
Why is a Grad-CAM heatmap coarse?
The smoothness of the blob is interpolation, not evidence. It can say which seventh of the image mattered, not which pixel.
Cheat sheet
Grad-CAM
Compute a Grad-CAM heatmap from gradients flowing into the last convolutional layer, then overlay it to see which regions drove the prediction.
Ashish Jangra builds and maintains VizLearn. Every module here is written and the visualisation behind it hand-built, so the numbers in a readout come from the same code that draws the picture. Corrections are genuinely welcome and get priority over everything else — if a page states something wrong, or an animation misrepresents what the algorithm does, get in touch.