code: def attack_stage2(
      self,
      audios,
      trans,
      adv,
      rescales,
      maxlen,
      sample_rate,
      masks,
      masks_freq,
      num_loop,
      data,
      lengths,
  ):
      sess = self.sess
      # initialize and load the pretrained model
      sess.run(tf.initializers.global_variables())
      saver = tf.train.Saver(
          [
              x
              for x in tf.global_variables()
              if x.name.startswith("librispeech")
          ]
      )
      saver.restore(sess, FLAGS.checkpoint)
  
      # reassign the variables
      sess.run(tf.assign(self.delta_large, adv))
      sess.run(tf.assign(self.rescale, rescales))
  
      noise = np.zeros(audios.shape)
      rir = Readrir()
      feed_dict = {
          self.input_tf: audios,
          self.tgt_tf: trans,
          self.sample_rate_tf: sample_rate,
          self.mask: masks,
          self.mask_freq: masks_freq,
          self.noise: noise,
          self.maxlen: maxlen,
          self.lengths: lengths,
          self.rir: rir,
          self.lr: self.lr_stage2,
      }
      losses, predictions = sess.run(
          (self.celoss, self.decoded), feed_dict
      )
  
      # show the initial predictions
      for i in range(self.batch_size):
          print(
              "example: {}, loss: {}".format(
                  num_loop * self.batch_size + i, losses[i]
              )
          )
          print("pred:{}".format(predictions["topk_decoded"][i, 0]))
          print("targ:{}".format(trans[i].lower()))
          print("true: {}".format(data[1, i].lower()))
  
      # We'll make a bunch of iterations of gradient descent here
      now = time.time()
      MAX = self.num_iter_stage2
      loss_th = [np.inf] * self.batch_size
      final_adv = [None] * self.batch_size
      final_perturb = [None] * self.batch_size
      num_counters = [FLAGS.num_counter] * self.batch_size
      num_rooms = [FLAGS.num_rooms] * self.batch_size
      clock = 0
  
      for i in range(1, MAX + 1):
          now = time.time()
  
          rir = Readrir()
          feed_dict = {
              self.input_tf: audios,
              self.tgt_tf: trans,
              self.sample_rate_tf: sample_rate,
              self.mask: masks,
              self.mask_freq: masks_freq,
              self.noise: noise,
              self.maxlen: maxlen,
              self.lengths: lengths,
              self.rir: rir,
              self.lr: self.lr_stage2,
          }
          losses, predictions = sess.run(
              (self.celoss, self.decoded), feed_dict
          )
  
          # Actually do the optimization
          sess.run(self.train1, feed_dict)
          if i % 10 == 0:
              d, apply_delta, cl, predictions, new_input = sess.run(
                  (
                      self.delta,
                      self.apply_delta,
                      self.celoss,
                      self.decoded,
                      self.new_input,
                  ),
                  feed_dict,
              )
  
          for ii in range(self.batch_size):
              if i % 100 == 0:
                  print(
                      "example: {}".format(
                          num_loop * self.batch_size + ii
                      )
                  )
                  print("iteration: {}. loss {}".format(i, cl[ii]))
                  print(
                      "pred:{}".format(
                          predictions["topk_decoded"][ii, 0]
                      )
                  )
                  print("targ:{}".format(trans[ii].lower()))
  
              sum_counter = 0
              if i % 10 == 0:
                  for counter in range(num_rooms[ii]):
                      if (
                          predictions["topk_decoded"][ii, 0]
                          == trans[ii].lower()
                      ):
                          sum_counter += 1
                          print(
                              "succeed %d times for example %d"
                              % (sum_counter, ii)
                          )
                          rir = Readrir()
                          feed_dict = {
                              self.input_tf: audios,
                              self.tgt_tf: trans,
                              self.sample_rate_tf: sample_rate,
                              self.mask: masks,
                              self.mask_freq: masks_freq,
                              self.noise: noise,
                              self.maxlen: maxlen,
                              self.lengths: lengths,
                              self.rir: rir,
                              self.lr: self.lr_stage2,
                          }
                          predictions = sess.run(
                              self.decoded, feed_dict
                          )
  
                      if sum_counter == num_counters[ii]:
                          print(
                              "-------------------------------True--------------------------"
                          )
                          print(
                              " The num_counter is %d for example %d"
                              % (num_counters[ii], ii)
                          )
                          num_counters[ii] += 1
                          if num_counters[ii] > num_rooms[ii]:
                              num_rooms[ii] += 1
                          # save the best adversarial example
                          final_adv[ii] = new_input[ii]
                          final_perturb[ii] = apply_delta[ii]
                          print(
                              "Stage 2: save the example at iteration i=%d example ii=%d celoss=%f"
                              % (i, ii, cl[ii])
                          )
  
              # in case no final_delta return
              if i == MAX - 1 and final_adv[ii] is None:
                  final_adv[ii] = new_input[ii]
                  final_perturb[ii] = apply_delta[ii]
  
          if i % 10 == 0:
              print("ten iterations take around {} ".format(clock))
              clock = 0
          clock += time.time() - now
  
      return final_adv, final_perturb
  
file_path: cleverhans/cleverhans_v3.1.0/examples/adversarial_asr/generate_robust_adv.py
imports: import tensorflow
  from lingvo import model_imports
  from lingvo import model_registry
  import numpy
  import scipy.io.wavfile
  import generate_masking_threshold
  from tool import create_features, create_inputs, create_speech_rir
  import time
  from lingvo.core import cluster_factory
  from absl import flags
  from absl import app
  import random
label_desc: Use image node_id 3 for calling the Attack obj's underlying member method code with example usage: obj.attack_stage2(audios, trans, adv, rescales, maxlen, sample_rate, masks, masks_freq, num_loop, data, lengths) and returns: final_adv,  final_perturb