Azimuth

Computer Vision2017intermediate10 min read

Grad-CAM: Visual Explanations from Deep Networks via Gradient-Based Localization

Grad-CAM: تحديد المناطق المؤثّرة في قرارات الشبكات العميقة باستخدام التدرُّجات

Selvaraju, R. R. · Cogswell, M. · Das, A. · Vedantam, R. · Parikh, D. · Batra, D. — ICCV

The problem

Deep CNNs achieve remarkable accuracy in image classification, captioning, and VQA, but they are black boxes — they give a without explaining why. Previous explanation methods like CAM required specific architectures ( right before softmax), limiting applicability. Pixel-level methods like show fine detail but are not class-discriminative — they highlight the same pixels regardless of class. There was no general, class-discriminative visual explanation method that works across all architectures and tasks without re-.

The contribution

Grad-CAM: a technique that uses the gradients flowing back into the final to produce a coarse localization map highlighting the important image regions for any target class. It generalizes CAM to any differentiable CNN architecture — no re-training or architectural changes needed. Combining Grad-CAM with Guided yields Guided Grad-CAM: high-resolution, class-discriminative visualizations. The method works for classification, captioning, VQA, and reinforcement learning models.

The impact

Grad-CAM became the default tool for visual . It established the principle that information from any differentiable output can localize relevant regions. Its influence extends to medical imaging, autonomous driving, and any domain where understanding model decisions is critical. It paved the way for Grad-CAM++, Score-CAM, and the broader field of explainable AI (XAI). With over 15,000 citations, it is one of the most cited papers in the interpretability literature.

A doctor examines an X-ray and says: "pneumonia." You ask: "Show me where you see it." The doctor circles a cloudy region in the lower-left lung.

That circle is what Grad-CAM does for a . The network classifies an image, and Grad-CAM asks the last convolutional layer: "which of your maps mattered most for that class?" It weights each map by how strongly that class's score responds to it, averages them, and lays the result over the image as a heat map — warm where the evidence lives, cool where the network ignored.

No architecture surgery, no re-training — just one backward pass to ask the right question.

The problem: powerful models that cannot explain themselves

By 2016, deep CNNs were beating humans on ImageNet, generating captions, and answering visual questions. But ask a VGG or ResNet why it said "golden retriever," and you got silence. This mattered beyond curiosity:

  • Trust. Deploying a model in medicine or self-driving without explanation is irresponsible. Doctors need to verify the model is looking at the lesion, not the ruler in the corner.

  • Debugging. A model might classify correctly for the wrong reason — learning "grass background" instead of "horse." Without visualization, the stays hidden until deployment.

  • Regulation. The EU's GDPR introduced a "right to explanation" for automated decisions. Black boxes were becoming a legal liability.

Existing explanation approaches fell into two camps, each with a critical weakness:

CAM () produced class-discriminative heat maps, but it only worked with architectures that use global directly before the output layer. VGG, AlexNet, and any model with fully-connected layers were excluded.

Guided Backpropagation and Deconvolution produced pixel-level detail — you could see individual edges and textures. But they were not class-discriminative: the same visualization appeared whether you asked "where is the cat?" or "where is the dog?" in an image containing both.

The field needed a method that was both class-discriminative and architecture-general.

Open in Lab
CAM requires global average pooling before the output. Grad-CAM works with any CNN — click to compare.
The demo wakes as you arrive…

The idea: ask the gradients where the evidence lives

The insight is elegant: the gradient of a class score with respect to a tells you how much that feature map matters for that class. If nudging a feature map upward increases the "cat" score a lot, that map is encoding something cat-like.

Think of the last convolutional layer as a grid of detectors — one might detect "pointy ears," another "whiskers," another "fur texture." Grad-CAM asks each detector: "if I turn you up, does the 'cat' score rise?" The ones that say "yes, a lot" get high . The weighted sum of those detector maps, passed through (keep only the positive evidence), becomes the heat map.

This is a generalization of CAM. CAM uses the actual weights connecting the layer to the output class — which only exist in architectures with global average pooling. Grad-CAM replaces those weights with gradients, which exist for any differentiable output. That single substitution makes the technique universal.

Open in Lab
Follow the Grad-CAM pipeline step by step: forward pass → pick class → backward pass → weight feature maps → combine → ReLU → heat map.
The demo wakes as you arrive…

The math: three lines that explain a network

Grad-CAM computes a class-discriminative localization map in three steps. First, compute the importance weight of each feature map for the target class. Then, take the weighted combination. Finally, apply ReLU to keep only the regions that positively influence the class.

αkc=1Z∑i∑j∂yc∂Aijk\alpha_k^c = \frac{1}{Z} \sum_i \sum_j \frac{\partial y^c}{\partial A^k_{ij}}
Step 1: importance weight — how much does feature map k matter for class c? — Global average pooling of the gradient of the class score yᶜ with respect to the activations Aᵏ of the k-th feature map. Each α captures how much feature map k contributes to class c.
LGrad-CAMc=ReLU ⁣(∑kαkc Ak)L^c_{\text{Grad-CAM}} = \text{ReLU}\!\left(\sum_k \alpha_k^c \, A^k\right)
Step 2: weighted combination + ReLU — the heat map — Weight each feature map by its importance, sum them, and pass through ReLU. The ReLU removes negative values because we only want regions that *increase* the class score — negative regions belong to other classes.
Open in Lab
Hover over each part of the formula to see what it does. Adjust the class to see how weights change.
The demo wakes as you arrive…

The best of both worlds: Guided Grad-CAM

Grad-CAM gives you a coarse heat map — you know where the network looked, but the map is low-resolution (typically 14×14 for VGG). Guided Backpropagation gives you pixel-sharp detail — you see every edge and texture — but it cannot tell classes apart.

The solution is simple and effective: multiply them together. Take the high-resolution Guided Backpropagation map (the sharp detail) and pointwise-multiply it by the upsampled Grad-CAM map (the class-discriminative region). The result — Guided Grad-CAM — is both high-resolution and class-discriminative.

Think of it as a magnifying glass. Grad-CAM tells you which part of the image to zoom into (the "where"), and Guided Backpropagation provides the zoomed-in detail (the "what"). The product gives you both: what the network saw and where it saw it.

Open in Lab
See how Guided Backpropagation (detail) × Grad-CAM (region) = Guided Grad-CAM (both).
The demo wakes as you arrive…

Why the last convolutional layer?

CNNs build features in a hierarchy. Early layers detect edges and corners — local patterns with tiny receptive fields. Middle layers combine edges into textures and parts. The last convolutional layer captures the highest-level spatial features: "dog face," "wheel," "wing shape." It is the best compromise between high-level semantics and spatial information.

Earlier layers give finer localization but detect low-level features that are not class-discriminative (edges appear in all objects). Later fully-connected layers lose spatial information entirely — they know the class but not where. The last convolutional layer sits at the sweet spot: it knows what and where.

Open in Lab
Switch between convolutional layers to see how Grad-CAM changes — earlier layers show edges, later layers show objects.
The demo wakes as you arrive…

Beyond classification: captioning, VQA, and trust

Because Grad-CAM only needs a differentiable class score and a convolutional layer, it extends naturally to any task:

  • Image captioning: backpropagate from each generated word to see which region triggered it. A model generating "dog on couch" highlights the dog when generating "dog" and the couch when generating "couch."

  • Visual question answering (VQA): given an image and "What color is the fire hydrant?", Grad-CAM shows the model attended to the hydrant even without explicit layers.

  • Identifying dataset bias: Grad-CAM revealed that a "nurse" classifier was attending to faces and hair (learning gender stereotypes from biased data) rather than medical equipment. This made hidden bias visible and actionable.

  • Human trust studies: in controlled experiments, Grad-CAM helped untrained users identify the more accurate model 61.2% of the time when both models made identical predictions — the visual explanation revealed which model was looking at the right evidence.

Open in Lab
Switch between classification, captioning, and VQA to see Grad-CAM adapt to different tasks.
The demo wakes as you arrive…

The same idea in code

Grad-CAM in ~20 lines of PyTorchpython

Simplified to show the idea — not the real implementation.

import torch
import torch.nn.functional as F

def grad_cam(model, image, target_class, target_layer):
    """Compute Grad-CAM heatmap for a target class at a target conv layer."""
    # 1. Hook the target layer to capture activations and gradients
    activations, gradients = {}, {}
    def fwd_hook(m, inp, out): activations['value'] = out
    def bwd_hook(m, inp, grad_out): gradients['value'] = grad_out[0]
    h1 = target_layer.register_forward_hook(fwd_hook)
    h2 = target_layer.register_full_backward_hook(bwd_hook)

    # 2. Forward pass — get the class score
    output = model(image)                    # (1, num_classes)
    score = output[0, target_class]          # scalar

    # 3. Backward pass — gradients flow into the target layer
    model.zero_grad()
    score.backward()

    # 4. Global average pooling of gradients → importance weights α
    alpha = gradients['value'].mean(dim=(2, 3), keepdim=True)  # (1, K, 1, 1)

    # 5. Weighted combination + ReLU
    cam = F.relu((alpha * activations['value']).sum(dim=1, keepdim=True))

    # 6. Upsample to image size and normalize
    cam = F.interpolate(cam, size=image.shape[2:], mode='bilinear')
    cam = (cam - cam.min()) / (cam.max() - cam.min() + 1e-8)

    h1.remove(); h2.remove()
    return cam.squeeze()          # (H, W) heatmap in [0, 1]

Limitations and what came next

Grad-CAM is powerful but not perfect:

  • Coarse resolution. The heat map has the resolution of the last convolutional layer (e.g. 14×14 for VGG-16). Fine boundaries are lost. Guided Grad-CAM partially solves this.

  • Gradient saturation. When a class score is near 1.0, gradients approach zero and the heat map becomes noisy. Grad-CAM++ addressed this by using second-order gradients.

  • Single layer. Grad-CAM uses only one layer. Information from earlier layers is lost. Score-CAM later proposed a gradient-free approach based on -wise increase in confidence.

  • Not a full explanation. Grad-CAM shows where but not how — it highlights regions but does not explain the chain. It is a map, not a causal explanation.

Why it mattered

  1. 2013

    Zeiler & Fergus — Deconvolution Visualizations

    Deconvolutional networks reversed the CNN computation to visualize which input patterns activate each feature map. Pixel-level detail, but not class-discriminative.

  2. 2014

    Simonyan et al. — Saliency Maps via Backpropagation

    Computed the gradient of a class score with respect to input pixels to produce saliency maps. First gradient-based visual explanation, but noisy and hard to interpret.

  3. 2015

    Springenberg et al. — Guided Backpropagation

    Combined deconvolution with backpropagation to produce cleaner pixel-level visualizations. Still not class-discriminative.

  4. 2016

    Zhou et al. — CAM (Class Activation Mapping)

    First class-discriminative heat maps by using global average pooling weights. Powerful but restricted to specific architectures.

  5. 2017

    Grad-CAM — the universal solution

    Replaced CAM's architectural weights with gradients, making visual explanations available for any CNN architecture and any differentiable task.

  6. 2018

    Grad-CAM++ — higher-order gradients

    Used second-order gradients as pixel-wise weights for better localization of multiple objects and handling gradient saturation.

  7. 2020

    Score-CAM — gradient-free explanations

    Proposed using the increase in target class confidence when masking with each feature map as the importance weight, removing gradient dependency entirely.

Grad-CAM turned an architectural trick (CAM) into a universal interpretability principle. Every researcher debugging a CNN, every doctor verifying a diagnosis model, every engineer auditing for bias now has a one-line tool: backpropagate from the class, pool the gradients, and see where the model looked.

CitationSelvaraju, Cogswell, Das, Vedantam, Parikh, Batra. Grad-CAM: Visual Explanations from Deep Networks via Gradient-Based Localization. ICCV, 2017.

Terms in this paper