captum/attr/_core/neuron/neuron_deep_lift.py [15:84]: - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - r""" Implements DeepLIFT algorithm for the neuron based on the following paper: Learning Important Features Through Propagating Activation Differences, Avanti Shrikumar, et. al. https://arxiv.org/abs/1704.02685 and the gradient formulation proposed in: Towards better understanding of gradient-based attribution methods for deep neural networks, Marco Ancona, et.al. https://openreview.net/pdf?id=Sy21R9JAW This implementation supports only Rescale rule. RevealCancel rule will be supported in later releases. Although DeepLIFT's(Rescale Rule) attribution quality is comparable with Integrated Gradients, it runs significantly faster than Integrated Gradients and is preferred for large datasets. Currently we only support a limited number of non-linear activations but the plan is to expand the list in the future. Note: As we know, currently we cannot access the building blocks, of PyTorch's built-in LSTM, RNNs and GRUs such as Tanh and Sigmoid. Nonetheless, it is possible to build custom LSTMs, RNNS and GRUs with performance similar to built-in ones using TorchScript. More details on how to build custom RNNs can be found here: https://pytorch.org/blog/optimizing-cuda-rnn-with-torchscript/ """ def __init__( self, model: Module, layer: Module, multiply_by_inputs: bool = True ) -> None: r""" Args: model (nn.Module): The reference to PyTorch model instance. Model cannot contain any in-place nonlinear submodules; these are not supported by the register_full_backward_hook PyTorch API starting from PyTorch v1.9. layer (torch.nn.Module): Layer for which neuron attributions are computed. Attributions for a particular neuron for the input or output of this layer are computed using the argument neuron_selector in the attribute method. Currently, it is assumed that the inputs or the outputs of the layer, depending on which one is used for attribution, can only be a single tensor. multiply_by_inputs (bool, optional): Indicates whether to factor model inputs' multiplier in the final attribution scores. In the literature this is also known as local vs global attribution. If inputs' multiplier isn't factored in then that type of attribution method is also called local attribution. If it is, then that type of attribution method is called global. More detailed can be found here: https://arxiv.org/abs/1711.06104 In case of Neuron DeepLift, if `multiply_by_inputs` is set to True, final sensitivity scores are being multiplied by (inputs - baselines). This flag applies only if `custom_attribution_func` is set to None. """ NeuronAttribution.__init__(self, model, layer) GradientAttribution.__init__(self, model) self._multiply_by_inputs = multiply_by_inputs @log_usage() def attribute( self, inputs: TensorOrTupleOfTensorsGeneric, neuron_selector: Union[int, Tuple[Union[int, slice], ...], Callable], - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - captum/attr/_core/neuron/neuron_deep_lift.py [266:326]: - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - r""" Extends NeuronAttribution and uses LayerDeepLiftShap algorithms and approximates SHAP values for given input `layer` and `neuron_selector`. For each input sample - baseline pair it computes DeepLift attributions with respect to inputs or outputs of given `layer` and `neuron_selector` averages resulting attributions across baselines. Whether to compute the attributions with respect to the inputs or outputs of the layer is defined by the input flag `attribute_to_layer_input`. More details about the algorithm can be found here: http://papers.nips.cc/paper/7062-a-unified-approach-to-interpreting-model-predictions.pdf Note that the explanation model: 1. Assumes that input features are independent of one another 2. Is linear, meaning that the explanations are modeled through the additive composition of feature effects. Although, it assumes a linear model for each explanation, the overall model across multiple explanations can be complex and non-linear. """ def __init__( self, model: Module, layer: Module, multiply_by_inputs: bool = True ) -> None: r""" Args: model (nn.Module): The reference to PyTorch model instance. Model cannot contain any in-place nonlinear submodules; these are not supported by the register_full_backward_hook PyTorch API starting from PyTorch v1.9. layer (torch.nn.Module): Layer for which neuron attributions are computed. Attributions for a particular neuron for the input or output of this layer are computed using the argument neuron_selector in the attribute method. Currently, only layers with a single tensor input and output are supported. multiply_by_inputs (bool, optional): Indicates whether to factor model inputs' multiplier in the final attribution scores. In the literature this is also known as local vs global attribution. If inputs' multiplier isn't factored in then that type of attribution method is also called local attribution. If it is, then that type of attribution method is called global. More detailed can be found here: https://arxiv.org/abs/1711.06104 In case of Neuron DeepLift Shap, if `multiply_by_inputs` is set to True, final sensitivity scores are being multiplied by (inputs - baselines). This flag applies only if `custom_attribution_func` is set to None. """ NeuronAttribution.__init__(self, model, layer) GradientAttribution.__init__(self, model) self._multiply_by_inputs = multiply_by_inputs @log_usage() def attribute( self, inputs: TensorOrTupleOfTensorsGeneric, neuron_selector: Union[int, Tuple[Union[int, slice], ...], Callable], - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -