code: def main(use_cuda):
      """
      Advbox example which demonstrate how to use advbox.
      """
      # base marco
      TOTAL_NUM = 100
      IMG_NAME = "image"
      LABEL_NAME = "label"
  
      # parse args
      args = parser.parse_args()
      print_arguments(args)
  
      # parameters from arguments
      class_dim = args.class_dim
      model_name = args.model
      target_class = args.target
      pretrained_model = args.pretrained_model
      image_shape = [int(m) for m in args.image_shape.split(",")]
      if args.log_debug:
          logging.getLogger().setLevel(logging.INFO)
  
      assert model_name in model_list, "{} is not in lists: {}".format(
          args.model, model_list
      )
  
      # model definition
      model = models.__dict__[model_name]()
  
      # declare vars
      image = fluid.layers.data(
          name=IMG_NAME, shape=image_shape, dtype="float32"
      )
      logits = model.net(input=image, class_dim=class_dim)
  
      # clone program and graph for inference
      infer_program = fluid.default_main_program().clone(for_test=True)
  
      image.stop_gradient = False
      label = fluid.layers.data(
          name=LABEL_NAME, shape=[1], dtype="int64"
      )
      cost = fluid.layers.cross_entropy(input=logits, label=label)
      avg_cost = fluid.layers.mean(x=cost)
  
      BATCH_SIZE = 1
      test_reader = paddle.batch(
          reader.test(TEST_LIST, DATA_PATH), batch_size=BATCH_SIZE
      )
      # setup run environment
      enable_gpu = use_cuda and args.use_gpu
      place = fluid.CUDAPlace(0) if enable_gpu else fluid.CPUPlace()
      exe = fluid.Executor(place)
      exe.run(fluid.default_startup_program())
  
      # advbox demo
      m = PaddleModel(
          fluid.default_main_program(),
          IMG_NAME,
          LABEL_NAME,
          logits.name,
          avg_cost.name,
          (0, 1),
          channel_axis=3,
      )
      # Adversarial method: CW
      attack = CW_L2(
          m,
          learning_rate=0.1,
          attack_model=model.conv_net,
          with_gpu=enable_gpu,
          shape=image_shape,
          dim=class_dim,
          confidence_level=0.9,
          multi_clip=True,
      )
      attack_config = {
          "attack_iterations": 50,
          "c_search_step": 10,
          "c_range": (0.01, 100),
          "c_start": 10,
          "targeted": True,
      }
  
      # reload model vars
      if pretrained_model:
  
          def if_exist(var):
              return os.path.exists(
                  os.path.join(pretrained_model, var.name)
              )
  
          fluid.io.load_vars(exe, pretrained_model, predicate=if_exist)
  
      # inference
      pred_label = infer(infer_program, image, logits, place, exe)
      # if only inference ,and exit
      if args.inference:
          exit(0)
  
      print("--------------------adversary-------------------")
      # use test data to generate adversarial examples
      total_count = 0
      fooling_count = 0
      for data in test_reader():
          total_count += 1
          data_img = [data[0][0]]
          filename = data[0][1]
          org_data = data_img[0][0]
          adversary = Adversary(org_data, pred_label[filename])
          # target attack
          if target_class != -1:
              tlabel = target_class
              adversary.set_target(
                  is_targeted_attack=True, target_label=tlabel
              )
  
          adversary = attack(adversary, **attack_config)
  
          if adversary.is_successful():
              fooling_count += 1
              print(
                  "attack success, original_label=%d, adversarial_label=%d, count=%d"
                  % (
                      pred_label[filename],
                      adversary.adversarial_label,
                      total_count,
                  )
              )
              # output original image， adversarial image and difference image
              generation_image(
                  total_count,
                  org_data,
                  pred_label[filename],
                  adversary.adversarial_example,
                  adversary.adversarial_label,
                  "CW",
              )
          else:
              print(
                  "attack failed, original_label=%d, count=%d"
                  % (pred_label[filename], total_count)
              )
  
          if total_count >= TOTAL_NUM:
              print(
                  "[TEST_DATASET]: fooling_count=%d, total_count=%d, fooling_rate=%f"
                  % (
                      fooling_count,
                      total_count,
                      float(fooling_count) / total_count,
                  )
              )
              break
  
      print("cw attack done")
  
file_path: AdvBox/example/imagenet_example_cw.py
imports: from __future__ import print_function
  import sys
  import os
  import numpy
  import logging
  import paddle.fluid
  import paddle
  import models
  import reader
  import argparse
  import functools
  from utility import add_arguments, print_arguments, generation_image
  from adversarialbox.adversary import Adversary
  from adversarialbox.attacks.cw import CW_L2
  from adversarialbox.models.paddle import PaddleModel
label_desc: Use image node_id 2 for calling a global function with example usage: main(use_cuda) and returns: os