class_docstr: This attack was originally implemented by Goodfellow et al. (2015) with the infinity norm (and is known as the "Fast
  Gradient Sign Method"). This implementation extends the attack to other norms, and is therefore called the Fast
  Gradient Method.
  
  | Paper link: https://arxiv.org/abs/1412.6572
class_docstr_tok: ["This","attack","was","originally","implemented","by","Goodfellow","et","al",".","(","2015",")","with","the","infinity","norm","(","and","is","known","as","the","``","Fast","Gradient","Sign","Method","''",")",".","This","implementation","extends","the","attack","to","other","norms",",","and","is","therefore","called","the","Fast","Gradient","Method",".","|","Paper","link",":","https",":","\/\/arxiv.org\/abs\/1412.6572"]
docstr: Generate adversarial samples and return them in an array.
  
  :param x: An array with the original inputs.
  :param y: Target values (class labels) one-hot-encoded of shape (nb_samples, nb_classes) or indices of shape
            (nb_samples,). Only provide this parameter if you'd like to use true labels when crafting adversarial
            samples. Otherwise, model predictions are used as labels to avoid the "label leaking" effect
            (explained in this paper: https://arxiv.org/abs/1611.01236). Default is `None`.
  :param mask: An array with a mask broadcastable to input `x` defining where to apply adversarial perturbations.
               Shape needs to be broadcastable to the shape of x and can also be of the same shape as `x`. Any
               features for which the mask is zero will not be adversarially perturbed.
  :type mask: `np.ndarray`
  :return: An array holding the adversarial examples.
docstr_tok: ["Generate","adversarial","samples","and","return","them","in","an","array",".",":","param","x",":","An","array","with","the","original","inputs",".",":","param","y",":","Target","values","(","class","labels",")","one-hot-encoded","of","shape","(","nb_samples",",","nb_classes",")","or","indices","of","shape","(","nb_samples",",",")",".","Only","provide","this","parameter","if","you","'d","like","to","use","true","labels","when","crafting","adversarial","samples",".","Otherwise",",","model","predictions","are","used","as","labels","to","avoid","the","``","label","leaking","''","effect","(","explained","in","this","paper",":","https",":","\/\/arxiv.org\/abs\/1611.01236",")",".","Default","is","`","None","`",".",":","param","mask",":","An","array","with","a","mask","broadcastable","to","input","`","x","`","defining","where","to","apply","adversarial","perturbations",".","Shape","needs","to","be","broadcastable","to","the","shape","of","x","and","can","also","be","of","the","same","shape","as","`","x","`",".","Any","features","for","which","the","mask","is","zero","will","not","be","adversarially","perturbed",".",":","type","mask",":","`","np.ndarray","`",":","return",":","An","array","holding","the","adversarial","examples","."]
code: def generate(
      self, x: np.ndarray, y: Optional[np.ndarray] = None, **kwargs
  ) -> np.ndarray:
      """Generate adversarial samples and return them in an array.
  
      :param x: An array with the original inputs.
      :param y: Target values (class labels) one-hot-encoded of shape (nb_samples, nb_classes) or indices of shape
                (nb_samples,). Only provide this parameter if you'd like to use true labels when crafting adversarial
                samples. Otherwise, model predictions are used as labels to avoid the "label leaking" effect
                (explained in this paper: https://arxiv.org/abs/1611.01236). Default is `None`.
      :param mask: An array with a mask broadcastable to input `x` defining where to apply adversarial perturbations.
                   Shape needs to be broadcastable to the shape of x and can also be of the same shape as `x`. Any
                   features for which the mask is zero will not be adversarially perturbed.
      :type mask: `np.ndarray`
      :return: An array holding the adversarial examples.
      """
      mask = self._get_mask(x, **kwargs)
  
      # Ensure eps is broadcastable
      self._check_compatibility_input_and_eps(x=x)
  
      if isinstance(self.estimator, ClassifierMixin):
          if y is not None:
              y = check_and_transform_label_format(
                  y, nb_classes=self.estimator.nb_classes
              )
  
          if y is None:
              # Throw error if attack is targeted, but no targets are provided
              if self.targeted:  # pragma: no cover
                  raise ValueError(
                      "Target labels `y` need to be provided for a targeted attack."
                  )
  
              # Use model predictions as correct outputs
              logger.info(
                  "Using model predictions as correct labels for FGM."
              )
              y_array = get_labels_np_array(self.estimator.predict(x, batch_size=self.batch_size))  # type: ignore
          else:
              y_array = y
  
          if self.estimator.nb_classes > 2:
              y_array = y_array / np.sum(y_array, axis=1, keepdims=True)
  
          # Return adversarial examples computed with minimal perturbation if option is active
          adv_x_best = x
          if self.minimal:
              logger.info("Performing minimal perturbation FGM.")
              adv_x_best = self._minimal_perturbation(x, y_array, mask)
              rate_best = 100 * compute_success(
                  self.estimator,  # type: ignore
                  x,
                  y_array,
                  adv_x_best,
                  self.targeted,
                  batch_size=self.batch_size,  # type: ignore
              )
          else:
              rate_best = 0.0
              for _ in range(max(1, self.num_random_init)):
                  adv_x = self._compute(
                      x,
                      x,
                      y_array,
                      mask,
                      self.eps,
                      self.eps,
                      self._project,
                      self.num_random_init > 0,
                  )
  
                  if self.num_random_init > 1:
                      rate = 100 * compute_success(
                          self.estimator,  # type: ignore
                          x,
                          y_array,
                          adv_x,
                          self.targeted,
                          batch_size=self.batch_size,  # type: ignore
                      )
                      if rate > rate_best:
                          rate_best = rate
                          adv_x_best = adv_x
                  else:
                      adv_x_best = adv_x
  
          logger.info(
              "Success rate of FGM attack: %.2f%%",
              rate_best
              if rate_best is not None
              else 100
              * compute_success(
                  self.estimator,  # type: ignore
                  x,
                  y_array,
                  adv_x_best,
                  self.targeted,
                  batch_size=self.batch_size,
              ),
          )
  
      else:
          if self.minimal:  # pragma: no cover
              raise ValueError(
                  "Minimal perturbation is only supported for classification."
              )
  
          if y is None:
              # Throw error if attack is targeted, but no targets are provided
              if self.targeted:  # pragma: no cover
                  raise ValueError(
                      "Target labels `y` need to be provided for a targeted attack."
                  )
  
              # Use model predictions as correct outputs
              logger.info(
                  "Using model predictions as correct labels for FGM."
              )
              y_array = self.estimator.predict(
                  x, batch_size=self.batch_size
              )
          else:
              y_array = y
  
          adv_x_best = self._compute(
              x,
              x,
              y_array,
              None,
              self.eps,
              self.eps,
              self._project,
              self.num_random_init > 0,
          )
  
      if self.summary_writer is not None:
          self.summary_writer.reset()
  
      return adv_x_best
  
imports: from __future__ import absolute_import, division, print_function, unicode_literals
  import logging
  from typing import Optional, Union, TYPE_CHECKING
  import numpy
  from art.config import ART_NUMPY_DTYPE
  from art.attacks.attack import EvasionAttack
  from art.estimators.estimator import BaseEstimator, LossGradientsMixin
  from art.estimators.classification.classifier import ClassifierMixin
  from art.utils import compute_success, get_labels_np_array, random_sphere, projection, check_and_transform_label_format
  from art.summary_writer import SummaryWriter
label_desc: Use image node_id 4 for calling the FastGradientMethod obj's underlying member method code with example usage: obj.generate(x, y) and returns: adv_x_best