Fix LGTM

Signed-off-by: Beat Buesser <[email protected]>

Author: Beat Buesser

art/attacks/evasion/imperceptible_asr/imperceptible_asr_pytorch.py

@@ -27,8 +27,8 @@
 import logging
 from typing import Tuple, TYPE_CHECKING
 
-import torch
 import numpy as np
+import scipy
 
 from art.attacks.attack import EvasionAttack
 from art.estimators.estimator import BaseEstimator, LossGradientsMixin, NeuralNetworkMixin
@@ -421,6 +421,7 @@ def _forward_1st_stage(
                     - decoded_output: Transcription output.
                     - masked_adv_input: Perturbed inputs.
         """
+        import torch  # lgtm [py/repeated-import]
         from warpctc_pytorch import CTCLoss
 
         # Compute perturbed inputs
@@ -607,7 +608,6 @@ def _compute_masking_threshold(self, x: np.ndarray) -> Tuple[np.ndarray, np.ndar
         :param x: Samples of shape (seq_length,).
         :return: A tuple of the masking threshold and the maximum psd.
         """
-        import scipy
         import librosa
 
         # First compute the psd matrix

art/attacks/inference/membership_inference/black_box.py

@@ -223,7 +223,7 @@ def to_cuda(x):
 
                     optimizer.zero_grad()
                     outputs = self.attack_model(input1, input2)
-                    loss = loss_fn(outputs, targets.unsqueeze(1))
+                    loss = loss_fn(outputs, targets.unsqueeze(1))  # lgtm [py/call-to-non-callable]
 
                     loss.backward()
                     optimizer.step()

art/defences/preprocessor/preprocessor.py

@@ -135,8 +135,6 @@ class PreprocessorPyTorch(Preprocessor):
     Abstract base class for preprocessing defences implemented in PyTorch that support efficient preprocessor-chaining.
     """
 
-    import torch
-
     @abc.abstractmethod
     def forward(
         self, x: "torch.Tensor", y: Optional["torch.Tensor"] = None

art/defences/preprocessor/spatial_smoothing_pytorch.py

@@ -193,7 +193,7 @@ def forward(
             else:
                 #   NHWC <-- NCHW
                 x = x_nchw.permute(0, 2, 3, 1)
-        elif x_ndim == 5:
+        elif x_ndim == 5:  # lgtm [py/redundant-comparison]
             if self.channels_first:
                 # NCFHW <-- NFCHW <-- NCHW
                 x_nfchw = x_nchw.reshape(nb_clips, clip_size, channels, height, width)

art/estimators/certification/neural_cleanse/neural_cleanse.py

@@ -284,7 +284,7 @@ def outlier_detection(self, x_val: np.ndarray, y_val: np.ndarray) -> List[Tuple[
 
         median = np.median(l1_norms)
         mad = consistency_constant * np.median(np.abs(l1_norms - median))
-        min_mad = np.abs(np.min(l1_norms) - median) / mad
+        # min_mad = np.abs(np.min(l1_norms) - median) / mad
         flagged_labels = []
 
         for class_idx in range(num_classes):

art/estimators/object_detection/pytorch_faster_rcnn.py

@@ -84,7 +84,7 @@ def __init__(
         :param device_type: Type of device to be used for model and tensors, if `cpu` run on CPU, if `gpu` run on GPU
                             if available otherwise run on CPU.
         """
-        import torch
+        import torch  # lgtm [py/repeated-import]
 
         # Remove in 1.5.0
         if channel_index == 3:
@@ -149,7 +149,7 @@ def loss_gradient(self, x: np.ndarray, y: List[Dict[str, np.ndarray]], **kwargs)
                   - scores (Tensor[N]): the scores or each prediction.
         :return: Loss gradients of the same shape as `x`.
         """
-        import torch
+        import torch  # lgtm [py/repeated-import]
         import torchvision  # lgtm [py/repeated-import]
 
         self._model.train()

art/estimators/object_detection/tensorflow_faster_rcnn.py

@@ -509,5 +509,5 @@ def fit(self):
     def get_activations(self):
         raise NotImplementedError
 
-    def set_learning_phase(self):
+    def set_learning_phase(self, train: bool) -> None:
         raise NotImplementedError

conftest.py

@@ -197,10 +197,10 @@ def image_iterator(framework, is_tf_version_2, get_default_mnist_subset, default
         return torch.utils.data.DataLoader(dataset=dataset, batch_size=default_batch_size, shuffle=True)
 
     if framework == "mxnet":
-        from mxnet import gluon
+        import mxnet
 
-        dataset = gluon.data.dataset.ArrayDataset(x_train_mnist, y_train_mnist)
-        return gluon.data.DataLoader(dataset, batch_size=5, shuffle=True)
+        dataset = mxnet.gluon.data.dataset.ArrayDataset(x_train_mnist, y_train_mnist)
+        return mxnet.gluon.data.DataLoader(dataset, batch_size=5, shuffle=True)
 
     return None
 
@@ -323,20 +323,20 @@ def _expected_values():
 
 @pytest.fixture(scope="session")
 def get_image_classifier_mx_model():
-    from mxnet.gluon import nn
+    import mxnet
 
     # TODO needs to be made parameterizable once Mxnet allows multiple identical models to be created in one session
     from_logits = True
 
-    class Model(nn.Block):
+    class Model(mxnet.gluon.nn.Block):
         def __init__(self, **kwargs):
             super(Model, self).__init__(**kwargs)
-            self.model = nn.Sequential()
+            self.model = mxnet.gluon.nn.Sequential()
             self.model.add(
-                nn.Conv2D(channels=1, kernel_size=7, activation="relu",),
-                nn.MaxPool2D(pool_size=4, strides=4),
-                nn.Flatten(),
-                nn.Dense(10, activation=None,),
+                mxnet.gluon.nn.Conv2D(channels=1, kernel_size=7, activation="relu",),
+                mxnet.gluon.nn.MaxPool2D(pool_size=4, strides=4),
+                mxnet.gluon.nn.Flatten(),
+                mxnet.gluon.nn.Dense(10, activation=None,),
             )
 
         def forward(self, x):