---

Captum 是一个用于 PyTorch 的模型可解释性和理解库。 “Captum”在拉丁语中意为“理解”，它包含了针对 PyTorch 模型的积分梯度、显著性图、SmoothGrad、Vargrad 等通用实现。该库能够快速集成到使用特定领域库（如 torchvision、torchtext 等）构建的模型中。

关于 Captum

随着模型复杂性的增加以及由此带来的透明度不足，模型可解释性方法变得愈发重要。模型理解既是当前活跃的研究领域，也是各行各业在实际应用中关注的重点。Captum 提供了最先进的算法，例如积分梯度、基于概念激活向量的测试（TCAV）、TracIn 影响函数等，这些算法为研究人员和开发者提供了一种简便的方式，以了解哪些特征、训练样本或概念对模型的预测结果产生了影响，以及模型究竟学习了什么、如何学习。此外，Captum 还提供了对抗攻击和最小输入扰动功能，可用于生成反事实解释和对抗性扰动生成。

Captum 帮助机器学习研究人员更轻松地实现可解释性算法，并使其能够与 PyTorch 模型无缝对接。同时，Captum 也使研究人员能够快速将自己的工作与其他库中已有的算法进行基准比较。

目标用户

Captum 的主要受众是希望改进模型、理解哪些概念、特征或训练样本重要的模型开发者，以及专注于开发能够更好地解释各类模型的算法的可解释性研究者。

此外，Captum 也可被在生产环境中使用训练好的模型的应用工程师所采用。通过提升模型的可解释性，Captum 能够简化故障排查，并为最终用户提供更好的解释，说明他们为何会看到某一特定内容，例如电影推荐等。

安装

安装要求

• Python >= 3.10
• PyTorch >= 2.3

安装最新版本

通过 pip 安装发布的 Captum 版本。

使用 pip

pip install captum

手动/开发版安装

如果您想尝试我们的前沿功能（并且不介意偶尔遇到一些小 bug），可以直接从 GitHub 克隆最新主分支进行安装。基本安装步骤如下：

git clone https://github.com/pytorch/captum.git
cd captum
pip install -e .

若需自定义安装，还可运行以下变体：

• pip install -e .[dev]：同时安装所有开发所需的工具（测试、代码检查、文档构建；详见下方的 贡献指南）。
• pip install -e .[tutorials]：同时安装运行教程笔记本所需的所有包。

从手动安装中执行单元测试的方法如下：

# 运行单个单元测试
python -m unittest -v tests.attr.test_saliency
# 运行所有单元测试
pytest -ra

入门

Captum 通过探索对模型预测有贡献的特征，帮助您解释和理解 PyTorch 模型的预测结果。它还能帮助您了解哪些神经元和层对模型的预测至关重要。

让我们将其中一些算法应用于我们为演示目的创建的一个玩具模型。为了简单起见，我们将使用以下架构，但用户也可以自由选择任何他们喜欢的 PyTorch 模型。

import numpy as np

import torch
import torch.nn as nn

from captum.attr import (
    GradientShap,
    DeepLift,
    DeepLiftShap,
    IntegratedGradients,
    LayerConductance,
    NeuronConductance,
    NoiseTunnel,
)

class ToyModel(nn.Module):
    def __init__(self):
        super().__init__()
        self.lin1 = nn.Linear(3, 3)
        self.relu = nn.ReLU()
        self.lin2 = nn.Linear(3, 2)

        # 初始化权重和偏置
        self.lin1.weight = nn.Parameter(torch.arange(-4.0, 5.0).view(3, 3))
        self.lin1.bias = nn.Parameter(torch.zeros(1,3))
        self.lin2.weight = nn.Parameter(torch.arange(-3.0, 3.0).view(2, 3))
        self.lin2.bias = nn.Parameter(torch.ones(1,2))

    def forward(self, input):
        return self.lin2(self_relu(self_lin1(input)))

让我们创建一个模型实例，并将其设置为评估模式。

model = ToyModel()
model.eval()

接下来，我们需要定义简单的输入张量和基线张量。基线属于输入空间，通常不携带任何预测信号。零张量可以作为许多任务的基线。一些可解释性算法，如 IntegratedGradients、DeepLift 和 GradientShap，旨在将输入与基线之间的变化归因于神经网络输出的某个预测类别或值。

我们将对上述网络应用模型可解释性算法，以了解各个神经元/层的重要性，以及输入中对最终预测起重要作用的部分。

为了使计算具有确定性，我们固定随机种子。

torch.manual_seed(123)
np.random.seed(123)

让我们定义输入和基线张量。基线用于一些可解释性算法，例如 IntegratedGradients、DeepLift、GradientShap、NeuronConductance、LayerConductance、InternalInfluence 和 NeuronIntegratedGradients。

input = torch.rand(2, 3)
baseline = torch.zeros(2, 3)

接下来，我们将使用 IntegratedGradients 算法，针对第一个目标输出，为每个输入特征分配归因分数。

ig = IntegratedGradients(model)
attributions, delta = ig.attribute(input, baseline, target=0, return_convergence_delta=True)
print('IG Attributions:', attributions)
print('Convergence Delta:', delta)

输出：

IG Attributions: tensor([[-0.5922, -1.5497, -1.0067],
                         [ 0.0000, -0.2219, -5.1991]])
Convergence Delta: tensor([2.3842e-07, -4.7684e-07])

该算法会输出每个输入元素的归因分数以及收敛误差。收敛误差的绝对值越小，近似效果越好。如果我们不想返回误差，只需不提供 return_convergence_delta 参数即可。返回的误差绝对值可以被解释为每个输入样本的近似误差，也可以作为给定输入和基线下积分近似的准确性的代理指标。如果近似误差较大，我们可以尝试增加积分近似的步数，将 n_steps 设置为更大的值。并非所有算法都会返回近似误差；而那些会返回的算法，则是基于其算法的完备性属性来计算的。

正的归因分数表示该位置的输入对最终预测有正面贡献，负的则相反。归因分数的大小表明了贡献的强度。归因分数为零意味着该特征没有贡献。

同样地，我们也可以将 GradientShap、DeepLift 等归因算法应用于该模型。

GradientShap 首先从基线分布中随机选择一个基线，然后对每个输入示例添加标准差为 0.09 的高斯噪声，重复 n_samples 次。之后，它在每个示例与基线之间随机选取一点，并计算相对于目标类（本例中为 0）的梯度。最终的归因结果是梯度乘以 (输入 - 基线) 的平均值。

gs = GradientShap(model)

# 我们定义一个基线分布，并从中抽取 `n_samples` 个样本，以估计所有基线上的梯度期望值
baseline_dist = torch.randn(10, 3) * 0.001
attributions, delta = gs.attribute(input, stdevs=0.09, n_samples=4, baselines=baseline_dist,
                                   target=0, return_convergence_delta=True)
print('GradientShap Attributions:', attributions)
print('Convergence Delta:', delta)

输出：

GradientShap Attributions: tensor([[-0.1542, -1.6229, -1.5835],
                                   [-0.3916, -0.2836, -4.6851]])
Convergence Delta: tensor([ 0.0000, -0.0005, -0.0029, -0.0084, -0.0087, -0.0405,  0.0000, -0.0084])

对于每个 n_samples * input.shape[0] 个示例，都会计算出相应的误差。用户可以对这些误差取平均值：

deltas_per_example = torch.mean(delta.reshape(input.shape[0], -1), dim=1)

以得到每个示例的平均误差。

以下是我们在上述 ToyModel 上应用 DeepLift 和 DeepLiftShap 的示例。目前的 DeepLift 实现仅支持 Rescale 规则。有关其他实现方式的详细信息，请参阅 DeepLift 论文。

dl = DeepLift(model)
attributions, delta = dl.attribute(input, baseline, target=0, return_convergence_delta=True)
print('DeepLift Attributions:', attributions)
print('Convergence Delta:', delta)

输出：

DeepLift Attributions: tensor([[-0.5922, -1.5497, -1.0067],
                               [ 0.0000, -0.2219, -5.1991]])
Convergence Delta: tensor([0., 0.])

DeepLift 为输入分配的归因分数与 IntegratedGradients 类似，但其执行时间更短。关于 DeepLift 的另一个重要注意事项是，它目前并不支持所有非线性激活函数。有关当前实现局限性的详细信息，请参阅 DeepLift 论文。

与 IntegratedGradients 类似，DeepLift 也会为每个输入示例返回收敛误差。该误差的绝对值可作为算法近似准确性的代理指标。

现在让我们来看看 DeepLiftShap。与 GradientShap 类似，DeepLiftShap 也使用基线分布。在下面的示例中，我们使用了与 GradientShap 相同的基线分布。

dl = DeepLiftShap(model)
attributions, delta = dl.attribute(input, baseline_dist, target=0, return_convergence_delta=True)
print('DeepLiftSHAP Attributions:', attributions)
print('Convergence Delta:', delta)

输出：

DeepLiftShap Attributions: tensor([[-5.9169e-01, -1.5491e+00, -1.0076e+00],
                                   [-4.7101e-03, -2.2300e-01, -5.1926e+00]], grad_fn=<MeanBackward1>)
Convergence Delta: tensor([-4.6120e-03, -1.6267e-03, -5.1045e-04, -1.4184e-03, -6.8886e-03,
                           -2.2224e-02,  0.0000e+00, -2.8790e-02, -4.1285e-03, -2.7295e-02,
                           -3.2349e-03, -1.6265e-03, -4.7684e-07, -1.4191e-03, -6.8889e-03,
                           -2.2224e-02,  0.0000e+00, -2.4792e-02, -4.1289e-03, -2.7296e-02])

DeepLiftShap 使用 DeepLift 来计算每个输入-基线对的归因分数，并对所有基线上的每个输入取平均值。

它会为每个输入样本-基线对计算差异值，因此会产生 input.shape[0] * baseline.shape[0] 个差异值。

与 GradientShap 类似，为了计算基于样本的差异值，我们可以按样本对它们进行平均：

deltas_per_example = torch.mean(delta.reshape(input.shape[0], -1), dim=1)

为了平滑并提高归因的质量，我们可以将 IntegratedGradients 和其他归因方法通过 NoiseTunnel 运行。NoiseTunnel 允许我们使用 SmoothGrad、SmoothGrad_Sq 和 VarGrad 技术，通过对多个添加了高斯噪声的样本进行聚合来平滑归因结果。

以下是一个如何将 NoiseTunnel 与 IntegratedGradients 结合使用的示例。

ig = IntegratedGradients(model)
nt = NoiseTunnel(ig)
attributions, delta = nt.attribute(input, nt_type='smoothgrad', stdevs=0.02, nt_samples=4,
      baselines=baseline, target=0, return_convergence_delta=True)
print('IG + SmoothGrad Attributions:', attributions)
print('Convergence Delta:', delta)

输出：

IG + SmoothGrad Attributions: tensor([[-0.4574, -1.5493, -1.0893],
                                      [ 0.0000, -0.2647, -5.1619]])
Convergence Delta: tensor([ 0.0000e+00,  2.3842e-07,  0.0000e+00, -2.3842e-07,  0.0000e+00,
        -4.7684e-07,  0.0000e+00, -4.7684e-07])

delta 张量中的元素数量等于：nt_samples * input.shape[0]。为了得到每个样本的差异值，我们可以例如对它们取平均：

deltas_per_example = torch.mean(delta.reshape(input.shape[0], -1), dim=1)

让我们深入研究我们的网络内部，了解哪些层和神经元对预测很重要。

我们将从 NeuronConductance 开始。NeuronConductance 帮助我们识别对给定层中某个特定神经元重要的输入特征。它通过链式法则分解集成梯度的计算，将神经元的重要性定义为输出对神经元的导数与神经元对模型输入的导数的路径积分乘积。

在本例中，我们选择分析线性层中的第一个神经元。

nc = NeuronConductance(model, model.lin1)
attributions = nc.attribute(input, neuron_selector=1, target=0)
print('Neuron Attributions:', attributions)

输出：

Neuron Attributions: tensor([[ 0.0000,  0.0000,  0.0000],
                             [ 1.3358,  0.0000, -1.6811]])

层导通率显示了神经元对于某一层及给定输入的重要性。它是隐藏层路径积分梯度的扩展版本，并且同样具有完备性。

它不会将贡献分数归因于输入特征，而是展示所选层中每个神经元的重要性。

lc = LayerConductance(model, model.lin1)
attributions, delta = lc.attribute(input, baselines=baseline, target=0, return_convergence_delta=True)
print('Layer Attributions:', attributions)
print('Convergence Delta:', delta)

输出：

Layer Attributions: tensor([[ 0.0000,  0.0000, -3.0856],
                            [ 0.0000, -0.3488, -4.9638]], grad_fn=<SumBackward1>)
Convergence Delta: tensor([0.0630, 0.1084])

与其他返回收敛差值的归因算法类似，LayerConductance 也会为每个样本返回差异值。近似误差即为收敛差值的绝对值，可以作为衡量给定输入和基线下积分近似准确性的指标。

有关支持的算法列表以及如何将 Captum 应用于不同类型模型的更多详细信息，请参阅我们的教程。

Captum Insights（已停用）

Captum Insights 在 v0.8.0 版本之后已被弃用，不再受支持。您可以查看 v0.8.0 标签下的仓库以查看已废弃的代码。

常见问题解答

如果您对使用 Captum 方法有任何疑问，请查阅此 FAQ，其中解答了许多常见问题。

贡献

请参阅 CONTRIBUTING 文件，了解如何参与贡献。

演讲和论文

NeurIPS 2019： 我们演讲的幻灯片可以在这里找到 这里

KDD 2020： 我们在 KDD 2020 研讨会上的演讲幻灯片可以在这里找到 这里。 您也可以观看录制的演讲 这里

GTC 2020： 打开黑箱：使用 Captum 和 PyTorch 理解模型。 您可以通过观看录制的演讲 这里 来了解更多信息。

XAI Summit 2020： 使用 Captum 和 Fiddler 通过可解释的人工智能提升模型理解能力。 您可以通过观看录制的演讲 这里 来了解更多信息。

PyTorch Developer Day 2020 模型可解释性。 您可以通过观看录制的演讲 这里 来了解更多信息。

NAACL 2021 关于深度 NLP 模型中细粒度解释和因果分析的教程。 您可以通过观看录制的演讲 这里 来了解更多信息。

ICLR 2021 关于负责任的人工智能的研讨会：

• 论文 关于 Captum 库
• 论文 关于探索显著性图的合理性检查

里昂大学的医学影像暑期学校有一节关于模型可解释性的课程，您可以通过观看 这里 来了解更多信息。

算法参考文献

• IntegratedGradients、LayerIntegratedGradients：深度神经网络的公理化归因，Mukund Sundararajan 等人，2017 年 和 模型是否理解了问题？，Pramod K. Mudrakarta 等人，2018 年
• InputXGradient：不只是黑箱：通过传播激活差异学习重要特征，Avanti Shrikumar 等人，2016 年
• SmoothGrad：SmoothGrad：通过添加噪声去除噪声，Daniel Smilkov 等人，2017 年
• NoiseTunnel：显著性图的合理性检验，Julius Adebayo 等人，2018 年
• NeuronConductance：一个神经元有多重要？，Kedar Dhamdhere 等人，2018 年
• LayerConductance：高效的内部神经元重要性度量，Avanti Shrikumar 等人，2018 年
• DeepLift、NeuronDeepLift、LayerDeepLift：通过传播激活差异学习重要特征，Avanti Shrikumar 等人，2017 年 和 更好地理解基于梯度的深度神经网络归因方法，Marco Ancona 等人，2018 年
• NeuronIntegratedGradients：高效的内部神经元重要性度量，Avanti Shrikumar 等人，2018 年
• GradientShap、NeuronGradientShap、LayerGradientShap、DeepLiftShap、NeuronDeepLiftShap、LayerDeepLiftShap：解释模型预测的统一方法，Scott M. Lundberg 等人，2017 年
• InternalInfluence：面向深度卷积神经网络的影响导向解释，Klas Leino 等人，2018 年
• Saliency、NeuronGradient：深入卷积神经网络：可视化图像分类模型和显著性图，K. Simonyan 等人，2014 年
• GradCAM、Guided GradCAM：Grad-CAM：通过基于梯度的定位实现深度网络的视觉解释，Ramprasaath R. Selvaraju 等人，2017 年
• Deconvolution、Neuron Deconvolution：可视化与理解卷积神经网络，Matthew D Zeiler 等人，2014 年
• Guided Backpropagation、Neuron Guided Backpropagation：追求简单：全卷积网络，Jost Tobias Springenberg 等人，2015 年
• Feature Permutation：特征置换重要性
• Occlusion：可视化与理解卷积神经网络
• Shapley Value：n 人博弈的价值。博弈论贡献 2.28（1953）：307–317
• Shapley Value Sampling：基于采样的 Shapley 值多项式计算
• Infidelity and Sensitivity：关于解释的（不）忠实性和敏感性
• TracInCP、TracInCPFast、TracInCPRandProj：通过追踪梯度下降估计训练数据的影响
• SimilarityInfluence：[基于预定义相似性度量的训练样本与测试样本之间的成对相似性]
• BinaryConcreteStochasticGates：具有二值 Concrete 分布的随机门控机制
• GaussianStochasticGates：具有高斯分布的随机门控机制

有关上述归因算法及其优缺点的更多详细信息，请参阅我们的网站。

许可证

Captum 采用 BSD 许可证，具体见LICENSE 文件。

Captum 快速上手指南

Captum 是专为 PyTorch 打造的模型可解释性库，提供集成梯度（Integrated Gradients）、Saliency Maps、DeepLift 等前沿算法，帮助开发者理解模型预测背后的特征贡献、神经元重要性及训练数据影响。

环境准备

在开始之前，请确保您的开发环境满足以下最低要求：

• Python: >= 3.10
• PyTorch: >= 2.3
• 操作系统: Linux, macOS 或 Windows

安装步骤

推荐使用 pip 安装最新稳定版。国内用户建议使用清华或阿里镜像源以加速下载。

使用 pip 安装（推荐）

pip install captum -i https://pypi.tuna.tsinghua.edu.cn/simple

开发者安装（获取最新特性）

如果您需要体验 GitHub 上的最新功能（可能包含未稳定的 Bug），可源码安装：

git clone https://github.com/pytorch/captum.git
cd captum
pip install -e . -i https://pypi.tuna.tsinghua.edu.cn/simple

注：若需运行官方教程笔记，可使用 pip install -e .[tutorials]。

基本使用

以下示例演示如何在一个简单的 PyTorch 模型上使用 Integrated Gradients (IG) 算法计算输入特征的归因分数。

1. 定义模型与数据

首先构建一个简单的全连接网络，并设置输入张量和基线（Baseline）。基线通常设为零张量，代表无预测信号的状态。

import numpy as np
import torch
import torch.nn as nn
from captum.attr import IntegratedGradients

# 定义一个简单的玩具模型
class ToyModel(nn.Module):
    def __init__(self):
        super().__init__()
        self.lin1 = nn.Linear(3, 3)
        self.relu = nn.ReLU()
        self.lin2 = nn.Linear(3, 2)

        # 初始化权重和偏置以便复现结果
        self.lin1.weight = nn.Parameter(torch.arange(-4.0, 5.0).view(3, 3))
        self.lin1.bias = nn.Parameter(torch.zeros(1,3))
        self.lin2.weight = nn.Parameter(torch.arange(-3.0, 3.0).view(2, 3))
        self.lin2.bias = nn.Parameter(torch.ones(1,2))

    def forward(self, input):
        return self.lin2(self.relu(self.lin1(input)))

# 实例化模型并设为评估模式
model = ToyModel()
model.eval()

# 固定随机种子以确保结果可复现
torch.manual_seed(123)
np.random.seed(123)

# 定义输入和基线
input = torch.rand(2, 3)
baseline = torch.zeros(2, 3)

2. 应用归因算法

使用 IntegratedGradients 计算每个输入特征对目标类别（此处为 target=0）的贡献度。

# 初始化算法
ig = IntegratedGradients(model)

# 计算归因分数
# return_convergence_delta=True 用于检查积分近似误差，值越小越准确
attributions, delta = ig.attribute(input, baseline, target=0, return_convergence_delta=True)

print('IG Attributions:', attributions)
print('Convergence Delta:', delta)

输出示例：

IG Attributions: tensor([[-0.5922, -1.5497, -1.0067],
                         [ 0.0000, -0.2219, -5.1991]])
Convergence Delta: tensor([2.3842e-07, -4.7684e-07])

结果解读

• Attributions (归因分数):
  • 正值表示该特征对预测结果有正向贡献。
  • 负值表示该特征对预测结果有负向贡献。
  • 绝对值大小代表贡献的强度。
• Convergence Delta: 表示积分近似的误差。如果该值较大，可以通过增加 n_steps 参数来提高计算精度（例如：ig.attribute(..., n_steps=50)）。

除了 IntegratedGradients，Captum 还支持 GradientShap、DeepLift、Saliency 等多种算法，使用方法类似，只需替换对应的类即可。