tdhook.attribution.lrp_helpers.rules

LRP rules.

This code is adapted from the Zennit library (LGPL-3.0) and the LXT library (Clear BSD) Original sources: - chr5tphr/zennit - rachtibat/LRP-eXplains-Transformers

Classes

ParamModifier
RemovableRuleHandle
AbstractFunctionMeta	Metaclass for defining Abstract Base Classes (ABCs).
Rule	Base class for LRP rules implemented as custom autograd functions.
EpsilonRule	Base class for LRP rules implemented as custom autograd functions.
UniformEpsilonRule	Base class for LRP rules implemented as custom autograd functions.
PassRule	Base class for LRP rules implemented as custom autograd functions.
IgnoreRule	Base class for LRP rules implemented as custom autograd functions.
WSquareRule	Base class for LRP rules implemented as custom autograd functions.
FlatRule	Base class for LRP rules implemented as custom autograd functions.
UniformRule	Base class for LRP rules implemented as custom autograd functions.
StopRule	Base class for LRP rules implemented as custom autograd functions.
AlphaBetaRule	Base class for LRP rules implemented as custom autograd functions.
SoftmaxEpsilonRule	Base class for LRP rules implemented as custom autograd functions.
LayerNormRule	Base class for LRP rules implemented as custom autograd functions.
PseudoIdentityRule	Base class for LRP rules implemented as custom autograd functions.
AHQKVRule	Base class for LRP rules implemented as custom autograd functions.
BaseRuleMapper
EpsilonPlus

Functions

stabilize(tensor[, epsilon])
raise_for_unconserved_rel_factory([atol, rtol])

Module Contents

tdhook.attribution.lrp_helpers.rules.stabilize(tensor, epsilon=1e-06)

class tdhook.attribution.lrp_helpers.rules.ParamModifier(modify_fn=None, select_fn=None)

Parameters:

• modify_fn (Optional[Callable[[str, torch.nn.Parameter], torch.Tensor]])

• select_fn (Optional[Callable[[str, torch.nn.Parameter], bool]])

_modify_fn

_select_fn

state_dicts(module)

Parameters:

module (torch.nn.Module)

__call__(module)

Parameters:

module (torch.nn.Module)

static from_modifiers(modifiers)

Parameters:

modifiers (List[ParamModifier])

static select_all(name, param)

Parameters:

• name (str)

• param (torch.nn.Parameter)

class tdhook.attribution.lrp_helpers.rules.RemovableRuleHandle(rule, module)

Parameters:

• rule (Rule)

• module (torch.nn.Module)

_rule

_module_ref

__enter__()

__exit__(exc_type, exc_value, traceback)

remove()

class tdhook.attribution.lrp_helpers.rules.AbstractFunctionMeta(name, bases, attrs)

Bases: abc.ABCMeta, torch.autograd.function.FunctionMeta

Metaclass for defining Abstract Base Classes (ABCs).

Use this metaclass to create an ABC. An ABC can be subclassed directly, and then acts as a mix-in class. You can also register unrelated concrete classes (even built-in classes) and unrelated ABCs as ‘virtual subclasses’ – these and their descendants will be considered subclasses of the registering ABC by the built-in issubclass() function, but the registering ABC won’t show up in their MRO (Method Resolution Order) nor will method implementations defined by the registering ABC be callable (not even via super()).

class tdhook.attribution.lrp_helpers.rules.Rule

Bases: torch.autograd.function.Function

Base class for LRP rules implemented as custom autograd functions.

Subclasses override forward() and backward() to define how relevance is propagated through a wrapped module. Instances are registered onto modules by temporarily replacing module.forward with Function.apply(…).

_apply_kwargs

register(module)

Parameters:

module (torch.nn.Module)

unregister(module)

Parameters:

module (torch.nn.Module)

static forward(ctx, apply_kwargs, module, model_kwargs, *inputs)

Abstractmethod:

Run the wrapped module and save any tensors needed for relevance propagation.

static backward(ctx, *out_relevance)

Abstractmethod:

Propagate output relevance back to the inputs of the wrapped module.

class tdhook.attribution.lrp_helpers.rules.EpsilonRule(epsilon=1e-06)

Bases: Rule

Base class for LRP rules implemented as custom autograd functions.

Subclasses override forward() and backward() to define how relevance is propagated through a wrapped module. Instances are registered onto modules by temporarily replacing module.forward with Function.apply(…).

property epsilon

static forward(ctx, apply_kwargs, module, model_kwargs, *inputs)

Run the wrapped module and save any tensors needed for relevance propagation.

static backward(ctx, *out_relevance)

Propagate output relevance back to the inputs of the wrapped module.

class tdhook.attribution.lrp_helpers.rules.UniformEpsilonRule(epsilon=1e-06)

Bases: EpsilonRule

Base class for LRP rules implemented as custom autograd functions.

Subclasses override forward() and backward() to define how relevance is propagated through a wrapped module. Instances are registered onto modules by temporarily replacing module.forward with Function.apply(…).

static backward(ctx, *out_relevance)

Propagate output relevance back to the inputs of the wrapped module.

class tdhook.attribution.lrp_helpers.rules.PassRule

Bases: Rule

Base class for LRP rules implemented as custom autograd functions.

Subclasses override forward() and backward() to define how relevance is propagated through a wrapped module. Instances are registered onto modules by temporarily replacing module.forward with Function.apply(…).

static forward(ctx, apply_kwargs, module, model_kwargs, *inputs)

Run the wrapped module and save any tensors needed for relevance propagation.

static backward(ctx, *out_relevance)

Propagate output relevance back to the inputs of the wrapped module.

class tdhook.attribution.lrp_helpers.rules.IgnoreRule

Bases: Rule

Base class for LRP rules implemented as custom autograd functions.

Subclasses override forward() and backward() to define how relevance is propagated through a wrapped module. Instances are registered onto modules by temporarily replacing module.forward with Function.apply(…).

register(module)

Parameters:

module (torch.nn.Module)

unregister(module)

Parameters:

module (torch.nn.Module)

static forward(ctx, apply_kwargs, module, model_kwargs, *inputs)

Run the wrapped module and save any tensors needed for relevance propagation.

static backward(ctx, *out_relevance)

Propagate output relevance back to the inputs of the wrapped module.

class tdhook.attribution.lrp_helpers.rules.WSquareRule(stabilizer=1e-06)

Bases: Rule

Base class for LRP rules implemented as custom autograd functions.

Subclasses override forward() and backward() to define how relevance is propagated through a wrapped module. Instances are registered onto modules by temporarily replacing module.forward with Function.apply(…).

static forward(ctx, apply_kwargs, module, model_kwargs, *inputs)

Run the wrapped module and save any tensors needed for relevance propagation.

static backward(ctx, *out_relevance)

Propagate output relevance back to the inputs of the wrapped module.

class tdhook.attribution.lrp_helpers.rules.FlatRule(stabilizer=1e-06)

Bases: WSquareRule

Base class for LRP rules implemented as custom autograd functions.

Subclasses override forward() and backward() to define how relevance is propagated through a wrapped module. Instances are registered onto modules by temporarily replacing module.forward with Function.apply(…).

class tdhook.attribution.lrp_helpers.rules.UniformRule

Bases: Rule

Base class for LRP rules implemented as custom autograd functions.

Subclasses override forward() and backward() to define how relevance is propagated through a wrapped module. Instances are registered onto modules by temporarily replacing module.forward with Function.apply(…).

static forward(ctx, apply_kwargs, module, model_kwargs, *inputs)

Run the wrapped module and save any tensors needed for relevance propagation.

static backward(ctx, *out_relevances)

Propagate output relevance back to the inputs of the wrapped module.

class tdhook.attribution.lrp_helpers.rules.StopRule

Bases: Rule

Base class for LRP rules implemented as custom autograd functions.

Subclasses override forward() and backward() to define how relevance is propagated through a wrapped module. Instances are registered onto modules by temporarily replacing module.forward with Function.apply(…).

static forward(ctx, apply_kwargs, module, model_kwargs, *inputs)

Run the wrapped module and save any tensors needed for relevance propagation.

static backward(ctx, *out_relevances)

Propagate output relevance back to the inputs of the wrapped module.

class tdhook.attribution.lrp_helpers.rules.AlphaBetaRule(alpha=2.0, beta=1.0, stabilizer=1e-06)

Bases: Rule

Base class for LRP rules implemented as custom autograd functions.

Subclasses override forward() and backward() to define how relevance is propagated through a wrapped module. Instances are registered onto modules by temporarily replacing module.forward with Function.apply(…).

static forward(ctx, apply_kwargs, module, model_kwargs, *inputs)

Run the wrapped module and save any tensors needed for relevance propagation.

static backward(ctx, *out_relevance)

Propagate output relevance back to the inputs of the wrapped module.

class tdhook.attribution.lrp_helpers.rules.SoftmaxEpsilonRule(epsilon=1e-06)

Bases: EpsilonRule

Base class for LRP rules implemented as custom autograd functions.

Subclasses override forward() and backward() to define how relevance is propagated through a wrapped module. Instances are registered onto modules by temporarily replacing module.forward with Function.apply(…).

static backward(ctx, *out_relevances)

Propagate output relevance back to the inputs of the wrapped module.

class tdhook.attribution.lrp_helpers.rules.LayerNormRule

Bases: Rule

Base class for LRP rules implemented as custom autograd functions.

Subclasses override forward() and backward() to define how relevance is propagated through a wrapped module. Instances are registered onto modules by temporarily replacing module.forward with Function.apply(…).

static forward(ctx, apply_kwargs, module, model_kwargs, *inputs)

Run the wrapped module and save any tensors needed for relevance propagation.

static backward(ctx, *out_relevances)

Propagate output relevance back to the inputs of the wrapped module.

class tdhook.attribution.lrp_helpers.rules.PseudoIdentityRule(stabilizer=1e-06)

Bases: Rule

Base class for LRP rules implemented as custom autograd functions.

Subclasses override forward() and backward() to define how relevance is propagated through a wrapped module. Instances are registered onto modules by temporarily replacing module.forward with Function.apply(…).

static forward(ctx, apply_kwargs, module, model_kwargs, *inputs)

Run the wrapped module and save any tensors needed for relevance propagation.

static backward(ctx, *out_relevances)

Propagate output relevance back to the inputs of the wrapped module.

class tdhook.attribution.lrp_helpers.rules.AHQKVRule

Bases: Rule

Base class for LRP rules implemented as custom autograd functions.

Subclasses override forward() and backward() to define how relevance is propagated through a wrapped module. Instances are registered onto modules by temporarily replacing module.forward with Function.apply(…).

static forward(ctx, apply_kwargs, module, model_kwargs, *inputs)

Run the wrapped module and save any tensors needed for relevance propagation.

static backward(ctx, *out_relevances)

Propagate output relevance back to the inputs of the wrapped module.

class tdhook.attribution.lrp_helpers.rules.BaseRuleMapper(stabilizer=1e-06, rule_mapper=None)

Parameters:

rule_mapper (Optional[Callable[[str, torch.nn.Module], Rule | None]])

_stabilizer = 1e-06

_rule_mapper

_rules

_call(name, module)

Parameters:

• name (str)

• module (torch.nn.Module)

Return type:

Rule | None

__call__(name, module)

Parameters:

• name (str)

• module (torch.nn.Module)

Return type:

Rule | None

class tdhook.attribution.lrp_helpers.rules.EpsilonPlus(epsilon=1e-06, stabilizer=1e-06, rule_mapper=None)

Bases: BaseRuleMapper

Parameters:

rule_mapper (Optional[Callable[[str, torch.nn.Module], Rule | None]])

_call(name, module)

Parameters:

• name (str)

• module (torch.nn.Module)

Return type:

Rule | None

tdhook.attribution.lrp_helpers.rules.raise_for_unconserved_rel_factory(atol=1e-06, rtol=1e-06)

Parameters:

• atol (float)

• rtol (float)