Fix LGTM warnings

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

Author: Beat Buesser

art/attacks/evasion/sign_opt.py

@@ -50,7 +50,6 @@
 import time
 
 import numpy as np
-from numpy import integer, linalg as LA
 from tqdm.auto import tqdm
 
 from art.attacks.attack import EvasionAttack
@@ -119,7 +118,7 @@ def __init__(
         :param beta: The tolerance for line search
         :param batch_size: The size of the batch used by the estimator during inference.
         :param verbose: Show detailed information
-        :param eval_perform: Evaluate performnace with Avg. L2 and Success Rate with randomly choosing 100 samples
+        :param eval_perform: Evaluate performance with Avg. L2 and Success Rate with randomly choosing 100 samples
         """
 
         super().__init__(estimator=estimator)
@@ -211,7 +210,7 @@ def generate(self, x: np.ndarray, y: Optional[np.ndarray] = None, **kwargs) -> n
                     y_0=preds[ind],
                 )
             if succeed and self.eval_perform and counter < 100:
-                self.logs[counter] = LA.norm(diff)
+                self.logs[counter] = np.linalg.norm(diff)
                 counter += 1
 
         if self.targeted is False:
@@ -232,14 +231,14 @@ def _fine_grained_binary_search(
         target: Optional[int] = None,
     ) -> Tuple[float, int]:
         """
-        Perform fine grained line search plus binary search for finding a good starting direction
+        Perform fine-grained line search plus binary search for finding a good starting direction
 
         :param x_0: An array with the original input to be attacked.
         :param y_0: Target value.
         :param theta: Initial query direction.
         :param initial_lbd: Previous solution.
         :param current_best: Current best solution.
-        :param target: Target value. If `self.targeted` is true, it presents the targed label. Defaults to None.
+        :param target: Target value. If `self.targeted` is true, it presents the targeted label. Defaults to None.
         :return: Optimal solution for finding starting direction; the number of query performed
         """
         if self.targeted:
@@ -300,7 +299,7 @@ def _fine_grained_binary_search_local(
         nquery = 0
         lbd = initial_lbd
         # For targeted: we want to expand(x1.01) boundary away from targeted dataset
-        # For untargeted, we want to slim(x0.99) the boundary toward the orginal dataset
+        # For untargeted, we want to slim(x0.99) the boundary toward the original dataset
         if (not self._is_label(x_0 + lbd * theta, target) and self.targeted) or (
             self._is_label(x_0 + lbd * theta, y_0) and not self.targeted
         ):
@@ -349,7 +348,7 @@ def _is_label(self, x_0: np.ndarray, label: Optional[int]) -> bool:
         pred_y0 = np.argmax(pred)
         return pred_y0 == label
 
-    def _predict_label(self, x_0: np.ndarray) -> integer:
+    def _predict_label(self, x_0: np.ndarray) -> np.signedinteger:
         """
         Helper method to predict label for x_0
 
@@ -372,7 +371,7 @@ def _sign_grad(
         :param epsilon: A very small smoothing parameter.
         :param theta: Initial query direction.
         :param initial_lbd: Previous solution.
-        :param target: Target value. If `self.targeted` is true, it presents the targed label. Defaults to None.
+        :param target: Target value. If `self.targeted` is true, it presents the targeted label. Defaults to None.
         :return: the sign of gradient
         """
         sign_grad = np.zeros(theta.shape).astype(np.float32)
@@ -383,10 +382,10 @@ def _sign_grad(
             #     A:Randomly sample u1, . . . , uQ from a Gaussian or Uniform distribution;
             u_g = np.random.randn(*theta.shape).astype(np.float32)
             # gaussian
-            u_g /= LA.norm(u_g)
+            u_g /= np.linalg.norm(u_g)
             # function (3) in the paper
             new_theta = theta + epsilon * u_g
-            new_theta /= LA.norm(new_theta)
+            new_theta /= np.linalg.norm(new_theta)
             sign = 1
 
             if self.targeted and self._is_label(x_0 + initial_lbd * new_theta, target):
@@ -414,7 +413,7 @@ def _attack(
 
         :param x_0: An array with the original inputs to be attacked.
         :param y_0: Target value.
-        :param target: Target value. If `self.targeted` is true, it presents the targed label. Defaults to None.
+        :param target: Target value. If `self.targeted` is true, it presents the targeted label. Defaults to None.
         :param x_init: The pool of possible targets for finding initial direction. Only for targeted attack.
         :return: the adversarial sample to x_0
         """
@@ -438,7 +437,7 @@ def _attack(
                     continue
 
                 theta = x_i - x_0
-                initial_lbd = LA.norm(theta).item()  # .item() convert numpy type to python type
+                initial_lbd = np.linalg.norm(theta).item()  # .item() convert numpy type to python type
                 theta /= initial_lbd
                 lbd, count = self._fine_grained_binary_search(x_0, y_0, theta, initial_lbd, g_theta, target)
                 query_count += count
@@ -453,7 +452,7 @@ def _attack(
                 theta = np.random.randn(*x_0.shape).astype(np.float32)  # gaussian distortion
                 # register adv directions
                 if not self._is_label(x_0 + theta, y_0):
-                    initial_lbd = LA.norm(theta).item()  # .item() convert numpy type to python type
+                    initial_lbd = np.linalg.norm(theta).item()  # .item() convert numpy type to python type
                     theta /= initial_lbd  # l2 normalize: theta is normalized
                     # getting smaller g_theta
                     lbd, count = self._fine_grained_binary_search(x_0, y_0, theta, initial_lbd, g_theta)
@@ -463,7 +462,7 @@ def _attack(
                         if self.verbose:
                             print(f"Found distortion {g_theta} with iteration/num_directions={i}/{num_directions}")
 
-        # fail if cannot find a adv direction within `num_directions` Gaussian
+        # fail if it cannot find adv direction within `num_directions` Gaussian
         if g_theta == float("inf"):
             if self.verbose:
                 print("Couldn't find valid initial, failed")
@@ -494,12 +493,12 @@ def _attack(
             ls_count = 0
             min_theta = x_g  # next theta
             min_g2 = g_g  # current g_theta
-            new_theta = np.zeros((0, 0))
+            # new_theta = np.zeros((0, 0))
             for _ in range(15):
                 # Algorithm 1: Sign-OPT attack
                 new_theta = x_g - alpha * sign_gradient
-                new_theta /= LA.norm(new_theta)
-                # Algorithm 1: Sign-OPT attackx
+                new_theta /= np.linalg.norm(new_theta)
+                # Algorithm 1: Sign-OPT attack
                 #     D:Evaluate g(θt) using the same search algorithm in
                 #       Cheng et al. (2019) https://openreview.net/pdf?id=rJlk6iRqKX,
                 #       **Algorithm 1 Compute g(θ) locally**
@@ -512,13 +511,13 @@ def _attack(
                     min_theta = new_theta
                     min_g2 = new_g2
                 else:
-                    break  # meaning alphia is too big, so it needs to be reduced.
+                    break  # meaning alpha is too big, so it needs to be reduced.
 
             if min_g2 >= g_g:  # if the above code failed for the init alpha, we then try to decrease alpha
                 for _ in range(15):
                     alpha = alpha * 0.25
                     new_theta = x_g - alpha * sign_gradient
-                    new_theta /= LA.norm(new_theta)
+                    new_theta /= np.linalg.norm(new_theta)
                     new_g2, count = self._fine_grained_binary_search_local(
                         x_0, y_0, new_theta, target, initial_lbd=min_g2, tol=beta / 500
                     )
@@ -536,7 +535,7 @@ def _attack(
                 if beta < 1e-8:
                     break
 
-            # if all attemps failed, min_theta, min_g2 will be the current theta (i.e. not moving)
+            # if all attempts failed, min_theta, min_g2 will be the current theta (i.e. not moving)
             x_g, g_g = min_theta, min_g2
 
             query_count += grad_queries + ls_count
@@ -581,7 +580,7 @@ def _clip_value(self, x_0: np.ndarray) -> np.ndarray:
         """
         Apply clipping to input array
 
-        :param x_0: An array to be clippd
+        :param x_0: An array to be clipped
         :return: The array after clipping if clipping is enabled
         """
         if self.enable_clipped:

art/attacks/poisoning/sleeper_agent_attack.py

@@ -283,14 +283,12 @@ def create_model(
         :param epochs: The number of epochs for which training need to be applied.
         :return model, loss_fn, optimizer - trained model, loss function used to train the model and optimizer used.
         """
-        import torch
-        from torch import nn
-        from torch.utils.data import TensorDataset, DataLoader
+        import torch  # lgtm [py/repeated-import]
         import torchvision
 
-        device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
+        device = self.estimator.device
         model = torchvision.models.ResNet(torchvision.models.resnet.BasicBlock, [2, 2, 2, 2], num_classes=num_classes)
-        loss_fn = nn.CrossEntropyLoss()
+        loss_fn = torch.nn.CrossEntropyLoss()
         optimizer = torch.optim.SGD(model.parameters(), lr=0.1, momentum=0.9, weight_decay=5e-4, nesterov=True)
         model.to(device)
         y_train = np.argmax(y_train, axis=1)
@@ -301,11 +299,11 @@ def create_model(
         x_tensor_test = torch.tensor(x_test, dtype=torch.float32, device=device)  # transform to torch tensor
         y_tensor_test = torch.tensor(y_test, dtype=torch.long, device=device)
 
-        dataset_train = TensorDataset(x_tensor, y_tensor)  # create your datset
-        dataloader_train = DataLoader(dataset_train, batch_size=batch_size)
+        dataset_train = torch.utils.data.TensorDataset(x_tensor, y_tensor)  # create your dataset
+        dataloader_train = torch.utils.data.DataLoader(dataset_train, batch_size=batch_size)
 
-        dataset_test = TensorDataset(x_tensor_test, y_tensor_test)  # create your datset
-        dataloader_test = DataLoader(dataset_test, batch_size=batch_size)
+        dataset_test = torch.utils.data.TensorDataset(x_tensor_test, y_tensor_test)  # create your dataset
+        dataloader_test = torch.utils.data.DataLoader(dataset_test, batch_size=batch_size)
 
         for epoch in trange(epochs):
             running_loss = 0.0
@@ -325,9 +323,9 @@ def create_model(
                 running_loss += loss.item()
             if (epoch % 5 == 0) or epoch == (epochs - 1):
                 train_accuracy = 100 * accuracy / total
-                print("Epoch {} train accuracy: {}".format(epoch, train_accuracy))  # pylint: disable=C0209
+                logger.info("Epoch %d train accuracy: %f", epoch, train_accuracy)
         test_accuracy = self.test_accuracy(model, dataloader_test)
-        print("Final test accuracy: {}".format(test_accuracy))  # pylint: disable=C0209
+        logger.info("Final test accuracy: %f", test_accuracy)
         return model, loss_fn, optimizer
 
     @classmethod
@@ -338,7 +336,7 @@ def test_accuracy(cls, model: "torch.nn.Module", test_loader: "torch.utils.data.
         :param model: Trained model.
         :return accuracy - accuracy of trained model on test data.
         """
-        import torch
+        import torch  # lgtm [py/repeated-import]
 
         model_was_training = model.training
         model.eval()
@@ -375,9 +373,13 @@ def select_poison_indices(
         :num_poison: Number of poisoned samples to be selected out of all x_samples.
         :return indices - Indices of samples to be poisoned.
         """
-        import torch
+        import torch  # lgtm [py/repeated-import]
+        from art.estimators.classification.pytorch import PyTorchClassifier
 
-        device = "cuda" if torch.cuda.is_available() else "cpu"
+        if isinstance(classifier, PyTorchClassifier):
+            device = classifier.device
+        else:
+            raise ValueError("Classifier is not of type PyTorchClassifier.")
         grad_norms = []
         criterion = torch.nn.CrossEntropyLoss()
         model = classifier.model

tests/attacks/evasion/test_sign_opt.py

@@ -72,9 +72,10 @@ def test_images(
         classifier = image_dl_estimator_for_attack(SignOPTAttack)
 
         if targeted:
-            attack = SignOPTAttack(
-                estimator=classifier, targeted=targeted, max_iter=2000, query_limit=14000, verbose=True
-            )
+            pass
+            # attack = SignOPTAttack(
+            #     estimator=classifier, targeted=targeted, max_iter=2000, query_limit=14000, verbose=True
+            # )
             # backend_targeted_images(attack, fix_get_mnist_subset_large)
         else:
             attack = SignOPTAttack(

tests/estimators/object_detection/test_pytorch_yolo.py

@@ -33,7 +33,6 @@ def get_pytorch_yolo(get_default_cifar10_subset):
     This class tests the PyTorchYolo object detector.
     """
     import cv2
-    import numpy as np
     import torch
 
     from pytorchyolo import models
@@ -71,7 +70,6 @@ def forward(self, x, targets=None):
     n_test = 10
     (_, _), (x_test_cifar10, y_test_cifar10) = get_default_cifar10_subset
     x_test_cifar10 = x_test_cifar10[0:n_test]
-    y_test_cifar10 = y_test_cifar10[0:n_test]
 
     x_test = cv2.resize(
         x_test_cifar10[0].transpose((1, 2, 0)), dsize=(416, 416), interpolation=cv2.INTER_CUBIC