code: def deepfool_attack(
      sess,
      x,
      predictions,
      logits,
      grads,
      sample,
      nb_candidate,
      overshoot,
      max_iter,
      clip_min,
      clip_max,
      feed=None,
  ):
      """
      TensorFlow implementation of DeepFool.
      Paper link: see https://arxiv.org/pdf/1511.04599.pdf
      :param sess: TF session
      :param x: The input placeholder
      :param predictions: The model's sorted symbolic output of logits, only the
                         top nb_candidate classes are contained
      :param logits: The model's unnormalized output tensor (the input to
                     the softmax layer)
      :param grads: Symbolic gradients of the top nb_candidate classes, procuded
                   from gradient_graph
      :param sample: Numpy array with sample input
      :param nb_candidate: The number of classes to test against, i.e.,
                           deepfool only consider nb_candidate classes when
                           attacking(thus accelerate speed). The nb_candidate
                           classes are chosen according to the prediction
                           confidence during implementation.
      :param overshoot: A termination criterion to prevent vanishing updates
      :param max_iter: Maximum number of iteration for DeepFool
      :param clip_min: Minimum value for components of the example returned
      :param clip_max: Maximum value for components of the example returned
      :return: Adversarial examples
      """
      adv_x = copy.copy(sample)
      # Initialize the loop variables
      iteration = 0
      current = utils_tf.model_argmax(sess, x, logits, adv_x, feed=feed)
      if current.shape == ():
          current = np.array([current])
      w = np.squeeze(
          np.zeros(sample.shape[1:])
      )  # same shape as original image
      r_tot = np.zeros(sample.shape)
      original = current  # use original label as the reference
  
      _logger.debug(
          "Starting DeepFool attack up to %s iterations", max_iter
      )
      # Repeat this main loop until we have achieved misclassification
      while np.any(current == original) and iteration < max_iter:
          if iteration % 5 == 0 and iteration > 0:
              _logger.info(
                  "Attack result at iteration %s is %s",
                  iteration,
                  current,
              )
          gradients = sess.run(grads, feed_dict={x: adv_x})
          predictions_val = sess.run(predictions, feed_dict={x: adv_x})
          for idx in range(sample.shape[0]):
              pert = np.inf
              if current[idx] != original[idx]:
                  continue
              for k in range(1, nb_candidate):
                  w_k = gradients[idx, k, ...] - gradients[idx, 0, ...]
                  f_k = (
                      predictions_val[idx, k] - predictions_val[idx, 0]
                  )
                  # adding value 0.00001 to prevent f_k = 0
                  pert_k = (abs(f_k) + 0.00001) / np.linalg.norm(
                      w_k.flatten()
                  )
                  if pert_k < pert:
                      pert = pert_k
                      w = w_k
              r_i = pert * w / np.linalg.norm(w)
              r_tot[idx, ...] = r_tot[idx, ...] + r_i
  
          adv_x = np.clip(r_tot + sample, clip_min, clip_max)
          current = utils_tf.model_argmax(
              sess, x, logits, adv_x, feed=feed
          )
          if current.shape == ():
              current = np.array([current])
          # Update loop variables
          iteration = iteration + 1
  
      # need more revision, including info like how many succeed
      _logger.info(
          "Attack result at iteration %s is %s", iteration, current
      )
      _logger.info(
          "%s out of %s become adversarial examples at iteration %s",
          sum(current != original),
          sample.shape[0],
          iteration,
      )
      # need to clip this image into the given range
      adv_x = np.clip(
          (1 + overshoot) * r_tot + sample, clip_min, clip_max
      )
      return adv_x
  
file_path: cleverhans/cleverhans_v3.1.0/cleverhans/attacks/deep_fool.py
imports: import copy
  import logging
  import warnings
  import numpy
  import tensorflow
  from cleverhans.attacks.attack import Attack
  from cleverhans.model import Model, wrapper_warning_logits, CallableModelWrapper
  from cleverhans import utils
  from cleverhans import utils_tf
label_desc: Use image node_id 2 for calling a global function with example usage: deepfool_attack(sess, x, predictions, logits, grads, sample, nb_candidate, overshoot, max_iter, clip_min, clip_max, feed) and returns: adv_x