variable names more general; remove use_cuda

Author: holyseven

interpretdl/interpreter/abc_interpreter.py

@@ -34,7 +34,7 @@ class Interpreter(ABC):
     .. warning:: ``use_cuda`` would be deprecated soon. Use ``device`` directly.
     """
 
-    def __init__(self, model: callable, device: str, use_cuda: bool = None, **kwargs):
+    def __init__(self, model: callable, device: str, **kwargs):
         """
         
         Args:
@@ -46,9 +46,9 @@ def __init__(self, model: callable, device: str, use_cuda: bool = None, **kwargs
         self.model = model
         self.predict_fn = None
 
-        if use_cuda in [True, False]:
+        if 'use_cuda' in kwargs and kwargs['use_cuda'] in [True, False]:
             warnings.warn('``use_cuda`` would be deprecated soon. Use ``device`` directly.', stacklevel=2)
-            self.device = 'gpu:0' if use_cuda and device[:3] == 'gpu' else 'cpu'
+            self.device = 'gpu:0' if kwargs['use_cuda'] and device[:3] == 'gpu' else 'cpu'
 
         assert self.device[:3] in ['cpu', 'gpu']
 
@@ -90,15 +90,15 @@ class InputGradientInterpreter(Interpreter):
     This Interpreter implements :py:func:`_build_predict_fn` that returns input gradient given an input. 
     """
 
-    def __init__(self, model: callable, device: str, use_cuda: bool = None, **kwargs):
+    def __init__(self, model: callable, device: str, **kwargs):
         """
         
         Args:
             model (callable): A model with :py:func:`forward` and possibly :py:func:`backward` functions.
             device (str): The device used for running ``model``, options: ``"cpu"``, ``"gpu:0"``, ``"gpu:1"`` 
                 etc.
         """
-        Interpreter.__init__(self, model, device, use_cuda, **kwargs)
+        Interpreter.__init__(self, model, device, **kwargs)
         assert hasattr(model, 'forward'), \
             "model has to be " \
             "an instance of paddle.nn.Layer or a compatible one."
@@ -195,15 +195,15 @@ class InputOutputInterpreter(Interpreter):
 
     """
 
-    def __init__(self, model: callable, device: str, use_cuda: bool = None, **kwargs):
+    def __init__(self, model: callable, device: str, **kwargs):
         """
         
         Args:
             model (callable): A model with :py:func:`forward` and possibly :py:func:`backward` functions.
             device (str): The device used for running ``model``, options: ``"cpu"``, ``"gpu:0"``, ``"gpu:1"`` 
                 etc.
         """
-        Interpreter.__init__(self, model, device, use_cuda, **kwargs)
+        Interpreter.__init__(self, model, device, **kwargs)
         assert hasattr(model, 'forward'), \
             "model has to be " \
             "an instance of paddle.nn.Layer or a compatible one."
@@ -271,7 +271,7 @@ class IntermediateLayerInterpreter(Interpreter):
     input. 
     """
 
-    def __init__(self, model: callable, device: str, use_cuda: bool = None, **kwargs):
+    def __init__(self, model: callable, device: str, **kwargs):
         """
 
         Args:
@@ -280,7 +280,7 @@ def __init__(self, model: callable, device: str, use_cuda: bool = None, **kwargs
                 etc.
         """
 
-        Interpreter.__init__(self, model, device, use_cuda, **kwargs)
+        Interpreter.__init__(self, model, device, **kwargs)
         assert hasattr(model, 'forward'), \
             "model has to be " \
             "an instance of paddle.nn.Layer or a compatible one."
@@ -361,15 +361,15 @@ class TransformerInterpreter(Interpreter):
     This Interpreter implements :py:func:`_build_predict_fn` that returns servral variables and gradients in each layer. 
     """
 
-    def __init__(self, model: callable, device: str, use_cuda: bool = None, **kwargs):
+    def __init__(self, model: callable, device: str, **kwargs):
         """
         
         Args:
             model (callable): A model with :py:func:`forward` and possibly :py:func:`backward` functions.
             device (str): The device used for running ``model``, options: ``"cpu"``, ``"gpu:0"``, ``"gpu:1"`` 
                 etc.
         """
-        Interpreter.__init__(self, model, device, use_cuda, **kwargs)
+        Interpreter.__init__(self, model, device, **kwargs)
         assert hasattr(model, 'forward'), \
             "model has to be " \
             "an instance of paddle.nn.Layer or a compatible one."

interpretdl/interpreter/bidirectional_transformer.py

@@ -16,15 +16,15 @@ class BTCVInterpreter(TransformerInterpreter):
     The following implementation is specially designed for Vision Transformer.
     """
 
-    def __init__(self, paddle_model: callable, device: str = 'gpu:0', use_cuda=None) -> None:
+    def __init__(self, model: callable, device: str = 'gpu:0') -> None:
         """
 
         Args:
-            paddle_model (callable): A model with :py:func:`forward` and possibly :py:func:`backward` functions.
-            device (str): The device used for running ``paddle_model``, options: ``"cpu"``, ``"gpu:0"``, ``"gpu:1"`` 
+            model (callable): A model with :py:func:`forward` and possibly :py:func:`backward` functions.
+            device (str): The device used for running ``model``, options: ``"cpu"``, ``"gpu:0"``, ``"gpu:1"`` 
                 etc.
         """
-        TransformerInterpreter.__init__(self, paddle_model, device, use_cuda)
+        TransformerInterpreter.__init__(self, model, device)
 
     def interpret(self,
                   inputs: str or list(str) or np.ndarray,
@@ -130,7 +130,7 @@ def interpret(self,
         # gradient mean over heads.
         grad_head_mean = np.mean((total_gradients / steps).clip(min=0), axis=1)  # [b, s, s]
 
-        if hasattr(self.paddle_model, 'global_pool') and self.paddle_model.global_pool:
+        if hasattr(self.model, 'global_pool') and self.model.global_pool:
             # For MAE ViT.
             explanation = (R * grad_head_mean)[:, 1:, :].mean(axis=1)
         else:
@@ -157,15 +157,15 @@ class BTNLPInterpreter(TransformerInterpreter):
     The following implementation is specially designed for Ernie.
     """
 
-    def __init__(self, paddle_model: callable, device: str = 'gpu:0', use_cuda=None) -> None:
+    def __init__(self, model: callable, device: str = 'gpu:0') -> None:
         """
 
         Args:
-            paddle_model (callable): A model with :py:func:`forward` and possibly :py:func:`backward` functions.
-            device (str): The device used for running ``paddle_model``, options: ``"cpu"``, ``"gpu:0"``, ``"gpu:1"`` 
+            model (callable): A model with :py:func:`forward` and possibly :py:func:`backward` functions.
+            device (str): The device used for running ``model``, options: ``"cpu"``, ``"gpu:0"``, ``"gpu:1"`` 
                 etc.
         """
-        TransformerInterpreter.__init__(self, paddle_model, device, use_cuda)
+        TransformerInterpreter.__init__(self, model, device)
 
     def interpret(self,
                   raw_text: str,

interpretdl/interpreter/forgetting_events.py

@@ -19,15 +19,15 @@ class ForgettingEventsInterpreter(Interpreter):
     https://arxiv.org/abs/1812.05159.
     """
 
-    def __init__(self, paddle_model: callable, device: str = 'gpu:0', use_cuda=None):
+    def __init__(self, model: callable, device: str = 'gpu:0'):
         """
         
         Args:
-            paddle_model (callable): A model with :py:func:`forward` and possibly :py:func:`backward` functions.
-            device (str): The device used for running ``paddle_model``, options: ``"cpu"``, ``"gpu:0"``, ``"gpu:1"`` 
+            model (callable): A model with :py:func:`forward` and possibly :py:func:`backward` functions.
+            device (str): The device used for running ``model``, options: ``"cpu"``, ``"gpu:0"``, ``"gpu:1"`` 
                 etc.
         """
-        Interpreter.__init__(self, paddle_model, device, use_cuda)
+        Interpreter.__init__(self, model, device)
 
     def interpret(self,
                   train_reader: callable,
@@ -73,7 +73,7 @@ def interpret(self,
                 y_train = [t[2] for t in data_train]
                 x_train = paddle.to_tensor(x_train)
                 y_train = paddle.to_tensor(np.array(y_train).reshape((-1, 1)))
-                logits = self.paddle_model(x_train)
+                logits = self.model(x_train)
                 predicted = paddle.argmax(logits, axis=1).numpy()
                 bsz = len(predicted)
 

interpretdl/interpreter/generic_attention.py

@@ -22,15 +22,15 @@ class GAInterpreter(InputGradientInterpreter):
 
     """
 
-    def __init__(self, paddle_model: callable, device: str = 'gpu:0') -> None:
+    def __init__(self, model: callable, device: str = 'gpu:0') -> None:
         """
 
         Args:
-            paddle_model (callable): A model with :py:func:`forward` and possibly :py:func:`backward` functions.
-            device (str): The device used for running ``paddle_model``, options: ``"cpu"``, ``"gpu:0"``, ``"gpu:1"`` 
+            model (callable): A model with :py:func:`forward` and possibly :py:func:`backward` functions.
+            device (str): The device used for running ``model``, options: ``"cpu"``, ``"gpu:0"``, ``"gpu:1"`` 
                 etc.
         """
-        Interpreter.__init__(self, paddle_model, device)
+        Interpreter.__init__(self, model, device)
 
     def interpret(self,
                   image_input: str or np.ndarray,
@@ -140,7 +140,7 @@ def _build_predict_fn(self, vis_attn_layer_pattern: str, txt_attn_layer_pattern:
 
         if self.predict_fn is None or rebuild:
             import paddle
-            self._paddle_env_setup()  # inherit from InputGradientInterpreter
+            self._env_setup()  # inherit from InputGradientInterpreter
 
             def predict_fn(image, text_tokenized):
                 image = paddle.to_tensor(image)
@@ -158,7 +158,7 @@ def txt_hook(layer, input, output):
                     txt_attns.append(output)
 
                 hooks = []  # for remove.
-                for n, v in self.paddle_model.named_sublayers():
+                for n, v in self.model.named_sublayers():
                     if re.match(vis_attn_layer_pattern, n):
                         h = v.register_forward_post_hook(img_hook)
                         hooks.append(h)
@@ -167,7 +167,7 @@ def txt_hook(layer, input, output):
                         h = v.register_forward_post_hook(txt_hook)
                         hooks.append(h)
 
-                logits_per_image, logits_per_text = self.paddle_model(image, text_tokenized)
+                logits_per_image, logits_per_text = self.model(image, text_tokenized)
 
                 for h in hooks:
                     h.remove()
@@ -180,7 +180,7 @@ def txt_hook(layer, input, output):
                 one_hot[paddle.arange(logits_per_image.shape[0]), index] = 1
                 one_hot = paddle.to_tensor(one_hot)
                 one_hot = paddle.sum(one_hot * logits_per_image)
-                self.paddle_model.clear_gradients()
+                self.model.clear_gradients()
                 one_hot.backward()
 
                 img_attns_grads = []
@@ -218,15 +218,15 @@ class GANLPInterpreter(TransformerInterpreter):
 
     """
 
-    def __init__(self, paddle_model: callable, device: str = 'gpu:0', use_cuda=None) -> None:
+    def __init__(self, model: callable, device: str = 'gpu:0') -> None:
         """
 
         Args:
-            paddle_model (callable): A model with :py:func:`forward` and possibly :py:func:`backward` functions.
-            device (str): The device used for running ``paddle_model``, options: ``"cpu"``, ``"gpu:0"``, ``"gpu:1"`` 
+            model (callable): A model with :py:func:`forward` and possibly :py:func:`backward` functions.
+            device (str): The device used for running ``model``, options: ``"cpu"``, ``"gpu:0"``, ``"gpu:1"`` 
                 etc.
         """
-        TransformerInterpreter.__init__(self, paddle_model, device, use_cuda)
+        TransformerInterpreter.__init__(self, model, device)
 
     def interpret(self,
                   raw_text: str,
@@ -315,15 +315,15 @@ class GACVInterpreter(TransformerInterpreter):
     The following implementation is specially designed for Vision Transformer.
     """
 
-    def __init__(self, paddle_model: callable, device: str = 'gpu:0', use_cuda=None) -> None:
+    def __init__(self, model: callable, device: str = 'gpu:0') -> None:
         """
 
         Args:
-            paddle_model (callable): A model with :py:func:`forward` and possibly :py:func:`backward` functions.
-            device (str): The device used for running ``paddle_model``, options: ``"cpu"``, ``"gpu:0"``, ``"gpu:1"`` 
+            model (callable): A model with :py:func:`forward` and possibly :py:func:`backward` functions.
+            device (str): The device used for running ``model``, options: ``"cpu"``, ``"gpu:0"``, ``"gpu:1"`` 
                 etc.
         """
-        TransformerInterpreter.__init__(self, paddle_model, device, use_cuda)
+        TransformerInterpreter.__init__(self, model, device)
 
     def interpret(self,
                   inputs: str or list(str) or np.ndarray,
@@ -381,7 +381,7 @@ def interpret(self,
 
             R = R + np.matmul(attn, R)
 
-        if hasattr(self.paddle_model, 'global_pool') and self.paddle_model.global_pool:
+        if hasattr(self.model, 'global_pool') and self.model.global_pool:
             # For MAE ViT, but GA does not work well.
             R = R[:, 1:, :].mean(axis=1)
         else:

interpretdl/interpreter/glime.py

@@ -20,15 +20,15 @@ class GLIMECVInterpreter(LIMECVInterpreter):
     
     """
 
-    def __init__(self, paddle_model: callable, device: str = 'gpu:0') -> None:
+    def __init__(self, model: callable, device: str = 'gpu:0') -> None:
         """
 
         Args:
-            paddle_model (callable): A model with :py:func:`forward` and possibly :py:func:`backward` functions.
-            device (str): The device used for running ``paddle_model``, options: ``"cpu"``, ``"gpu:0"``, ``"gpu:1"`` 
+            model (callable): A model with :py:func:`forward` and possibly :py:func:`backward` functions.
+            device (str): The device used for running ``model``, options: ``"cpu"``, ``"gpu:0"``, ``"gpu:1"`` 
                 etc.
         """
-        LIMECVInterpreter.__init__(self, paddle_model, device)
+        LIMECVInterpreter.__init__(self, model, device)
         self.global_weights = None
 
     def set_global_weights(self, global_weights_info: str or dict):

interpretdl/interpreter/gradient_cam.py

@@ -24,15 +24,15 @@ class GradCAMInterpreter(Interpreter):
     https://arxiv.org/abs/1610.02391.
     """
 
-    def __init__(self, paddle_model: callable, device: str = 'gpu:0', use_cuda=None):
+    def __init__(self, model: callable, device: str = 'gpu:0'):
         """
         
         Args:
-            paddle_model (callable): A model with :py:func:`forward` and possibly :py:func:`backward` functions.
-            device (str): The device used for running ``paddle_model``, options: ``"cpu"``, ``"gpu:0"``, ``"gpu:1"`` 
+            model (callable): A model with :py:func:`forward` and possibly :py:func:`backward` functions.
+            device (str): The device used for running ``model``, options: ``"cpu"``, ``"gpu:0"``, ``"gpu:1"`` 
                 etc.
         """
-        Interpreter.__init__(self, paddle_model, device, use_cuda)
+        Interpreter.__init__(self, model, device)
         self.paddle_prepared = False
 
         # init for usages during the interpretation.
@@ -76,9 +76,9 @@ def interpret(self,
         bsz = len(data)  # batch size
         save_path = preprocess_save_path(save_path, bsz)
 
-        assert target_layer_name in [n for n, v in self.paddle_model.named_sublayers()], \
+        assert target_layer_name in [n for n, v in self.model.named_sublayers()], \
             f"target_layer_name {target_layer_name} does not exist in the given model, " \
-            f"please check all valid layer names by [n for n, v in paddle_model.named_sublayers()]"
+            f"please check all valid layer names by [n for n, v in model.named_sublayers()]"
 
         if self._target_layer_name != target_layer_name:
             self._target_layer_name = target_layer_name
@@ -119,12 +119,12 @@ def _paddle_prepare(self, predict_fn=None):
             paddle.set_device(self.device)
             # to get gradients, the ``train`` mode must be set.
             # we cannot set v.training = False for the same reason.
-            self.paddle_model.train()
+            self.model.train()
 
             def hook(layer, input, output):
                 self._feature_maps[layer._layer_name_for_hook] = output
 
-            for n, v in self.paddle_model.named_sublayers():
+            for n, v in self.model.named_sublayers():
                 if n == self._target_layer_name:
                     v._layer_name_for_hook = n
                     v.register_forward_post_hook(hook)
@@ -137,7 +137,7 @@ def hook(layer, input, output):
             def predict_fn(data, label):
                 data = paddle.to_tensor(data)
                 data.stop_gradient = False
-                out = self.paddle_model(data)
+                out = self.model(data)
                 out = paddle.nn.functional.softmax(out, axis=1)
                 preds = paddle.argmax(out, axis=1)
                 if label is None: