code: def spm(
      x,
      model,
      y=None,
      n_samples=None,
      dx_min=-0.1,
      dx_max=0.1,
      n_dxs=5,
      dy_min=-0.1,
      dy_max=0.1,
      n_dys=5,
      angle_min=-30,
      angle_max=30,
      n_angles=31,
      black_border_size=0,
  ):
      """
      TensorFlow implementation of the Spatial Transformation Method.
      :return: a tensor for the adversarial example
      """
      if y is None:
          preds = model.get_probs(x)
          # Using model predictions as ground truth to avoid label leaking
          preds_max = reduce_max(preds, 1, keepdims=True)
          y = tf.to_float(tf.equal(preds, preds_max))
          y = tf.stop_gradient(y)
          del preds
      y = y / reduce_sum(y, 1, keepdims=True)
  
      # Define the range of transformations
      dxs = np.linspace(dx_min, dx_max, n_dxs)
      dys = np.linspace(dy_min, dy_max, n_dys)
      angles = np.linspace(angle_min, angle_max, n_angles)
  
      if n_samples is None:
          import itertools
  
          transforms = list(itertools.product(*[dxs, dys, angles]))
      else:
          sampled_dxs = np.random.choice(dxs, n_samples)
          sampled_dys = np.random.choice(dys, n_samples)
          sampled_angles = np.random.choice(angles, n_samples)
          transforms = zip(sampled_dxs, sampled_dys, sampled_angles)
      transformed_ims = parallel_apply_transformations(
          x, transforms, black_border_size
      )
  
      def _compute_xent(x):
          preds = model.get_logits(x)
          return tf.nn.softmax_cross_entropy_with_logits_v2(
              labels=y, logits=preds
          )
  
      all_xents = tf.map_fn(
          _compute_xent, transformed_ims, parallel_iterations=1
      )  # Must be 1 to avoid keras race conditions
  
      # Return the adv_x with worst accuracy
  
      # all_xents is n_total_samples x batch_size (SB)
      all_xents = tf.stack(all_xents)  # SB
  
      # We want the worst case sample, with the largest xent_loss
      worst_sample_idx = tf.argmax(all_xents, axis=0)  # B
  
      batch_size = tf.shape(x)[0]
      keys = tf.stack(
          [
              tf.range(batch_size, dtype=tf.int32),
              tf.cast(worst_sample_idx, tf.int32),
          ],
          axis=1,
      )
      transformed_ims_bshwc = tf.einsum("sbhwc->bshwc", transformed_ims)
      after_lookup = tf.gather_nd(transformed_ims_bshwc, keys)  # BHWC
      return after_lookup
  
imports: import warnings
  import numpy
  from six.moves import xrange
  import tensorflow
  import tensorflow_addons
  from cleverhans.attacks.attack import Attack
  from cleverhans.compat import reduce_mean, reduce_sum, reduce_max
  from cleverhans.model import Model
  from cleverhans import utils_tf
label_desc: Use image node_id 5 for calling a global function with example usage: spm(x, model, y, n_samples, dx_min, dx_max, n_dxs, dy_min, dy_max, n_dys, angle_min, angle_max, n_angles, black_border_size) and returns: after_lookup, tf