CAM、Grad-CAM 與 Feature Visualization

F_k = (1/Z) × sum_(i,j) A^k_(i,j)
y_c = b_c + sum_k w^c_k F_k

CAM_c(i,j) = sum_k w^c_k A^k_(i,j)
因此 y_c = b_c + mean_(i,j)[CAM_c(i,j)]

A1 = [[1,2],       A2 = [[0,1],
      [0,1]]             [3,2]]

F1=1，F2=1.5
類別權重 w=(2,−1)，bias=.5
logit = 2×1 −1×1.5 +.5 = 1

CAM = 2A1 − A2
    = [[2,3],
       [−3,0]]

mean(CAM) = (2+3−3+0)/4 = .5
mean(CAM)+bias = 1

alpha^c_k = (1/Z) × sum_(i,j) ∂y_c/∂A^k_(i,j)
L_before_ReLU(i,j) = sum_k alpha^c_k × A^k_(i,j)
L_GradCAM = ReLU(L_before_ReLU)

∂y_c/∂A^k_(i,j) = w^c_k/Z
alpha^c_k = (1/Z) × Z × (w^c_k/Z) = w^c_k/Z

Grad-CAM的ReLU前圖 = [[.5,.75],
                     [−.75,0]]
                   = CAM/4

Grad-CAM ReLU後 = [[.5,.75],
                  [0,0]]

[[2/3,1],
 [0,0]]

目標 J(u) = 選定活動 a(u) − prior／regularizer
u_next = u + learning_rate × ∂J/∂u

固定 v=(2,−1,.5)，輸入u起始為(0,0,0)
a(u) = v·u
J(u) = v·u − lambda/2 × ||u||²
梯度 = v − lambda×u
每次更新 u_next = u + .2×gradient

python3 cam_and_input_ascent.py

#!/usr/bin/env python3
"""Fixed feature-map CAM/Grad-CAM and tiny input-optimization mechanics.

No CNN, dataset, checkpoint, image generation or model training is used.
Autograd differentiates a hand-set mean-GAP linear head and a 3D objective.
"""

from fractions import Fraction as F
import json
import torch

DTYPE = torch.float64
DEVICE = "cpu"


def head_logit(features, weights, bias):
    return (features.mean(dim=(-2, -1)) * weights).sum() + bias


def python_logit(features, weights, bias):
    """Scalar arithmetic reference, independent of tensor mean/autograd."""
    return sum(w * sum(sum(row) for row in channel) / 4
               for w, channel in zip(weights, features)) + bias


def peak_normalize(nonnegative_map):
    maximum = nonnegative_map.max()
    return nonnegative_map / maximum if maximum.item() > 0 else torch.zeros_like(nonnegative_map)


def map_checks():
    features = torch.tensor([[[1., 2.], [0., 1.]],
                             [[0., 1.], [3., 2.]]], dtype=DTYPE, device=DEVICE, requires_grad=True)
    weights = torch.tensor([2., -1.], dtype=DTYPE, device=DEVICE)
    bias = 0.5
    spatial_count = 4
    logit = head_logit(features, weights, bias)
    gradients, = torch.autograd.grad(logit, features)
    alpha = gradients.mean(dim=(-2, -1))
    cam_signed = (weights[:, None, None] * features).sum(dim=0)
    gradcam_signed = (alpha[:, None, None] * features).sum(dim=0)
    cam_positive, gradcam_positive = torch.relu(cam_signed), torch.relu(gradcam_signed)

    shifted_logit = head_logit(features, weights, bias + 2)
    shifted_gradient, = torch.autograd.grad(shifted_logit, features)
    finite = torch.empty_like(features)
    step = 1e-5
    source = features.detach().tolist()
    for k in range(2):
        for i in range(2):
            for j in range(2):
                plus = [[row[:] for row in channel] for channel in source]
                minus = [[row[:] for row in channel] for channel in source]
                plus[k][i][j] += step
                minus[k][i][j] -= step
                finite[k, i, j] = (python_logit(plus, weights.tolist(), bias)
                                   - python_logit(minus, weights.tolist(), bias)) / (2 * step)

    expected_cam = torch.tensor([[2., 3.], [-3., 0.]], dtype=DTYPE)
    torch.testing.assert_close(cam_signed, expected_cam, rtol=0, atol=0)
    torch.testing.assert_close(alpha, weights / spatial_count, rtol=0, atol=0)
    torch.testing.assert_close(gradcam_signed, cam_signed / spatial_count, rtol=0, atol=0)
    torch.testing.assert_close(gradients, finite, rtol=0, atol=1e-9)
    torch.testing.assert_close(shifted_gradient, gradients, rtol=0, atol=0)
    torch.testing.assert_close(cam_signed.mean() + bias, logit, rtol=0, atol=0)
    torch.testing.assert_close(gradcam_signed.sum() + bias, logit, rtol=0, atol=0)
    torch.testing.assert_close(peak_normalize(cam_positive), peak_normalize(gradcam_positive), rtol=0, atol=0)
    assert (gradcam_positive.sum() + bias).item() != logit.item()

    return {"feature_shape_K_H_W": list(features.shape), "feature_maps": source,
            "class_weights": weights.tolist(), "bias": bias, "GAP_convention": "mean of 4 spatial positions",
            "gap_features": features.mean(dim=(-2, -1)).detach().tolist(), "raw_class_logit": logit.item(),
            "score_gradients_wrt_features": gradients.tolist(), "central_difference_gradients": finite.tolist(),
            "central_difference_max_abs_error": (gradients - finite).abs().max().item(),
            "gradcam_alpha": alpha.tolist(), "CAM_signed": cam_signed.detach().tolist(),
            "GradCAM_before_ReLU": gradcam_signed.detach().tolist(),
            "CAM_after_ReLU_for_comparison": cam_positive.detach().tolist(),
            "GradCAM_after_ReLU": gradcam_positive.detach().tolist(),
            "CAM_mean_plus_bias": (cam_signed.mean() + bias).item(),
            "GradCAM_before_ReLU_sum_plus_bias": (gradcam_signed.sum() + bias).item(),
            "GradCAM_after_ReLU_sum_plus_bias": (gradcam_positive.sum() + bias).item(),
            "peak_normalized_CAM_positive": peak_normalize(cam_positive).detach().tolist(),
            "peak_normalized_GradCAM": peak_normalize(gradcam_positive).detach().tolist(),
            "bias_plus_2_changes_logit_to": shifted_logit.item(),
            "bias_shift_max_gradient_change": (shifted_gradient - gradients).abs().max().item(),
            "scope": "head-only fixed feature maps, not input pixels; signed CAM and standard positive Grad-CAM are distinct"}


def input_ascent(prior_strength):
    vector = torch.tensor([2., -1., 0.5], dtype=DTYPE, device=DEVICE)
    u = torch.zeros(3, dtype=DTYPE, device=DEVICE, requires_grad=True)
    learning_rate, total_steps = 0.2, 20
    records, objectives = [], []
    max_gradient_error = 0.
    for step in range(total_steps + 1):
        activation = (vector * u).sum()
        penalty = prior_strength / 2 * u.square().sum()
        objective = activation - penalty
        gradient, = torch.autograd.grad(objective, u)
        max_gradient_error = max(max_gradient_error, (gradient - (vector - prior_strength * u)).abs().max().item())
        objectives.append(objective.item())
        if step in (0, 1, 5, total_steps):
            records.append({"step": step, "input_u": u.detach().tolist(), "feature_activation": activation.item(),
                            "L2_penalty": penalty.item(), "objective": objective.item(),
                            "objective_gradient": gradient.detach().tolist()})
        if step < total_steps:
            # Optimize the input, not the fixed vector. No optimizer or model fit.
            with torch.no_grad():
                u.add_(learning_rate * gradient)

    if prior_strength == 0:
        expected = total_steps * learning_rate * vector
        optimum_note = "No finite maximizer: a nonzero linear feature is unbounded on unconstrained R^3"
        analytic = None
    else:
        optimum = vector / prior_strength
        # For lambda=.5, lr=.2, recurrence is u_n=(1-(9/10)^n)*(4,-2,1).
        q = F(1) - F(9, 10) ** total_steps
        expected = torch.tensor([float(F(4) * q), float(F(-2) * q), float(q)], dtype=DTYPE)
        analytic = {"optimal_input": optimum.tolist(), "optimal_objective": 5.25,
                    "finite_step_exact_factor": str(q), "finite_step_reference": expected.tolist(),
                    "objective_gap_to_optimum": 5.25 - records[-1]["objective"]}
        optimum_note = "Unique maximum for this unconstrained concave quadratic; no claim for a CNN objective"
    torch.testing.assert_close(u, expected, rtol=0, atol=1e-12)
    assert max_gradient_error < 1e-12
    assert all(b >= a - 1e-12 for a, b in zip(objectives, objectives[1:]))
    return {"fixed_feature_vector": vector.tolist(), "optimized_variable": "unconstrained 3D input u",
            "objective": "v dot u - lambda/2 * ||u||^2", "lambda": prior_strength,
            "learning_rate": learning_rate, "updates": total_steps, "selected_actual_iterates": records,
            "max_autograd_vs_analytic_gradient_error": max_gradient_error,
            "finite_step_max_reference_error": (u.detach() - expected).abs().max().item(),
            "analytic_reference": analytic, "optimization_scope": optimum_note}


def main():
    result = {"environment": {"torch": torch.__version__, "device": DEVICE, "dtype": "float64",
                              "random_sampling": False, "model_or_dataset_download": False},
              "CAM_GradCAM_fixed_maps": map_checks(),
              "feature_activation_input_ascent_no_prior": input_ascent(0.0),
              "feature_activation_input_ascent_L2_prior": input_ascent(0.5),
              "limits": ["no CNN forward, real photograph, trained checkpoint, localization accuracy or pixel causal test",
                         "mean-GAP linear head gives alpha=w/Z; this equality is not general for nonlinear heads",
                         "ReLU discards negative evidence; peak normalization can hide raw constant scale",
                         "input ascent is actual optimization of a hand-set vector, not a generated CNN image or model training",
                         "L2 prior here is a toy constraint, not a claim to natural-image realism"]}
    print(json.dumps(result, ensure_ascii=False, indent=2))


if __name__ == "__main__":
    main()

# DS59 image credits

These source-derived illustrations are licensed under **CC BY 4.0** as described below. Each source keeps its authorship and individual grant. Where modified, the modification is stated. The license terms are available at <https://creativecommons.org/licenses/by/4.0/>.

## Distill feature visualization

**Source:** Chris Olah, Alexander Mordvintsev, and Ludwig Schubert, “Feature Visualization,” Distill (2017), <https://distill.pub/2017/feature-visualization/>; mixed4a unit 97 simple-optimization and diversity-optimization images.

**License:** CC BY 4.0 for the article content, based on the article-specific reuse statement and the official article repository README. The code’s Apache 2.0 license is separate and is not the basis for image reuse. No third-party figure credit is attached to these two source images.

**Changes:** `fig01-featureviz-simple.png` and `fig02-featureviz-diversity.png` are byte-for-byte source copies. `fig02-featureviz-diversity-mobile.png` shows the whole source image first, followed by its four complete original tiles stacked vertically on white. No data-example photograph or new mark is included.

## Feature hierarchy diagram

**Source:** Martin Zurowietz and Tim W. Nattkemper, Figure 1, “An Interactive Visualization for Feature Localization in Deep Neural Networks,” Frontiers in Artificial Intelligence (2020), <https://doi.org/10.3389/frai.2020.00049>. The figure caption identifies it as adapted from Chris Olah, Alexander Mordvintsev, and Ludwig Schubert, “Feature Visualization,” Distill (2017), <https://distill.pub/2017/feature-visualization/>.

**License:** CC BY 4.0. Preserve both the Frontiers authors’ attribution and the cited Distill source attribution.

**Changes:** `fig03-feature-hierarchy.png` is the original 1429×549 WebP decoded and encoded as PNG without cropping or content changes. `fig03-feature-hierarchy-mobile.png` places the full diagram first, then stacks four complete original columns on white. No text, arrows, or values were added.

## Conventional CAM diagram

**Source:** Felipe Oviedo, Juan Lavista Ferres, Tonio Buonassisi, and Keith T. Butler, Figure 3(a), “Interpretable and Explainable Machine Learning for Materials Science and Chemistry,” Accounts of Materials Research 3(6) (2022), DOI <https://doi.org/10.1021/accountsmr.1c00244>. Canonical MIT repository record: <https://hdl.handle.net/1721.1/150806>.

**License:** CC BY 4.0, supported by the MIT repository record for the final published version and the DOI’s Crossref license metadata. Only author-made panel 3(a) is included. Panel 3(b), which is explicitly reproduced from another source, is excluded and is not covered by this notice.

**Changes:** `fig04-cam-schematic.png` is panel 3(a) cropped from the composite at source-pixel box `[0,0,1155,831]`; the crop stops before the dotted divider and panel 3(b). `fig04-cam-schematic-mobile.png` shows that full panel first and then stacks three original legend text/detail groups on white; complete symbol frames should be read in the whole panel. The first group uses source box `[20,704,380,827]` so the final letter of “Fully connected network” remains intact; it stops before the next legend group at x=411. `cover-candidate-cam-schematic.png` proportionally fits the complete panel 3(a) on a white 1600×900 canvas. No labels, values, lines, or other marks were added.

## Grad-CAM process schematic

**Source:** Jong-Chih Chien, Jiann-Der Lee, Ching-Shu Hu, and Chieh-Tsai Wu, Figure 2, “The Usefulness of Gradient-Weighted CAM in Assisting Medical Diagnoses,” Applied Sciences 12(15):7748 (2022), <https://doi.org/10.3390/app12157748>.

**License:** CC BY 4.0, expressly stated in the article. The selected Figure 2 has no separate third-party credit. The medical scan examples in a later figure are not included.

**Changes:** `fig05-gradcam-pipeline.png` is Figure 2 with its complete original caption, cropped from a 300-dpi render of page 4 of the article PDF at source-pixel box `[680,640,1810,1635]`. No drawing, wording, or values were added or changed.

The MDPI schematic illustrates a process and is not used as the authority for the canonical Grad-CAM weighting equation. The ACS diagram illustrates conventional CAM and must not be described as gradient-derived Grad-CAM.