Merge pull request #98 from vivekmig/DocStringFormatFix

Fixing docstring formatting

Author: vivekmig

captum/attr/_core/deep_lift.py

@@ -144,22 +144,23 @@ def attribute(
                         Default: False
 
         Returns:
-
-            attributions (tensor or tuple of tensors): Attribution score
-                        computed based on DeepLift rescale rule 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, optional): This is computed using the property that the total
-                        sum of forward_func(inputs) - forward_func(baselines)
-                        must equal the total sum of the attributions computed
-                        based on Deeplift's rescale rule.
-                        Delta is calculated per example, meaning that the number of
-                        elements in returned delta tensor is equal to the number of
-                        of examples in input.
+            **attributions** or 2-element tuple of **attributions**, **delta**:
+            - **attributions** (*tensor* or tuple of *tensors*):
+                Attribution score computed based on DeepLift rescale rule 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):
+                This is computed using the property that
+                the total sum of forward_func(inputs) - forward_func(baselines)
+                must equal the total sum of the attributions computed
+                based on Deeplift's rescale rule.
+                Delta is calculated per example, meaning that the number of
+                elements in returned delta tensor is equal to the number of
+                of examples in input.
 
         Examples::
 
@@ -435,16 +436,17 @@ def attribute(
                         Default: False
 
         Returns:
-
-            attributions (tensor or tuple of tensors): Attribution score
-                        computed based on DeepLift rescale rule with respect
-                        to each input feature. Attributions will always be
+            **attributions** or 2-element tuple of **attributions**, **delta**:
+            - **attributions** (*tensor* or tuple of *tensors*):
+                        Attribution score computed based on DeepLift rescale rule 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, optional): This is computed using the property that the
+            - **delta** (*tensor*, returned if return_convergence_delta=True):
+                        This is computed using the property that the
                         total sum of forward_func(inputs) - forward_func(baselines)
                         must be very close to the total sum of attributions
                         computed based on approximated SHAP values using

captum/attr/_core/gradient_shap.py

@@ -141,16 +141,17 @@ def attribute(
                         a tuple following attributions.
                         Default: False
         Returns:
-
-            attributions (tensor or tuple of tensors): Attribution score
-                        computed based on GradientSHAP with respect
+            **attributions** or 2-element tuple of **attributions**, **delta**:
+            - **attributions** (*tensor* or tuple of *tensors*):
+                        Attribution score computed based on GradientSHAP 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, optional): This is computed using the property that the total
+            - **delta** (*tensor*, returned if return_convergence_delta=True):
+                        This is computed using the property that the total
                         sum of forward_func(inputs) - forward_func(baselines)
                         must be very close to the total sum of the attributions
                         based on GradientSHAP.

captum/attr/_core/input_x_gradient.py

@@ -68,9 +68,10 @@ def attribute(self, inputs, target=None, additional_forward_args=None):
                         to these arguments.
                         Default: None
 
-        Return:
-
-                attributions (tensor or tuple of tensors): The input x gradient with
+        Returns:
+                *tensor* or tuple of *tensors* of **attributions**:
+                - **attributions** (*tensor* or tuple of *tensors*):
+                            The input x gradient 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.

captum/attr/_core/integrated_gradients.py

@@ -124,23 +124,25 @@ def attribute(
                             is set to True convergence delta will be returned in
                             a tuple following attributions.
                             Default: False
-            Return:
-
-                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, optional): 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.
+            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::
 

captum/attr/_core/internal_influence.py

@@ -17,7 +17,7 @@
 class InternalInfluence(LayerAttribution):
     def __init__(self, forward_func, layer, device_ids=None):
         r"""
-        Args
+        Args:
 
             forward_func (callable):  The forward function of the model or any
                           modification of it
@@ -57,7 +57,7 @@ def attribute(
             taking the layer as input, integrating the gradient of the layer with
             respect to the output.
 
-            Args
+            Args:
 
                 inputs (tensor or tuple of tensors):  Input for which internal
                             influence is computed. If forward_func takes a single
@@ -133,9 +133,10 @@ def attribute(
                             are processed in one batch.
                             Default: None
 
-            Return
-
-                attributions (tensor): Internal influence of each neuron in given
+            Returns:
+                *tensor* of **attributions**:
+                - **attributions** (*tensor*):
+                            Internal influence of each neuron in given
                             layer output. Attributions will always be the same size
                             as the output of the given layer.
 

captum/attr/_core/layer_activation.py

@@ -6,7 +6,7 @@
 class LayerActivation(LayerAttribution):
     def __init__(self, forward_func, layer, device_ids=None):
         r"""
-        Args
+        Args:
 
             forward_func (callable):  The forward function of the model or any
                           modification of it
@@ -28,7 +28,7 @@ def attribute(self, inputs, additional_forward_args=None):
         r"""
             Computes activation of selected layer for given input.
 
-            Args
+            Args:
 
                 inputs (tensor or tuple of tensors):  Input for which layer
                             activation is computed. If forward_func takes a single
@@ -51,9 +51,10 @@ def attribute(self, inputs, additional_forward_args=None):
                             to these arguments.
                             Default: None
 
-            Return
-
-                attributions (tensor): Activation of each neuron in given layer output.
+            Returns:
+                *tensor* of **attributions**:
+                - **attributions** (*tensor*):
+                            Activation of each neuron in given layer output.
                             Attributions will always be the same size as the
                             output of the given layer.
 

captum/attr/_core/layer_conductance.py

@@ -17,7 +17,7 @@
 class LayerConductance(LayerAttribution):
     def __init__(self, forward_func, layer, device_ids=None):
         r"""
-        Args
+        Args:
 
             forward_func (callable):  The forward function of the model or any
                           modification of it
@@ -63,7 +63,7 @@ def attribute(
             features, utilize NeuronConductance instead, and provide the target
             neuron index.
 
-            Args
+            Args:
 
                 inputs (tensor or tuple of tensors):  Input for which layer
                             conductance is computed. If forward_func takes a single
@@ -144,12 +144,14 @@ def attribute(
                             a tuple following attributions.
                             Default: False
 
-            Return
-
-                attributions (tensor): Conductance of each neuron in given layer output.
+            Returns:
+                **attributions** or 2-element tuple of **attributions**, **delta**:
+                - **attributions** (*tensor*):
+                            Conductance of each neuron in given layer output.
                             Attributions will always be the same size as the
                             output of the given layer.
-                delta (tensor, optional): The difference between the total
+                - **delta** (*tensor*, returned if return_convergence_delta=True):
+                            The difference between the total
                             approximated and true conductance.
                             This is computed using the property that the total sum of
                             forward_func(inputs) - forward_func(baselines) must equal

captum/attr/_core/layer_gradient_x_activation.py

@@ -7,7 +7,7 @@
 class LayerGradientXActivation(LayerAttribution):
     def __init__(self, forward_func, layer, device_ids=None):
         r"""
-        Args
+        Args:
 
             forward_func (callable):  The forward function of the model or any
                           modification of it
@@ -30,7 +30,7 @@ def attribute(self, inputs, target=None, additional_forward_args=None):
             Computes element-wise product of gradient and activation for selected
             layer on given inputs.
 
-            Args
+            Args:
 
                 inputs (tensor or tuple of tensors):  Input for which attributions
                             are computed. If forward_func takes a single
@@ -78,9 +78,10 @@ def attribute(self, inputs, target=None, additional_forward_args=None):
                             to these arguments.
                             Default: None
 
-            Return
-
-                attributions (tensor): Product of gradient and activation for each
+            Returns:
+                *tensor* of **attributions**:
+                - **attributions** (*tensor*):
+                            Product of gradient and activation for each
                             neuron in given layer output.
                             Attributions will always be the same size as the
                             output of the given layer.

captum/attr/_core/neuron_conductance.py

@@ -19,7 +19,7 @@
 class NeuronConductance(NeuronAttribution):
     def __init__(self, forward_func, layer, device_ids=None):
         r"""
-        Args
+        Args:
 
             forward_func (callable):  The forward function of the model or any
                           modification of it
@@ -138,9 +138,10 @@ def attribute(
                             processed in one batch.
                             Default: None
 
-            Return:
-
-                attributions (tensor or tuple of tensors): Conductance for
+            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

captum/attr/_core/neuron_gradient.py

@@ -15,7 +15,7 @@
 class NeuronGradient(NeuronAttribution):
     def __init__(self, forward_func, layer, device_ids=None):
         r"""
-        Args
+        Args:
 
             forward_func (callable):  The forward function of the model or any
                           modification of it
@@ -38,7 +38,7 @@ def attribute(self, inputs, neuron_index, additional_forward_args=None):
             Computes the gradient of the output of a particular neuron with
             respect to the inputs of the network.
 
-            Args
+            Args:
 
                 inputs (tensor or tuple of tensors):  Input for which neuron
                             gradients are computed. If forward_func takes a single
@@ -68,13 +68,13 @@ def attribute(self, inputs, neuron_index, additional_forward_args=None):
                             to these arguments.
                             Default: None
 
-            Return
-
-                attributions (tensor or tuple of tensors): Gradients of
-                            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.
+            Returns:
+                *tensor* or tuple of *tensors* of **attributions**:
+                - **attributions** (*tensor* or tuple of *tensors*):
+                            Gradients of 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.

captum/attr/_core/neuron_integrated_gradients.py

@@ -8,7 +8,7 @@
 class NeuronIntegratedGradients(NeuronAttribution):
     def __init__(self, forward_func, layer, device_ids=None):
         r"""
-        Args
+        Args:
 
             forward_func (callable):  The forward function of the model or any
                           modification of it
@@ -106,10 +106,11 @@ def attribute(
                             processed in one batch.
                             Default: None
 
-            Return:
-
-                attributions (tensor or tuple of tensors): Integrated gradients for
-                            particular neuron with respect to each input feature.
+            Returns:
+                *tensor* or tuple of *tensors* of **attributions**:
+                - **attributions** (*tensor* or tuple of *tensors*):
+                            Integrated gradients 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.

captum/attr/_core/noise_tunnel.py

@@ -109,16 +109,18 @@ def attribute(
                             For instance, such arguments include
                             `additional_forward_args` and `baselines`.
 
-            Return:
-
-                attributions (tensor or tuple of tensors): Attribution with
+            Returns:
+                **attributions** or 2-element tuple of **attributions**, **delta**:
+                - **attributions** (*tensor* or tuple of *tensors*):
+                            Attribution 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 (float, optional): Approximation error computed by the
+                - **delta** (*float*, returned if return_convergence_delta=True):
+                            Approximation error computed by the
                             attribution algorithm. Not all attribution algorithms
                             return delta value. It is computed only for some
                             algorithms, e.g. integrated gradients.