code: def saliency_map(grads_target, grads_other, search_domain, increase):
      """
      TensorFlow implementation for computing saliency maps
      :param grads_target: a matrix containing forward derivatives for the
                           target class
      :param grads_other: a matrix where every element is the sum of forward
                          derivatives over all non-target classes at that index
      :param search_domain: the set of input indices that we are considering
      :param increase: boolean; true if we are increasing pixels, false otherwise
      :return: (i, j, search_domain) the two input indices selected and the
               updated search domain
      """
      warnings.warn(
          "This function is dead code and will be removed on or after 2019-07-18"
      )
  
      # Compute the size of the input (the number of features)
      nf = len(grads_target)
  
      # Remove the already-used input features from the search space
      invalid = list(set(range(nf)) - search_domain)
      increase_coef = 2 * int(increase) - 1
      grads_target[invalid] = -increase_coef * np.max(
          np.abs(grads_target)
      )
      grads_other[invalid] = increase_coef * np.max(np.abs(grads_other))
  
      # Create a 2D numpy array of the sum of grads_target and grads_other
      target_sum = grads_target.reshape((1, nf)) + grads_target.reshape(
          (nf, 1)
      )
      other_sum = grads_other.reshape((1, nf)) + grads_other.reshape(
          (nf, 1)
      )
  
      # Create a mask to only keep features that match saliency map conditions
      if increase:
          scores_mask = (target_sum > 0) & (other_sum < 0)
      else:
          scores_mask = (target_sum < 0) & (other_sum > 0)
  
      # Create a 2D numpy array of the scores for each pair of candidate features
      scores = scores_mask * (-target_sum * other_sum)
  
      # A pixel can only be selected (and changed) once
      np.fill_diagonal(scores, 0)
  
      # Extract the best two pixels
      best = np.argmax(scores)
      p1, p2 = best % nf, best // nf
  
      # Remove used pixels from our search domain
      search_domain.discard(p1)
      search_domain.discard(p2)
  
      return p1, p2, search_domain
  
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 4 for calling a global function with example usage: saliency_map(grads_target, grads_other, search_domain, increase) and returns: p1,  p2,  search_domain