def attribute( # type: ignore self, inputs: TensorOrTupleOfTensorsGeneric, baselines: BaselineType = None, target: TargetType = None, additional_forward_args: Any = None, return_convergence_delta: bool = False, ) -> Union[TensorOrTupleOfTensorsGeneric, Tuple[ TensorOrTupleOfTensorsGeneric, Tensor]]: # Keeps track whether original input is a tuple or not before # converting it into a tuple. is_inputs_tuple = _is_tuple(inputs) inputs, baselines = _format_input_baseline(inputs, baselines) rand_coefficient = torch.tensor( np.random.uniform(0.0, 1.0, inputs[0].shape[0]), device=inputs[0].device, dtype=inputs[0].dtype, ) input_baseline_scaled = tuple( _scale_input(input, baseline, rand_coefficient) for input, baseline in zip(inputs, baselines)) grads = self.gradient_func(self.forward_func, input_baseline_scaled, target, additional_forward_args) if self.multiplies_by_inputs: input_baseline_diffs = tuple( input - baseline for input, baseline in zip(inputs, baselines)) attributions = tuple(input_baseline_diff * grad for input_baseline_diff, grad in zip( input_baseline_diffs, grads)) else: attributions = grads return _compute_conv_delta_and_format_attrs( self, return_convergence_delta, attributions, baselines, inputs, additional_forward_args, target, is_inputs_tuple, )
def _lime_test_assert( self, model: Callable, test_input: TensorOrTupleOfTensorsGeneric, expected_attr, expected_coefs_only=None, feature_mask: Union[None, TensorOrTupleOfTensorsGeneric] = None, additional_input: Any = None, perturbations_per_eval: Tuple[int, ...] = (1, ), baselines: BaselineType = None, target: Union[None, int] = 0, n_perturb_samples: int = 100, alpha: float = 1.0, delta: float = 1.0, batch_attr: bool = False, ) -> None: for batch_size in perturbations_per_eval: lime = Lime( model, similarity_func=get_exp_kernel_similarity_function( "cosine", 10.0), ) attributions = lime.attribute( test_input, target=target, feature_mask=feature_mask, additional_forward_args=additional_input, baselines=baselines, perturbations_per_eval=batch_size, n_perturb_samples=n_perturb_samples, alpha=alpha, ) assertTensorTuplesAlmostEqual(self, attributions, expected_attr, delta=delta, mode="max") if expected_coefs_only is not None: # Test with return_input_shape = False attributions = lime.attribute( test_input, target=target, feature_mask=feature_mask, additional_forward_args=additional_input, baselines=baselines, perturbations_per_eval=batch_size, n_perturb_samples=n_perturb_samples, alpha=alpha, return_input_shape=False, ) assertTensorAlmostEqual(self, attributions, expected_coefs_only, delta=delta, mode="max") lime_alt = LimeBase( model, lasso_interpretable_model_trainer, get_exp_kernel_similarity_function("euclidean", 1000.0), alt_perturb_func, False, None, alt_to_interp_rep, ) # Test with equivalent sampling in original input space formatted_inputs, baselines = _format_input_baseline( test_input, baselines) if feature_mask is None: ( formatted_feature_mask, num_interp_features, ) = _construct_default_feature_mask(formatted_inputs) else: formatted_feature_mask = _format_input(feature_mask) num_interp_features = int( max( torch.max(single_inp).item() for single_inp in feature_mask) + 1) if batch_attr: attributions = lime_alt.attribute( test_input, target=target, feature_mask=formatted_feature_mask if isinstance( test_input, tuple) else formatted_feature_mask[0], additional_forward_args=additional_input, baselines=baselines, perturbations_per_eval=batch_size, n_perturb_samples=n_perturb_samples, alpha=alpha, num_interp_features=num_interp_features, ) assertTensorAlmostEqual(self, attributions, expected_coefs_only, delta=delta, mode="max") return bsz = formatted_inputs[0].shape[0] for ( curr_inps, curr_target, curr_additional_args, curr_baselines, curr_feature_mask, expected_coef_single, ) in _batch_example_iterator( bsz, test_input, target, additional_input, baselines if isinstance(test_input, tuple) else baselines[0], formatted_feature_mask if isinstance( test_input, tuple) else formatted_feature_mask[0], expected_coefs_only, ): attributions = lime_alt.attribute( curr_inps, target=curr_target, feature_mask=curr_feature_mask, additional_forward_args=curr_additional_args, baselines=curr_baselines, perturbations_per_eval=batch_size, n_perturb_samples=n_perturb_samples, alpha=alpha, num_interp_features=num_interp_features, ) assertTensorAlmostEqual( self, attributions, expected_coef_single, delta=delta, mode="max", )
def attribute( # type: ignore self, inputs: TensorOrTupleOfTensorsGeneric, baselines: BaselineType = None, target: TargetType = None, additional_forward_args: Any = None, feature_mask: Union[None, Tensor, Tuple[Tensor, ...]] = None, n_samples: int = 25, perturbations_per_eval: int = 1, return_input_shape: bool = True, ) -> TensorOrTupleOfTensorsGeneric: r""" This method attributes the output of the model with given target index (in case it is provided, otherwise it assumes that output is a scalar) to the inputs of the model using the approach described above, training an interpretable model based on KernelSHAP and returning a representation of the interpretable model. It is recommended to only provide a single example as input (tensors with first dimension or batch size = 1). This is because LIME / KernelShap is generally used for sample-based interpretability, training a separate interpretable model to explain a model's prediction on each individual example. A batch of inputs can also be provided as inputs, similar to other perturbation-based attribution methods. In this case, if forward_fn returns a scalar per example, attributions will be computed for each example independently, with a separate interpretable model trained for each example. Note that provided similarity and perturbation functions will be provided each example separately (first dimension = 1) in this case. If forward_fn returns a scalar per batch (e.g. loss), attributions will still be computed using a single interpretable model for the full batch. In this case, similarity and perturbation functions will be provided the same original input containing the full batch. The number of interpretable features is determined from the provided feature mask, or if none is provided, from the default feature mask, which considers each scalar input as a separate feature. It is generally recommended to provide a feature mask which groups features into a small number of interpretable features / components (e.g. superpixels in images). Args: inputs (tensor or tuple of tensors): Input for which KernelShap is computed. If forward_func takes a single tensor as input, a single input tensor should be provided. If forward_func takes multiple tensors as input, a tuple of the input tensors should be provided. It is assumed that for all given input tensors, dimension 0 corresponds to the number of examples, and if multiple input tensors are provided, the examples must be aligned appropriately. baselines (scalar, tensor, tuple of scalars or tensors, optional): Baselines define the reference value which replaces each feature when the corresponding interpretable feature is set to 0. Baselines can be provided as: - a single tensor, if inputs is a single tensor, with exactly the same dimensions as inputs or the first dimension is one and the remaining dimensions match with inputs. - a single scalar, if inputs is a single tensor, which will be broadcasted for each input value in input tensor. - a tuple of tensors or scalars, the baseline corresponding to each tensor in the inputs' tuple can be: - either a tensor with matching dimensions to corresponding tensor in the inputs' tuple or the first dimension is one and the remaining dimensions match with the corresponding input tensor. - or a scalar, corresponding to a tensor in the inputs' tuple. This scalar value is broadcasted for corresponding input tensor. In the cases when `baselines` is not provided, we internally use zero scalar corresponding to each input tensor. Default: None target (int, tuple, tensor or list, optional): Output indices for which surrogate model is trained (for classification cases, this is usually the target class). If the network returns a scalar value per example, no target index is necessary. For general 2D outputs, targets can be either: - a single integer or a tensor containing a single integer, which is applied to all input examples - a list of integers or a 1D tensor, with length matching the number of examples in inputs (dim 0). Each integer is applied as the target for the corresponding example. For outputs with > 2 dimensions, targets can be either: - A single tuple, which contains #output_dims - 1 elements. This target index is applied to all examples. - A list of tuples with length equal to the number of examples in inputs (dim 0), and each tuple containing #output_dims - 1 elements. Each tuple is applied as the target for the corresponding example. Default: None additional_forward_args (any, optional): If the forward function requires additional arguments other than the inputs for which attributions should not be computed, this argument can be provided. It must be either a single additional argument of a Tensor or arbitrary (non-tuple) type or a tuple containing multiple additional arguments including tensors or any arbitrary python types. These arguments are provided to forward_func in order following the arguments in inputs. For a tensor, the first dimension of the tensor must correspond to the number of examples. It will be repeated for each of `n_steps` along the integrated path. For all other types, the given argument is used for all forward evaluations. Note that attributions are not computed with respect to these arguments. Default: None feature_mask (tensor or tuple of tensors, optional): feature_mask defines a mask for the input, grouping features which correspond to the same interpretable feature. feature_mask should contain the same number of tensors as inputs. Each tensor should be the same size as the corresponding input or broadcastable to match the input tensor. Values across all tensors should be integers in the range 0 to num_interp_features - 1, and indices corresponding to the same feature should have the same value. Note that features are grouped across tensors (unlike feature ablation and occlusion), so if the same index is used in different tensors, those features are still grouped and added simultaneously. If None, then a feature mask is constructed which assigns each scalar within a tensor as a separate feature. Default: None n_samples (int, optional): The number of samples of the original model used to train the surrogate interpretable model. Default: `50` if `n_samples` is not provided. perturbations_per_eval (int, optional): Allows multiple samples to be processed simultaneously in one call to forward_fn. Each forward pass will contain a maximum of perturbations_per_eval * #examples samples. For DataParallel models, each batch is split among the available devices, so evaluations on each available device contain at most (perturbations_per_eval * #examples) / num_devices samples. If the forward function returns a single scalar per batch, perturbations_per_eval must be set to 1. Default: 1 return_input_shape (bool, optional): Determines whether the returned tensor(s) only contain the coefficients for each interp- retable feature from the trained surrogate model, or whether the returned attributions match the input shape. When return_input_shape is True, the return type of attribute matches the input shape, with each element containing the coefficient of the corresponding interpretable feature. All elements with the same value in the feature mask will contain the same coefficient in the returned attributions. If return_input_shape is False, a 1D tensor is returned, containing only the coefficients of the trained interpretable model, with length num_interp_features. Returns: *tensor* or tuple of *tensors* of **attributions**: - **attributions** (*tensor* or tuple of *tensors*): The attributions with respect to each input feature. If return_input_shape = True, attributions will be the same size as the provided inputs, with each value providing the coefficient of the corresponding interpretale feature. If return_input_shape is False, a 1D tensor is returned, containing only the coefficients of the trained interpreatable models, with length num_interp_features. Examples:: >>> # SimpleClassifier takes a single input tensor of size Nx4x4, >>> # and returns an Nx3 tensor of class probabilities. >>> net = SimpleClassifier() >>> # Generating random input with size 1 x 4 x 4 >>> input = torch.randn(1, 4, 4) >>> # Defining KernelShap interpreter >>> ks = KernelShap(net) >>> # Computes attribution, with each of the 4 x 4 = 16 >>> # features as a separate interpretable feature >>> attr = ks.attribute(input, target=1, n_samples=200) >>> # Alternatively, we can group each 2x2 square of the inputs >>> # as one 'interpretable' feature and perturb them together. >>> # This can be done by creating a feature mask as follows, which >>> # defines the feature groups, e.g.: >>> # +---+---+---+---+ >>> # | 0 | 0 | 1 | 1 | >>> # +---+---+---+---+ >>> # | 0 | 0 | 1 | 1 | >>> # +---+---+---+---+ >>> # | 2 | 2 | 3 | 3 | >>> # +---+---+---+---+ >>> # | 2 | 2 | 3 | 3 | >>> # +---+---+---+---+ >>> # With this mask, all inputs with the same value are set to their >>> # baseline value, when the corresponding binary interpretable >>> # feature is set to 0. >>> # The attributions can be calculated as follows: >>> # feature mask has dimensions 1 x 4 x 4 >>> feature_mask = torch.tensor([[[0,0,1,1],[0,0,1,1], >>> [2,2,3,3],[2,2,3,3]]]) >>> # Computes KernelSHAP attributions with feature mask. >>> attr = ks.attribute(input, target=1, feature_mask=feature_mask) """ formatted_inputs, baselines = _format_input_baseline(inputs, baselines) feature_mask, num_interp_features = construct_feature_mask( feature_mask, formatted_inputs) num_features_list = torch.arange(num_interp_features, dtype=torch.float) denom = num_features_list * (num_interp_features - num_features_list) probs = (num_interp_features - 1) / denom probs[0] = 0.0 return self._attribute_kwargs( inputs=inputs, baselines=baselines, target=target, additional_forward_args=additional_forward_args, feature_mask=feature_mask, n_samples=n_samples, perturbations_per_eval=perturbations_per_eval, return_input_shape=return_input_shape, num_select_distribution=Categorical(probs), )
def attribute( self, inputs: Union[Tensor, Tuple[Tensor, ...]], baselines: Optional[ Union[Tensor, int, float, Tuple[Union[Tensor, int, float], ...]] ] = None, target: Optional[ Union[int, Tuple[int, ...], Tensor, List[Tuple[int, ...]]] ] = None, additional_forward_args: Any = None, n_steps: int = 50, method: str = "gausslegendre", internal_batch_size: Optional[int] = None, return_convergence_delta: bool = False, attribute_to_layer_input: bool = False, ) -> Union[ Tensor, Tuple[Tensor, ...], Tuple[Union[Tensor, Tuple[Tensor, ...]], Tensor] ]: r""" This method attributes the output of the model with given target index (in case it is provided, otherwise it assumes that output is a scalar) to layer inputs or outputs of the model, depending on whether `attribute_to_layer_input` is set to True or False, using the approach described above. In addition to that it also returns, if `return_convergence_delta` is set to True, integral approximation delta based on the completeness property of integrated gradients. Args: inputs (tensor or tuple of tensors): Input for which layer integrated gradients are computed. If forward_func takes a single tensor as input, a single input tensor should be provided. If forward_func takes multiple tensors as input, a tuple of the input tensors should be provided. It is assumed that for all given input tensors, dimension 0 corresponds to the number of examples, and if multiple input tensors are provided, the examples must be aligned appropriately. baselines (scalar, tensor, tuple of scalars or tensors, optional): Baselines define the starting point from which integral is computed and can be provided as: - a single tensor, if inputs is a single tensor, with exactly the same dimensions as inputs or the first dimension is one and the remaining dimensions match with inputs. - a single scalar, if inputs is a single tensor, which will be broadcasted for each input value in input tensor. - a tuple of tensors or scalars, the baseline corresponding to each tensor in the inputs' tuple can be: - either a tensor with matching dimensions to corresponding tensor in the inputs' tuple or the first dimension is one and the remaining dimensions match with the corresponding input tensor. - or a scalar, corresponding to a tensor in the inputs' tuple. This scalar value is broadcasted for corresponding input tensor. In the cases when `baselines` is not provided, we internally use zero scalar corresponding to each input tensor. Default: None target (int, tuple, tensor or list, optional): Output indices for which gradients are computed (for classification cases, this is usually the target class). If the network returns a scalar value per example, no target index is necessary. For general 2D outputs, targets can be either: - a single integer or a tensor containing a single integer, which is applied to all input examples - a list of integers or a 1D tensor, with length matching the number of examples in inputs (dim 0). Each integer is applied as the target for the corresponding example. For outputs with > 2 dimensions, targets can be either: - A single tuple, which contains #output_dims - 1 elements. This target index is applied to all examples. - A list of tuples with length equal to the number of examples in inputs (dim 0), and each tuple containing #output_dims - 1 elements. Each tuple is applied as the target for the corresponding example. Default: None additional_forward_args (any, optional): If the forward function requires additional arguments other than the inputs for which attributions should not be computed, this argument can be provided. It must be either a single additional argument of a Tensor or arbitrary (non-tuple) type or a tuple containing multiple additional arguments including tensors or any arbitrary python types. These arguments are provided to forward_func in order following the arguments in inputs. For a tensor, the first dimension of the tensor must correspond to the number of examples. It will be repeated for each of `n_steps` along the integrated path. For all other types, the given argument is used for all forward evaluations. Note that attributions are not computed with respect to these arguments. Default: None n_steps (int, optional): The number of steps used by the approximation method. Default: 50. method (string, optional): Method for approximating the integral, one of `riemann_right`, `riemann_left`, `riemann_middle`, `riemann_trapezoid` or `gausslegendre`. Default: `gausslegendre` if no method is provided. internal_batch_size (int, optional): Divides total #steps * #examples data points into chunks of size internal_batch_size, which are computed (forward / backward passes) sequentially. For DataParallel models, each batch is split among the available devices, so evaluations on each available device contain internal_batch_size / num_devices examples. If internal_batch_size is None, then all evaluations are processed in one batch. Default: None return_convergence_delta (bool, optional): Indicates whether to return convergence delta or not. If `return_convergence_delta` is set to True convergence delta will be returned in a tuple following attributions. Default: False attribute_to_layer_input (bool, optional): Indicates whether to compute the attribution with respect to the layer input or output. If `attribute_to_layer_input` is set to True then the attributions will be computed with respect to layer input, otherwise it will be computed with respect to layer output. Note that currently it is assumed that either the input or the output of internal layer, depending on whether we attribute to the input or output, is a single tensor. Support for multiple tensors will be added later. Default: False Returns: **attributions** or 2-element tuple of **attributions**, **delta**: - **attributions** (*tensor* or tuple of *tensors*): Integrated gradients with respect to `layer`'s inputs or outputs. Attributions will always be the same size and dimensionality as the input or output of the given layer, depending on whether we attribute to the inputs or outputs of the layer which is decided by the input flag `attribute_to_layer_input`. - **delta** (*tensor*, returned if return_convergence_delta=True): The difference between the total approximated and true integrated gradients. This is computed using the property that the total sum of forward_func(inputs) - forward_func(baselines) must equal the total sum of the integrated gradient. Delta is calculated per example, meaning that the number of elements in returned delta tensor is equal to the number of of examples in inputs. Examples:: >>> # ImageClassifier takes a single input tensor of images Nx3x32x32, >>> # and returns an Nx10 tensor of class probabilities. >>> # It contains an attribute conv1, which is an instance of nn.conv2d, >>> # and the output of this layer has dimensions Nx12x32x32. >>> net = ImageClassifier() >>> lig = LayerIntegratedGradients(net, net.conv1) >>> input = torch.randn(2, 3, 32, 32, requires_grad=True) >>> # Computes layer integrated gradients for class 3. >>> # attribution size matches layer output, Nx12x32x32 >>> attribution = lig.attribute(input, target=3) """ inps, baselines = _format_input_baseline(inputs, baselines) _validate_input(inps, baselines, n_steps, method) baselines = _tensorize_baseline(inps, baselines) additional_forward_args = _format_additional_forward_args( additional_forward_args ) if self.device_ids is None: self.device_ids = getattr(self.forward_func, "device_ids", None) inputs_layer, is_layer_tuple = _forward_layer_eval( self.forward_func, inps, self.layer, device_ids=self.device_ids, additional_forward_args=additional_forward_args, attribute_to_layer_input=attribute_to_layer_input, ) baselines_layer, _ = _forward_layer_eval( self.forward_func, baselines, self.layer, device_ids=self.device_ids, additional_forward_args=additional_forward_args, attribute_to_layer_input=attribute_to_layer_input, ) # inputs -> these inputs are scaled def gradient_func( forward_fn: Callable, inputs: Union[Tensor, Tuple[Tensor, ...]], target_ind: Optional[ Union[int, Tuple[int, ...], Tensor, List[Tuple[int, ...]]] ] = None, additional_forward_args: Any = None, ) -> Tuple[Tensor, ...]: if self.device_ids is None: scattered_inputs = (inputs,) else: # scatter method does not have a precise enough return type in its # stub, so suppress the type warning. scattered_inputs = scatter( # type:ignore inputs, target_gpus=self.device_ids ) scattered_inputs_dict = { scattered_input[0].device: scattered_input for scattered_input in scattered_inputs } with torch.autograd.set_grad_enabled(True): def layer_forward_hook(module, hook_inputs, hook_outputs=None): device = _extract_device(module, hook_inputs, hook_outputs) if is_layer_tuple: return scattered_inputs_dict[device] return scattered_inputs_dict[device][0] if attribute_to_layer_input: hook = self.layer.register_forward_pre_hook(layer_forward_hook) else: hook = self.layer.register_forward_hook(layer_forward_hook) output = _run_forward( self.forward_func, additional_forward_args, target_ind, ) hook.remove() assert output[0].numel() == 1, ( "Target not provided when necessary, cannot" " take gradient with respect to multiple outputs." ) # torch.unbind(forward_out) is a list of scalar tensor tuples and # contains batch_size * #steps elements grads = torch.autograd.grad(torch.unbind(output), inputs) return grads self.ig.gradient_func = gradient_func all_inputs = ( (inps + additional_forward_args) if additional_forward_args is not None else inps ) attributions = self.ig.attribute( inputs_layer, baselines=baselines_layer, target=target, additional_forward_args=all_inputs, n_steps=n_steps, method=method, internal_batch_size=internal_batch_size, return_convergence_delta=False, ) if return_convergence_delta: start_point, end_point = baselines, inps # computes approximation error based on the completeness axiom delta = self.compute_convergence_delta( attributions, start_point, end_point, additional_forward_args=additional_forward_args, target=target, ) return _format_attributions(is_layer_tuple, attributions), delta return _format_attributions(is_layer_tuple, attributions)
def attribute( # type: ignore self, inputs: Union[Tensor, Tuple[Tensor, ...]], baselines: Union[Tensor, Tuple[Tensor, ...]], target: TargetType = None, additional_forward_args: Any = None, return_convergence_delta: bool = False, attribute_to_layer_input: bool = False, ) -> Union[Tensor, Tuple[Tensor, ...], Tuple[Union[Tensor, Tuple[ Tensor, ...]], Tensor]]: inputs, baselines = _format_input_baseline(inputs, baselines) rand_coefficient = torch.tensor( np.random.uniform(0.0, 1.0, inputs[0].shape[0]), device=inputs[0].device, dtype=inputs[0].dtype, ) input_baseline_scaled = tuple( _scale_input(input, baseline, rand_coefficient) for input, baseline in zip(inputs, baselines)) grads, _ = compute_layer_gradients_and_eval( self.forward_func, self.layer, input_baseline_scaled, target, additional_forward_args, device_ids=self.device_ids, attribute_to_layer_input=attribute_to_layer_input, ) attr_baselines = _forward_layer_eval( self.forward_func, baselines, self.layer, additional_forward_args=additional_forward_args, device_ids=self.device_ids, attribute_to_layer_input=attribute_to_layer_input, ) attr_inputs = _forward_layer_eval( self.forward_func, inputs, self.layer, additional_forward_args=additional_forward_args, device_ids=self.device_ids, attribute_to_layer_input=attribute_to_layer_input, ) if self.multiplies_by_inputs: input_baseline_diffs = tuple( input - baseline for input, baseline in zip(attr_inputs, attr_baselines)) attributions = tuple(input_baseline_diff * grad for input_baseline_diff, grad in zip( input_baseline_diffs, grads)) else: attributions = grads return _compute_conv_delta_and_format_attrs( self, return_convergence_delta, attributions, baselines, inputs, additional_forward_args, target, cast(Union[Literal[True], Literal[False]], len(attributions) > 1), )
def attribute( self, inputs: TensorOrTupleOfTensorsGeneric, neuron_selector: Union[int, Tuple[int, ...], Callable], baselines: BaselineType = None, target: TargetType = None, additional_forward_args: Any = None, n_steps: int = 50, method: str = "riemann_trapezoid", internal_batch_size: Union[None, int] = None, attribute_to_neuron_input: bool = False, ) -> TensorOrTupleOfTensorsGeneric: r""" Args: inputs (tensor or tuple of tensors): Input for which neuron conductance is computed. If forward_func takes a single tensor as input, a single input tensor should be provided. If forward_func takes multiple tensors as input, a tuple of the input tensors should be provided. It is assumed that for all given input tensors, dimension 0 corresponds to the number of examples, and if multiple input tensors are provided, the examples must be aligned appropriately. neuron_selector (int, callable, or tuple of ints or slices): Selector for neuron in given layer for which attribution is desired. Neuron selector can be provided as: - a single integer, if the layer output is 2D. This integer selects the appropriate neuron column in the layer input or output - a tuple of integers. Length of this tuple must be one less than the number of dimensions in the input / output of the given layer (since dimension 0 corresponds to number of examples). This can be used as long as the layer input / output is a single tensor. - a callable, which should take the target layer as input (single tensor or tuple if multiple tensors are in layer) and return a selected neuron - output shape should be 1D with length equal to batch_size (one scalar per input example) NOTE: Callables applicable for neuron conductance are less general than those of other methods and should NOT aggregate values of the layer, only return a specific output. This option should only be used in cases where the layer input / output is a tuple of tensors, where the other options would not suffice. This limitation is necessary since neuron conductance, unlike other neuron methods, also utilizes the gradient of output with respect to the intermedite neuron, which cannot be computed for aggregations of multiple intemediate neurons. baselines (scalar, tensor, tuple of scalars or tensors, optional): Baselines define the starting point from which integral is computed and can be provided as: - a single tensor, if inputs is a single tensor, with exactly the same dimensions as inputs or the first dimension is one and the remaining dimensions match with inputs. - a single scalar, if inputs is a single tensor, which will be broadcasted for each input value in input tensor. - a tuple of tensors or scalars, the baseline corresponding to each tensor in the inputs' tuple can be: - either a tensor with matching dimensions to corresponding tensor in the inputs' tuple or the first dimension is one and the remaining dimensions match with the corresponding input tensor. - or a scalar, corresponding to a tensor in the inputs' tuple. This scalar value is broadcasted for corresponding input tensor. In the cases when `baselines` is not provided, we internally use zero scalar corresponding to each input tensor. Default: None target (int, tuple, tensor or list, optional): Output indices for which gradients are computed (for classification cases, this is usually the target class). If the network returns a scalar value per example, no target index is necessary. For general 2D outputs, targets can be either: - a single integer or a tensor containing a single integer, which is applied to all input examples - a list of integers or a 1D tensor, with length matching the number of examples in inputs (dim 0). Each integer is applied as the target for the corresponding example. For outputs with > 2 dimensions, targets can be either: - A single tuple, which contains #output_dims - 1 elements. This target index is applied to all examples. - A list of tuples with length equal to the number of examples in inputs (dim 0), and each tuple containing #output_dims - 1 elements. Each tuple is applied as the target for the corresponding example. Default: None additional_forward_args (any, optional): If the forward function requires additional arguments other than the inputs for which attributions should not be computed, this argument can be provided. It must be either a single additional argument of a Tensor or arbitrary (non-tuple) type or a tuple containing multiple additional arguments including tensors or any arbitrary python types. These arguments are provided to forward_func in order following the arguments in inputs. For a tensor, the first dimension of the tensor must correspond to the number of examples. It will be repeated for each of `n_steps` along the integrated path. For all other types, the given argument is used for all forward evaluations. Note that attributions are not computed with respect to these arguments. Default: None n_steps (int, optional): The number of steps used by the approximation method. Default: 50. method (string, optional): Method for approximating the integral, one of `riemann_right`, `riemann_left`, `riemann_middle`, `riemann_trapezoid` or `gausslegendre`. Default: `gausslegendre` if no method is provided. internal_batch_size (int, optional): Divides total #steps * #examples data points into chunks of size at most internal_batch_size, which are computed (forward / backward passes) sequentially. internal_batch_size must be at least equal to #examples. For DataParallel models, each batch is split among the available devices, so evaluations on each available device contain internal_batch_size / num_devices examples. If internal_batch_size is None, then all evaluations are processed in one batch. Default: None attribute_to_neuron_input (bool, optional): Indicates whether to compute the attributions with respect to the neuron input or output. If `attribute_to_neuron_input` is set to True then the attributions will be computed with respect to neuron's inputs, otherwise it will be computed with respect to neuron's outputs. Note that currently it is assumed that either the input or the output of internal neuron, depending on whether we attribute to the input or output, is a single tensor. Support for multiple tensors will be added later. Default: False Returns: *tensor* or tuple of *tensors* of **attributions**: - **attributions** (*tensor* or tuple of *tensors*): Conductance for particular neuron with respect to each input feature. Attributions will always be the same size as the provided inputs, with each value providing the attribution of the corresponding input index. If a single tensor is provided as inputs, a single tensor is returned. If a tuple is provided for inputs, a tuple of corresponding sized tensors is returned. Examples:: >>> # ImageClassifier takes a single input tensor of images Nx3x32x32, >>> # and returns an Nx10 tensor of class probabilities. >>> # It contains an attribute conv1, which is an instance of nn.conv2d, >>> # and the output of this layer has dimensions Nx12x32x32. >>> net = ImageClassifier() >>> neuron_cond = NeuronConductance(net, net.conv1) >>> input = torch.randn(2, 3, 32, 32, requires_grad=True) >>> # To compute neuron attribution, we need to provide the neuron >>> # index for which attribution is desired. Since the layer output >>> # is Nx12x32x32, we need a tuple in the form (0..11,0..31,0..31) >>> # which indexes a particular neuron in the layer output. >>> # Computes neuron conductance for neuron with >>> # index (4,1,2). >>> attribution = neuron_cond.attribute(input, (4,1,2)) """ if callable(neuron_selector): warnings.warn( "The neuron_selector provided is a callable. Please ensure that this" " function only selects neurons from the given layer; aggregating" " or performing other operations on the tensor may lead to inaccurate" " results.") is_inputs_tuple = _is_tuple(inputs) inputs, baselines = _format_input_baseline(inputs, baselines) _validate_input(inputs, baselines, n_steps, method) num_examples = inputs[0].shape[0] if internal_batch_size is not None: num_examples = inputs[0].shape[0] attrs = _batch_attribution( self, num_examples, internal_batch_size, n_steps, inputs=inputs, baselines=baselines, neuron_selector=neuron_selector, target=target, additional_forward_args=additional_forward_args, method=method, attribute_to_neuron_input=attribute_to_neuron_input, ) else: attrs = self._attribute( inputs=inputs, neuron_selector=neuron_selector, baselines=baselines, target=target, additional_forward_args=additional_forward_args, n_steps=n_steps, method=method, attribute_to_neuron_input=attribute_to_neuron_input, ) return _format_output(is_inputs_tuple, attrs)
def attribute( self, inputs: Union[Tensor, Tuple[Tensor, ...]], baselines: BaselineType = None, target: TargetType = None, additional_forward_args: Any = None, n_steps: int = 50, method: str = "gausslegendre", internal_batch_size: Union[None, int] = None, attribute_to_layer_input: bool = False, ) -> Union[Tensor, Tuple[Tensor, ...]]: r""" Args: inputs (tensor or tuple of tensors): Input for which internal influence is computed. If forward_func takes a single tensor as input, a single input tensor should be provided. If forward_func takes multiple tensors as input, a tuple of the input tensors should be provided. It is assumed that for all given input tensors, dimension 0 corresponds to the number of examples, and if multiple input tensors are provided, the examples must be aligned appropriately. baselines scalar, tensor, tuple of scalars or tensors, optional): Baselines define a starting point from which integral is computed and can be provided as: - a single tensor, if inputs is a single tensor, with exactly the same dimensions as inputs or the first dimension is one and the remaining dimensions match with inputs. - a single scalar, if inputs is a single tensor, which will be broadcasted for each input value in input tensor. - a tuple of tensors or scalars, the baseline corresponding to each tensor in the inputs' tuple can be: - either a tensor with matching dimensions to corresponding tensor in the inputs' tuple or the first dimension is one and the remaining dimensions match with the corresponding input tensor. - or a scalar, corresponding to a tensor in the inputs' tuple. This scalar value is broadcasted for corresponding input tensor. In the cases when `baselines` is not provided, we internally use zero scalar corresponding to each input tensor. Default: None target (int, tuple, tensor or list, optional): Output indices for which gradients are computed (for classification cases, this is usually the target class). If the network returns a scalar value per example, no target index is necessary. For general 2D outputs, targets can be either: - a single integer or a tensor containing a single integer, which is applied to all input examples - a list of integers or a 1D tensor, with length matching the number of examples in inputs (dim 0). Each integer is applied as the target for the corresponding example. For outputs with > 2 dimensions, targets can be either: - A single tuple, which contains #output_dims - 1 elements. This target index is applied to all examples. - A list of tuples with length equal to the number of examples in inputs (dim 0), and each tuple containing #output_dims - 1 elements. Each tuple is applied as the target for the corresponding example. Default: None additional_forward_args (any, optional): If the forward function requires additional arguments other than the inputs for which attributions should not be computed, this argument can be provided. It must be either a single additional argument of a Tensor or arbitrary (non-tuple) type or a tuple containing multiple additional arguments including tensors or any arbitrary python types. These arguments are provided to forward_func in order following the arguments in inputs. For a tensor, the first dimension of the tensor must correspond to the number of examples. It will be repeated for each of `n_steps` along the integrated path. For all other types, the given argument is used for all forward evaluations. Note that attributions are not computed with respect to these arguments. Default: None n_steps (int, optional): The number of steps used by the approximation method. Default: 50. method (string, optional): Method for approximating the integral, one of `riemann_right`, `riemann_left`, `riemann_middle`, `riemann_trapezoid` or `gausslegendre`. Default: `gausslegendre` if no method is provided. internal_batch_size (int, optional): Divides total #steps * #examples data points into chunks of size at most internal_batch_size, which are computed (forward / backward passes) sequentially. internal_batch_size must be at least equal to #examples. For DataParallel models, each batch is split among the available devices, so evaluations on each available device contain internal_batch_size / num_devices examples. If internal_batch_size is None, then all evaluations are processed in one batch. Default: None attribute_to_layer_input (bool, optional): Indicates whether to compute the attribution with respect to the layer input or output. If `attribute_to_layer_input` is set to True then the attributions will be computed with respect to layer inputs, otherwise it will be computed with respect to layer outputs. Note that currently it is assumed that either the input or the output of internal layer, depending on whether we attribute to the input or output, is a single tensor. Support for multiple tensors will be added later. Default: False Returns: *tensor* or tuple of *tensors* of **attributions**: - **attributions** (*tensor* or tuple of *tensors*): Internal influence of each neuron in given layer output. Attributions will always be the same size as the output or input of the given layer depending on whether `attribute_to_layer_input` is set to `False` or `True`respectively. Attributions are returned in a tuple if the layer inputs / outputs contain multiple tensors, otherwise a single tensor is returned. Examples:: >>> # ImageClassifier takes a single input tensor of images Nx3x32x32, >>> # and returns an Nx10 tensor of class probabilities. >>> # It contains an attribute conv1, which is an instance of nn.conv2d, >>> # and the output of this layer has dimensions Nx12x32x32. >>> net = ImageClassifier() >>> layer_int_inf = InternalInfluence(net, net.conv1) >>> input = torch.randn(2, 3, 32, 32, requires_grad=True) >>> # Computes layer internal influence. >>> # attribution size matches layer output, Nx12x32x32 >>> attribution = layer_int_inf.attribute(input) """ inputs, baselines = _format_input_baseline(inputs, baselines) _validate_input(inputs, baselines, n_steps, method) if internal_batch_size is not None: num_examples = inputs[0].shape[0] attrs = _batch_attribution( self, num_examples, internal_batch_size, n_steps, inputs=inputs, baselines=baselines, target=target, additional_forward_args=additional_forward_args, method=method, attribute_to_layer_input=attribute_to_layer_input, ) else: attrs = self._attribute( inputs=inputs, baselines=baselines, target=target, additional_forward_args=additional_forward_args, n_steps=n_steps, method=method, attribute_to_layer_input=attribute_to_layer_input, ) return attrs
def attribute( self, inputs: TensorOrTupleOfTensorsGeneric, baselines: BaselineType = None, target: TargetType = None, additional_forward_args: Any = None, feature_mask: Union[None, Tensor, Tuple[Tensor, ...]] = None, perturbations_per_eval: int = 1, **kwargs: Any ) -> TensorOrTupleOfTensorsGeneric: r""" Args: inputs (tensor or tuple of tensors): Input for which ablation attributions are computed. If forward_func takes a single tensor as input, a single input tensor should be provided. If forward_func takes multiple tensors as input, a tuple of the input tensors should be provided. It is assumed that for all given input tensors, dimension 0 corresponds to the number of examples (aka batch size), and if multiple input tensors are provided, the examples must be aligned appropriately. baselines (scalar, tensor, tuple of scalars or tensors, optional): Baselines define reference value which replaces each feature when ablated. Baselines can be provided as: - a single tensor, if inputs is a single tensor, with exactly the same dimensions as inputs or broadcastable to match the dimensions of inputs - a single scalar, if inputs is a single tensor, which will be broadcasted for each input value in input tensor. - a tuple of tensors or scalars, the baseline corresponding to each tensor in the inputs' tuple can be: - either a tensor with matching dimensions to corresponding tensor in the inputs' tuple or the first dimension is one and the remaining dimensions match with the corresponding input tensor. - or a scalar, corresponding to a tensor in the inputs' tuple. This scalar value is broadcasted for corresponding input tensor. In the cases when `baselines` is not provided, we internally use zero scalar corresponding to each input tensor. Default: None target (int, tuple, tensor or list, optional): Output indices for which gradients are computed (for classification cases, this is usually the target class). If the network returns a scalar value per example, no target index is necessary. For general 2D outputs, targets can be either: - a single integer or a tensor containing a single integer, which is applied to all input examples - a list of integers or a 1D tensor, with length matching the number of examples in inputs (dim 0). Each integer is applied as the target for the corresponding example. For outputs with > 2 dimensions, targets can be either: - A single tuple, which contains #output_dims - 1 elements. This target index is applied to all examples. - A list of tuples with length equal to the number of examples in inputs (dim 0), and each tuple containing #output_dims - 1 elements. Each tuple is applied as the target for the corresponding example. Default: None additional_forward_args (any, optional): If the forward function requires additional arguments other than the inputs for which attributions should not be computed, this argument can be provided. It must be either a single additional argument of a Tensor or arbitrary (non-tuple) type or a tuple containing multiple additional arguments including tensors or any arbitrary python types. These arguments are provided to forward_func in order following the arguments in inputs. For a tensor, the first dimension of the tensor must correspond to the number of examples. For all other types, the given argument is used for all forward evaluations. Note that attributions are not computed with respect to these arguments. Default: None feature_mask (tensor or tuple of tensors, optional): feature_mask defines a mask for the input, grouping features which should be ablated together. feature_mask should contain the same number of tensors as inputs. Each tensor should be the same size as the corresponding input or broadcastable to match the input tensor. Each tensor should contain integers in the range 0 to num_features - 1, and indices corresponding to the same feature should have the same value. Note that features within each input tensor are ablated independently (not across tensors). If the forward function returns a single scalar per batch, we enforce that the first dimension of each mask must be 1, since attributions are returned batch-wise rather than per example, so the attributions must correspond to the same features (indices) in each input example. If None, then a feature mask is constructed which assigns each scalar within a tensor as a separate feature, which is ablated independently. Default: None perturbations_per_eval (int, optional): Allows ablation of multiple features to be processed simultaneously in one call to forward_fn. Each forward pass will contain a maximum of perturbations_per_eval * #examples samples. For DataParallel models, each batch is split among the available devices, so evaluations on each available device contain at most (perturbations_per_eval * #examples) / num_devices samples. If the forward function's number of outputs does not change as the batch size grows (e.g. if it outputs a scalar value), you must set perturbations_per_eval to 1 and use a single feature mask to describe the features for all examples in the batch. Default: 1 **kwargs (Any, optional): Any additional arguments used by child classes of FeatureAblation (such as Occlusion) to construct ablations. These arguments are ignored when using FeatureAblation directly. Default: None Returns: *tensor* or tuple of *tensors* of **attributions**: - **attributions** (*tensor* or tuple of *tensors*): The attributions with respect to each input feature. If the forward function returns a scalar value per example, attributions will be the same size as the provided inputs, with each value providing the attribution of the corresponding input index. If the forward function returns a scalar per batch, then attribution tensor(s) will have first dimension 1 and the remaining dimensions will match the input. If a single tensor is provided as inputs, a single tensor is returned. If a tuple of tensors is provided for inputs, a tuple of corresponding sized tensors is returned. Examples:: >>> # SimpleClassifier takes a single input tensor of size Nx4x4, >>> # and returns an Nx3 tensor of class probabilities. >>> net = SimpleClassifier() >>> # Generating random input with size 2 x 4 x 4 >>> input = torch.randn(2, 4, 4) >>> # Defining FeatureAblation interpreter >>> ablator = FeatureAblation(net) >>> # Computes ablation attribution, ablating each of the 16 >>> # scalar input independently. >>> attr = ablator.attribute(input, target=1) >>> # Alternatively, we may want to ablate features in groups, e.g. >>> # grouping each 2x2 square of the inputs and ablating them together. >>> # This can be done by creating a feature mask as follows, which >>> # defines the feature groups, e.g.: >>> # +---+---+---+---+ >>> # | 0 | 0 | 1 | 1 | >>> # +---+---+---+---+ >>> # | 0 | 0 | 1 | 1 | >>> # +---+---+---+---+ >>> # | 2 | 2 | 3 | 3 | >>> # +---+---+---+---+ >>> # | 2 | 2 | 3 | 3 | >>> # +---+---+---+---+ >>> # With this mask, all inputs with the same value are ablated >>> # simultaneously, and the attribution for each input in the same >>> # group (0, 1, 2, and 3) per example are the same. >>> # The attributions can be calculated as follows: >>> # feature mask has dimensions 1 x 4 x 4 >>> feature_mask = torch.tensor([[[0,0,1,1],[0,0,1,1], >>> [2,2,3,3],[2,2,3,3]]]) >>> attr = ablator.attribute(input, target=1, feature_mask=feature_mask) """ # Keeps track whether original input is a tuple or not before # converting it into a tuple. is_inputs_tuple = _is_tuple(inputs) inputs, baselines = _format_input_baseline(inputs, baselines) additional_forward_args = _format_additional_forward_args( additional_forward_args ) num_examples = inputs[0].shape[0] feature_mask = _format_input(feature_mask) if feature_mask is not None else None assert ( isinstance(perturbations_per_eval, int) and perturbations_per_eval >= 1 ), "Perturbations per evaluation must be an integer and at least 1." with torch.no_grad(): # Computes initial evaluation with all features, which is compared # to each ablated result. initial_eval = _run_forward( self.forward_func, inputs, target, additional_forward_args ) agg_output_mode = FeatureAblation._find_output_mode( perturbations_per_eval, feature_mask ) # get as a 2D tensor (if it is not a scalar) if isinstance(initial_eval, torch.Tensor): initial_eval = initial_eval.reshape(1, -1) num_outputs = initial_eval.shape[1] else: num_outputs = 1 if not agg_output_mode: assert ( isinstance(initial_eval, torch.Tensor) and num_outputs == num_examples ), ( "expected output of `forward_func` to have " + "`batch_size` elements for perturbations_per_eval > 1 " + "and all feature_mask.shape[0] > 1" ) # Initialize attribution totals and counts attrib_type = cast( dtype, initial_eval.dtype if isinstance(initial_eval, Tensor) else type(initial_eval), ) total_attrib = [ torch.zeros( (num_outputs,) + input.shape[1:], dtype=attrib_type, device=input.device, ) for input in inputs ] # Weights are used in cases where ablations may be overlapping. if self.use_weights: weights = [ torch.zeros( (num_outputs,) + input.shape[1:], device=input.device ).float() for input in inputs ] # Iterate through each feature tensor for ablation for i in range(len(inputs)): # Skip any empty input tensors if torch.numel(inputs[i]) == 0: continue for ( current_inputs, current_add_args, current_target, current_mask, ) in self._ablation_generator( i, inputs, additional_forward_args, target, baselines, feature_mask, perturbations_per_eval, **kwargs ): # modified_eval dimensions: 1D tensor with length # equal to #num_examples * #features in batch modified_eval = _run_forward( self.forward_func, current_inputs, current_target, current_add_args, ) # (contains 1 more dimension than inputs). This adds extra # dimensions of 1 to make the tensor broadcastable with the inputs # tensor. if not isinstance(modified_eval, torch.Tensor): eval_diff = initial_eval - modified_eval else: if not agg_output_mode: assert ( modified_eval.numel() == current_inputs[0].shape[0] ), """expected output of forward_func to grow with batch_size. If this is not the case for your model please set perturbations_per_eval = 1""" eval_diff = ( initial_eval - modified_eval.reshape((-1, num_outputs)) ).reshape((-1, num_outputs) + (len(inputs[i].shape) - 1) * (1,)) if self.use_weights: weights[i] += current_mask.float().sum(dim=0) total_attrib[i] += (eval_diff * current_mask.to(attrib_type)).sum( dim=0 ) # Divide total attributions by counts and return formatted attributions if self.use_weights: attrib = tuple( single_attrib.float() / weight for single_attrib, weight in zip(total_attrib, weights) ) else: attrib = tuple(total_attrib) _result = _format_output(is_inputs_tuple, attrib) return _result
def compute_convergence_delta( self, attributions: Union[Tensor, Tuple[Tensor, ...]], start_point: Union[None, int, float, Tensor, Tuple[Union[int, float, Tensor], ...]], end_point: Union[Tensor, Tuple[Tensor, ...]], target: TargetType = None, additional_forward_args: Any = None, ) -> Tensor: r""" Here we provide a specific implementation for `compute_convergence_delta` which is based on a common property among gradient-based attribution algorithms. In the literature sometimes it is also called completeness axiom. Completeness axiom states that the sum of the attribution must be equal to the differences of NN Models's function at its end and start points. In other words: sum(attributions) - (F(end_point) - F(start_point)) is close to zero. Returned delta of this method is defined as above stated difference. This implementation assumes that both the `start_point` and `end_point` have the same shape and dimensionality. It also assumes that the target must have the same number of examples as the `start_point` and the `end_point` in case it is provided in form of a list or a non-singleton tensor. Args: attributions (tensor or tuple of tensors): Precomputed attribution scores. The user can compute those using any attribution algorithm. It is assumed the the shape and the dimensionality of attributions must match the shape and the dimensionality of `start_point` and `end_point`. It also assumes that the attribution tensor's dimension 0 corresponds to the number of examples, and if multiple input tensors are provided, the examples must be aligned appropriately. start_point (tensor or tuple of tensors, optional): `start_point` is passed as an input to model's forward function. It is the starting point of attributions' approximation. It is assumed that both `start_point` and `end_point` have the same shape and dimensionality. end_point (tensor or tuple of tensors): `end_point` is passed as an input to model's forward function. It is the end point of attributions' approximation. It is assumed that both `start_point` and `end_point` have the same shape and dimensionality. target (int, tuple, tensor or list, optional): Output indices for which gradients are computed (for classification cases, this is usually the target class). If the network returns a scalar value per example, no target index is necessary. For general 2D outputs, targets can be either: - a single integer or a tensor containing a single integer, which is applied to all input examples - a list of integers or a 1D tensor, with length matching the number of examples in inputs (dim 0). Each integer is applied as the target for the corresponding example. For outputs with > 2 dimensions, targets can be either: - A single tuple, which contains #output_dims - 1 elements. This target index is applied to all examples. - A list of tuples with length equal to the number of examples in inputs (dim 0), and each tuple containing #output_dims - 1 elements. Each tuple is applied as the target for the corresponding example. Default: None additional_forward_args (any, optional): If the forward function requires additional arguments other than the inputs for which attributions should not be computed, this argument can be provided. It must be either a single additional argument of a Tensor or arbitrary (non-tuple) type or a tuple containing multiple additional arguments including tensors or any arbitrary python types. These arguments are provided to forward_func in order following the arguments in inputs. For a tensor, the first dimension of the tensor must correspond to the number of examples. `additional_forward_args` is used both for `start_point` and `end_point` when computing the forward pass. Default: None Returns: *tensor* of **deltas**: - **deltas** (*tensor*): This implementation returns convergence delta per sample. Deriving sub-classes may do any type of aggregation of those values, if necessary. """ end_point, start_point = _format_input_baseline(end_point, start_point) additional_forward_args = _format_additional_forward_args( additional_forward_args) # tensorizing start_point in case it is a scalar or one example baseline # If the batch size is large we could potentially also tensorize only one # sample and expand the output to the rest of the elements in the batch start_point = _tensorize_baseline(end_point, start_point) attributions = _format_tensor_into_tuples(attributions) # verify that the attributions and end_point match on 1st dimension for attribution, end_point_tnsr in zip(attributions, end_point): assert end_point_tnsr.shape[0] == attribution.shape[0], ( "Attributions tensor and the end_point must match on the first" " dimension but found attribution: {} and end_point: {}". format(attribution.shape[0], end_point_tnsr.shape[0])) num_samples = end_point[0].shape[0] _validate_input(end_point, start_point) _validate_target(num_samples, target) with torch.no_grad(): start_out_sum = _sum_rows( _run_forward(self.forward_func, start_point, target, additional_forward_args)) end_out_sum = _sum_rows( _run_forward(self.forward_func, end_point, target, additional_forward_args)) row_sums = [_sum_rows(attribution) for attribution in attributions] attr_sum = torch.stack( [cast(Tensor, sum(row_sum)) for row_sum in zip(*row_sums)]) _delta = attr_sum - (end_out_sum - start_out_sum) return _delta
def attribute( # type: ignore self, inputs: TensorOrTupleOfTensorsGeneric, baselines: BaselineType = None, target: TargetType = None, additional_forward_args: Any = None, n_steps: int = 50, method: str = "gausslegendre", internal_batch_size: Union[None, int] = None, return_convergence_delta: bool = False, ) -> Union[ TensorOrTupleOfTensorsGeneric, Tuple[TensorOrTupleOfTensorsGeneric, Tensor] ]: r""" This method attributes the output of the model with given target index (in case it is provided, otherwise it assumes that output is a scalar) to the inputs of the model using the approach described above. In addition to that it also returns, if `return_convergence_delta` is set to True, integral approximation delta based on the completeness property of integrated gradients. Args: inputs (tensor or tuple of tensors): Input for which integrated gradients are computed. If forward_func takes a single tensor as input, a single input tensor should be provided. If forward_func takes multiple tensors as input, a tuple of the input tensors should be provided. It is assumed that for all given input tensors, dimension 0 corresponds to the number of examples, and if multiple input tensors are provided, the examples must be aligned appropriately. baselines (scalar, tensor, tuple of scalars or tensors, optional): Baselines define the starting point from which integral is computed and can be provided as: - a single tensor, if inputs is a single tensor, with exactly the same dimensions as inputs or the first dimension is one and the remaining dimensions match with inputs. - a single scalar, if inputs is a single tensor, which will be broadcasted for each input value in input tensor. - a tuple of tensors or scalars, the baseline corresponding to each tensor in the inputs' tuple can be: - either a tensor with matching dimensions to corresponding tensor in the inputs' tuple or the first dimension is one and the remaining dimensions match with the corresponding input tensor. - or a scalar, corresponding to a tensor in the inputs' tuple. This scalar value is broadcasted for corresponding input tensor. In the cases when `baselines` is not provided, we internally use zero scalar corresponding to each input tensor. Default: None target (int, tuple, tensor or list, optional): Output indices for which gradients are computed (for classification cases, this is usually the target class). If the network returns a scalar value per example, no target index is necessary. For general 2D outputs, targets can be either: - a single integer or a tensor containing a single integer, which is applied to all input examples - a list of integers or a 1D tensor, with length matching the number of examples in inputs (dim 0). Each integer is applied as the target for the corresponding example. For outputs with > 2 dimensions, targets can be either: - A single tuple, which contains #output_dims - 1 elements. This target index is applied to all examples. - A list of tuples with length equal to the number of examples in inputs (dim 0), and each tuple containing #output_dims - 1 elements. Each tuple is applied as the target for the corresponding example. Default: None additional_forward_args (any, optional): If the forward function requires additional arguments other than the inputs for which attributions should not be computed, this argument can be provided. It must be either a single additional argument of a Tensor or arbitrary (non-tuple) type or a tuple containing multiple additional arguments including tensors or any arbitrary python types. These arguments are provided to forward_func in order following the arguments in inputs. For a tensor, the first dimension of the tensor must correspond to the number of examples. It will be repeated for each of `n_steps` along the integrated path. For all other types, the given argument is used for all forward evaluations. Note that attributions are not computed with respect to these arguments. Default: None n_steps (int, optional): The number of steps used by the approximation method. Default: 50. method (string, optional): Method for approximating the integral, one of `riemann_right`, `riemann_left`, `riemann_middle`, `riemann_trapezoid` or `gausslegendre`. Default: `gausslegendre` if no method is provided. internal_batch_size (int, optional): Divides total #steps * #examples data points into chunks of size at most internal_batch_size, which are computed (forward / backward passes) sequentially. internal_batch_size must be at least equal to #examples. For DataParallel models, each batch is split among the available devices, so evaluations on each available device contain internal_batch_size / num_devices examples. If internal_batch_size is None, then all evaluations are processed in one batch. Default: None return_convergence_delta (bool, optional): Indicates whether to return convergence delta or not. If `return_convergence_delta` is set to True convergence delta will be returned in a tuple following attributions. Default: False Returns: **attributions** or 2-element tuple of **attributions**, **delta**: - **attributions** (*tensor* or tuple of *tensors*): Integrated gradients with respect to each input feature. attributions will always be the same size as the provided inputs, with each value providing the attribution of the corresponding input index. If a single tensor is provided as inputs, a single tensor is returned. If a tuple is provided for inputs, a tuple of corresponding sized tensors is returned. - **delta** (*tensor*, returned if return_convergence_delta=True): The difference between the total approximated and true integrated gradients. This is computed using the property that the total sum of forward_func(inputs) - forward_func(baselines) must equal the total sum of the integrated gradient. Delta is calculated per example, meaning that the number of elements in returned delta tensor is equal to the number of of examples in inputs. Examples:: >>> # ImageClassifier takes a single input tensor of images Nx3x32x32, >>> # and returns an Nx10 tensor of class probabilities. >>> net = ImageClassifier() >>> ig = IntegratedGradients(net) >>> input = torch.randn(2, 3, 32, 32, requires_grad=True) >>> # Computes integrated gradients for class 3. >>> attribution = ig.attribute(input, target=3) """ # Keeps track whether original input is a tuple or not before # converting it into a tuple. is_inputs_tuple = _is_tuple(inputs) inputs, baselines = _format_input_baseline(inputs, baselines) _validate_input(inputs, baselines, n_steps, method) if internal_batch_size is not None: num_examples = inputs[0].shape[0] attributions = _batch_attribution( self, num_examples, internal_batch_size, n_steps, inputs=inputs, baselines=baselines, target=target, additional_forward_args=additional_forward_args, method=method, ) else: attributions = self._attribute( inputs=inputs, baselines=baselines, target=target, additional_forward_args=additional_forward_args, n_steps=n_steps, method=method, ) if return_convergence_delta: start_point, end_point = baselines, inputs # computes approximation error based on the completeness axiom delta = self.compute_convergence_delta( attributions, start_point, end_point, additional_forward_args=additional_forward_args, target=target, ) return _format_output(is_inputs_tuple, attributions), delta return _format_output(is_inputs_tuple, attributions)
def attribute( self, inputs: TensorOrTupleOfTensorsGeneric, baselines: BaselineType = None, target: TargetType = None, additional_forward_args: Any = None, feature_mask: Union[None, TensorOrTupleOfTensorsGeneric] = None, n_samples: int = 25, perturbations_per_eval: int = 1, show_progress: bool = False, ) -> TensorOrTupleOfTensorsGeneric: r""" NOTE: The feature_mask argument differs from other perturbation based methods, since feature indices can overlap across tensors. See the description of the feature_mask argument below for more details. Args: inputs (tensor or tuple of tensors): Input for which Shapley value sampling attributions are computed. If forward_func takes a single tensor as input, a single input tensor should be provided. If forward_func takes multiple tensors as input, a tuple of the input tensors should be provided. It is assumed that for all given input tensors, dimension 0 corresponds to the number of examples (aka batch size), and if multiple input tensors are provided, the examples must be aligned appropriately. baselines (scalar, tensor, tuple of scalars or tensors, optional): Baselines define reference value which replaces each feature when ablated. Baselines can be provided as: - a single tensor, if inputs is a single tensor, with exactly the same dimensions as inputs or the first dimension is one and the remaining dimensions match with inputs. - a single scalar, if inputs is a single tensor, which will be broadcasted for each input value in input tensor. - a tuple of tensors or scalars, the baseline corresponding to each tensor in the inputs' tuple can be: - either a tensor with matching dimensions to corresponding tensor in the inputs' tuple or the first dimension is one and the remaining dimensions match with the corresponding input tensor. - or a scalar, corresponding to a tensor in the inputs' tuple. This scalar value is broadcasted for corresponding input tensor. In the cases when `baselines` is not provided, we internally use zero scalar corresponding to each input tensor. Default: None target (int, tuple, tensor or list, optional): Output indices for which difference is computed (for classification cases, this is usually the target class). If the network returns a scalar value per example, no target index is necessary. For general 2D outputs, targets can be either: - a single integer or a tensor containing a single integer, which is applied to all input examples - a list of integers or a 1D tensor, with length matching the number of examples in inputs (dim 0). Each integer is applied as the target for the corresponding example. For outputs with > 2 dimensions, targets can be either: - A single tuple, which contains #output_dims - 1 elements. This target index is applied to all examples. - A list of tuples with length equal to the number of examples in inputs (dim 0), and each tuple containing #output_dims - 1 elements. Each tuple is applied as the target for the corresponding example. Default: None additional_forward_args (any, optional): If the forward function requires additional arguments other than the inputs for which attributions should not be computed, this argument can be provided. It must be either a single additional argument of a Tensor or arbitrary (non-tuple) type or a tuple containing multiple additional arguments including tensors or any arbitrary python types. These arguments are provided to forward_func in order following the arguments in inputs. For a tensor, the first dimension of the tensor must correspond to the number of examples. For all other types, the given argument is used for all forward evaluations. Note that attributions are not computed with respect to these arguments. Default: None feature_mask (tensor or tuple of tensors, optional): feature_mask defines a mask for the input, grouping features which should be added together. feature_mask should contain the same number of tensors as inputs. Each tensor should be the same size as the corresponding input or broadcastable to match the input tensor. Values across all tensors should be integers in the range 0 to num_features - 1, and indices corresponding to the same feature should have the same value. Note that features are grouped across tensors (unlike feature ablation and occlusion), so if the same index is used in different tensors, those features are still grouped and added simultaneously. If the forward function returns a single scalar per batch, we enforce that the first dimension of each mask must be 1, since attributions are returned batch-wise rather than per example, so the attributions must correspond to the same features (indices) in each input example. If None, then a feature mask is constructed which assigns each scalar within a tensor as a separate feature Default: None n_samples (int, optional): The number of feature permutations tested. Default: `25` if `n_samples` is not provided. perturbations_per_eval (int, optional): Allows multiple ablations to be processed simultaneously in one call to forward_fn. Each forward pass will contain a maximum of perturbations_per_eval * #examples samples. For DataParallel models, each batch is split among the available devices, so evaluations on each available device contain at most (perturbations_per_eval * #examples) / num_devices samples. If the forward function returns a single scalar per batch, perturbations_per_eval must be set to 1. Default: 1 show_progress (bool, optional): Displays the progress of computation. It will try to use tqdm if available for advanced features (e.g. time estimation). Otherwise, it will fallback to a simple output of progress. Default: False Returns: *tensor* or tuple of *tensors* of **attributions**: - **attributions** (*tensor* or tuple of *tensors*): The attributions with respect to each input feature. If the forward function returns a scalar value per example, attributions will be the same size as the provided inputs, with each value providing the attribution of the corresponding input index. If the forward function returns a scalar per batch, then attribution tensor(s) will have first dimension 1 and the remaining dimensions will match the input. If a single tensor is provided as inputs, a single tensor is returned. If a tuple is provided for inputs, a tuple of corresponding sized tensors is returned. Examples:: >>> # SimpleClassifier takes a single input tensor of size Nx4x4, >>> # and returns an Nx3 tensor of class probabilities. >>> net = SimpleClassifier() >>> # Generating random input with size 2 x 4 x 4 >>> input = torch.randn(2, 4, 4) >>> # Defining ShapleyValueSampling interpreter >>> svs = ShapleyValueSampling(net) >>> # Computes attribution, taking random orderings >>> # of the 16 features and computing the output change when adding >>> # each feature. We average over 200 trials (random permutations). >>> attr = svs.attribute(input, target=1, n_samples=200) >>> # Alternatively, we may want to add features in groups, e.g. >>> # grouping each 2x2 square of the inputs and adding them together. >>> # This can be done by creating a feature mask as follows, which >>> # defines the feature groups, e.g.: >>> # +---+---+---+---+ >>> # | 0 | 0 | 1 | 1 | >>> # +---+---+---+---+ >>> # | 0 | 0 | 1 | 1 | >>> # +---+---+---+---+ >>> # | 2 | 2 | 3 | 3 | >>> # +---+---+---+---+ >>> # | 2 | 2 | 3 | 3 | >>> # +---+---+---+---+ >>> # With this mask, all inputs with the same value are added >>> # together, and the attribution for each input in the same >>> # group (0, 1, 2, and 3) per example are the same. >>> # The attributions can be calculated as follows: >>> # feature mask has dimensions 1 x 4 x 4 >>> feature_mask = torch.tensor([[[0,0,1,1],[0,0,1,1], >>> [2,2,3,3],[2,2,3,3]]]) >>> attr = svs.attribute(input, target=1, feature_mask=feature_mask) """ # Keeps track whether original input is a tuple or not before # converting it into a tuple. is_inputs_tuple = _is_tuple(inputs) inputs, baselines = _format_input_baseline(inputs, baselines) additional_forward_args = _format_additional_forward_args( additional_forward_args ) feature_mask = ( _format_tensor_into_tuples(feature_mask) if feature_mask is not None else None ) assert ( isinstance(perturbations_per_eval, int) and perturbations_per_eval >= 1 ), "Ablations per evaluation must be at least 1." with torch.no_grad(): baselines = _tensorize_baseline(inputs, baselines) num_examples = inputs[0].shape[0] if feature_mask is None: feature_mask, total_features = _construct_default_feature_mask(inputs) else: total_features = int( max(torch.max(single_mask).item() for single_mask in feature_mask) + 1 ) if show_progress: attr_progress = progress( desc=f"{self.get_name()} attribution", total=self._get_n_evaluations( total_features, n_samples, perturbations_per_eval ) + 1, # add 1 for the initial eval ) attr_progress.update(0) initial_eval = _run_forward( self.forward_func, baselines, target, additional_forward_args ) if show_progress: attr_progress.update() agg_output_mode = _find_output_mode_and_verify( initial_eval, num_examples, perturbations_per_eval, feature_mask ) # Initialize attribution totals and counts total_attrib = [ torch.zeros_like( input[0:1] if agg_output_mode else input, dtype=torch.float ) for input in inputs ] iter_count = 0 # Iterate for number of samples, generate a permutation of the features # and evalute the incremental increase for each feature. for feature_permutation in self.permutation_generator( total_features, n_samples ): iter_count += 1 prev_results = initial_eval for ( current_inputs, current_add_args, current_target, current_masks, ) in self._perturbation_generator( inputs, additional_forward_args, target, baselines, feature_mask, feature_permutation, perturbations_per_eval, ): if sum(torch.sum(mask).item() for mask in current_masks) == 0: warnings.warn( "Feature mask is missing some integers between 0 and " "num_features, for optimal performance, make sure each" " consecutive integer corresponds to a feature." ) # modified_eval dimensions: 1D tensor with length # equal to #num_examples * #features in batch modified_eval = _run_forward( self.forward_func, current_inputs, current_target, current_add_args, ) if show_progress: attr_progress.update() if agg_output_mode: eval_diff = modified_eval - prev_results prev_results = modified_eval else: all_eval = torch.cat((prev_results, modified_eval), dim=0) eval_diff = all_eval[num_examples:] - all_eval[:-num_examples] prev_results = all_eval[-num_examples:] for j in range(len(total_attrib)): current_eval_diff = eval_diff if not agg_output_mode: # current_eval_diff dimensions: # (#features in batch, #num_examples, 1,.. 1) # (contains 1 more dimension than inputs). This adds extra # dimensions of 1 to make the tensor broadcastable with the # inputs tensor. current_eval_diff = current_eval_diff.reshape( (-1, num_examples) + (len(inputs[j].shape) - 1) * (1,) ) total_attrib[j] += ( current_eval_diff * current_masks[j].float() ).sum(dim=0) if show_progress: attr_progress.close() # Divide total attributions by number of random permutations and return # formatted attributions. attrib = tuple( tensor_attrib_total / iter_count for tensor_attrib_total in total_attrib ) formatted_attr = _format_output(is_inputs_tuple, attrib) return formatted_attr