code: def jacobian(
      sess, x, grads, target, X, nb_features, nb_classes, feed=None
  ):
      """
      TensorFlow implementation of the foward derivative / Jacobian
      :param x: the input placeholder
      :param grads: the list of TF gradients returned by jacobian_graph()
      :param target: the target misclassification class
      :param X: numpy array with sample input
      :param nb_features: the number of features in the input
      :return: matrix of forward derivatives flattened into vectors
      """
      warnings.warn(
          "This function is dead code and will be removed on or after 2019-07-18"
      )
  
      # Prepare feeding dictionary for all gradient computations
      feed_dict = {x: X}
      if feed is not None:
          feed_dict.update(feed)
  
      # Initialize a numpy array to hold the Jacobian component values
      jacobian_val = np.zeros((nb_classes, nb_features), dtype=np_dtype)
  
      # Compute the gradients for all classes
      for class_ind, grad in enumerate(grads):
          run_grad = sess.run(grad, feed_dict)
          jacobian_val[class_ind] = np.reshape(
              run_grad, (1, nb_features)
          )
  
      # Sum over all classes different from the target class to prepare for
      # saliency map computation in the next step of the attack
      other_classes = utils.other_classes(nb_classes, target)
      grad_others = np.sum(jacobian_val[other_classes, :], axis=0)
  
      return jacobian_val[target], grad_others
  
imports: from __future__ import absolute_import
  from __future__ import division
  from __future__ import print_function
  from __future__ import unicode_literals
  import warnings
  import numpy
  from cleverhans.attacks.carlini_wagner_l2 import CWL2
  from cleverhans.attacks.deep_fool import deepfool_batch, deepfool_attack
  from cleverhans.attacks.elastic_net_method import EAD
  from cleverhans.attacks.lbfgs import LBFGS_impl
  from cleverhans.attacks.saliency_map_method import jsma_symbolic
  from cleverhans.attacks.spsa import TensorOptimizer, TensorGradientDescent, TensorAdam
  from cleverhans.attacks.spsa import SPSAAdam, margin_logit_loss, _apply_black_border
  from cleverhans.attacks.spsa import _apply_transformation, spm, parallel_apply_transformations
  from cleverhans.attacks.virtual_adversarial_method import vatm
  from cleverhans.utils_tf import jacobian_graph, jacobian_augmentation
  from cleverhans import utils
label_desc: Use image node_id 5 for calling a global function with example usage: jacobian(sess, x, grads, target, X, nb_features, nb_classes, feed) and returns: jacobian_val,  grad_others