#!/usr/bin/env python3 """ run_det_attacks.py Usage example: python run_det_attacks.py \ --weights /mnt/data/.../best.pt \ --source jjs_tmp/clean/images \ --out jjs_tmp/adv \ --methods FGSM,PGD \ --eps 8/255 \ --batch 4 \ --img-size 640 \ --device 0 \ --main_exec /abs/path/to/main \ --run_clean_main Notes: - This script uses function.attack.attack_api_det.DetectionEvasionAttacker.generate(...) to generate adversarial images. That function must support save_path and preserve format/size (we assume you've applied the modifications so save_path will save adv images with the same ext & size as the original). - For each method, adv images are saved under: OUT//images/ - After generation, the script symlinks or copies your provided main executable into OUT//main and runs it in that directory (so it will create OUT//result or results with txt files). """ import argparse import os import sys import time import shutil import subprocess from pathlib import Path import json # third-party import torch import numpy as np from PIL import Image # Import the detection attack API (make sure your PYTHONPATH includes project root) try: from function.attack.attack_api_det import DetectionEvasionAttacker except Exception as e: print("ERROR: cannot import DetectionEvasionAttacker from function.attack.attack_api_det:", e) raise # ----------------------- # Utilities # ----------------------- def safe_load_model(weights_path: str, map_location='cpu'): """ Safe loading: try to use torch.load fallback to load saved checkpoint. If the checkpoint contains 'model' as nn.Module, return it. If checkpoint is a state_dict only, raise informative error (user must use attempt_load) """ weights_path = str(weights_path) if not os.path.exists(weights_path): raise FileNotFoundError("Weights not found: " + weights_path) ck = torch.load(weights_path, map_location=map_location) # If the checkpoint is itself an nn.Module (rare), return it if isinstance(ck, torch.nn.Module): print("[safe_load_model] loaded nn.Module directly from checkpoint.") return ck # If it's dict and contains 'model' as nn.Module if isinstance(ck, dict): if 'model' in ck and isinstance(ck['model'], torch.nn.Module): print("[safe_load_model] checkpoint contains 'model' as nn.Module - using it.") return ck['model'] if 'state_dict' in ck: # state_dict only; cannot reconstruct architecture here raise RuntimeError("Checkpoint appears to be 'state_dict' only. Please ensure you can build the model architecture (yolov7 attempt_load) or provide checkpoint containing nn.Module under 'model'.") raise RuntimeError(f"Unknown checkpoint format: {type(ck)}. Consider using yolov7 attempt_load in your env.") def make_symlink_or_copy(src: str, dst: str): src = str(src); dst = str(dst) try: if os.path.exists(dst): return os.symlink(src, dst) except Exception: # fallback to copy shutil.copy(src, dst) os.chmod(dst, 0o755) def run_main_in_dir(main_exec: str, cwd: str, timeout: int = 300): """ Run './main' in cwd (expects main_exec to be a file to copy or symlink into cwd as 'main'). Return dict with rc, stdout, stderr. """ # Ensure the exec exists in cwd tgt = Path(cwd) / "main" if not tgt.exists(): raise FileNotFoundError(f"Expected main at {tgt} but not found. Ensure script installed main into method folder before calling run_main_in_dir.") try: proc = subprocess.run(["./main", "images/"], cwd=str(cwd), stdout=subprocess.PIPE, stderr=subprocess.PIPE, timeout=timeout) return {"rc": proc.returncode, "stdout": proc.stdout.decode('utf8', errors='ignore'), "stderr": proc.stderr.decode('utf8', errors='ignore')} except subprocess.TimeoutExpired as e: return {"rc": -1, "stdout": "", "stderr": f"Timeout after {timeout}s"} except Exception as e: return {"rc": -1, "stdout": "", "stderr": str(e)} # ----------------------- # Main CLI # ----------------------- def parse_args(): p = argparse.ArgumentParser() p.add_argument('--weights', required=True, help='path to yolov7 weights (checkpoint).') p.add_argument('--source', required=True, help='directory with clean images (images/). Usually jjs_tmp/clean/images') p.add_argument('--out', required=True, help='output adv root. For each method we will create OUT//images/') p.add_argument('--methods', help='comma-separated methods to run (FGSM,PGD,...). Must match attack_api_det methods.') p.add_argument('--eps', default='8/255', help='epsilon for attacks (specify like 8/255 or 0.0313725).') p.add_argument('--batch', type=int, default=4, help='batch size for generation') p.add_argument('--img-size', type=int, default=640, help='img size used in attacker (letterbox).') p.add_argument('--device', default='0', help='cuda device id or "cpu"') p.add_argument('--nc', type=int, default=5, help='number of classes (your dataset).') p.add_argument('--main_exec', default='./main', help='path to closed-source main executable used by the system.') p.add_argument('--run_clean_main', action='store_true', help='if set, run ./main in the clean folder to produce baseline results.') p.add_argument('--timeout_main', type=int, default=300, help='timeout seconds for each ./main run in method dir.') p.add_argument('--no_copy_main', action='store_true', help='if set do not copy/symlink main into method dir (assume it already exists).') # New Arguments for sample count and method-specific config p.add_argument('--n-samples', type=int, default=50, help='number of images to attack (required)') p.add_argument('--method-config', default=None, help='JSON string or path to JSON file mapping method names to kwargs, e.g. \'{"FGSM":{"eps":0.03},"PGD":{"eps":0.03,"alpha":0.01,"iters":40}}\'') return p.parse_args() def parse_eps(eps_str): # support "8/255" or float strings try: if '/' in eps_str: a,b = eps_str.split('/') return float(a)/float(b) return float(eps_str) except: return float(eps_str) def main(): args = parse_args() device_str = args.device device = 'cpu' if device_str.lower() == 'cpu' else f'cuda:{int(device_str)}' outroot = Path(args.out) source_images = Path(args.source) main_exec_path = Path(args.main_exec).resolve() if not source_images.exists(): raise SystemExit(f"Source images directory not found: {source_images}") methods = [m.strip() for m in args.methods.split(',') if m.strip()] eps = parse_eps(args.eps) print("[run_det_attacks] device:", device) print("[run_det_attacks] methods:", methods) print("[run_det_attacks] source_images:", source_images) print("[run_det_attacks] outroot:", outroot) print("[run_det_attacks] main_exec (abs):", main_exec_path) # 1) load model (safe) print("[run_det_attacks] Loading model checkpoint (torch.load fallback)...") try: model = safe_load_model(args.weights, map_location=device) except Exception as e: print("Failed to load model via safe_load_model():", e) raise # ensure model float and on device try: model = model.to(device) model = model.float() except Exception as e: print("Warning: failed to cast model to float/device:", e) # 2) instantiate attacker print("[run_det_attacks] Instantiating DetectionEvasionAttacker...") attacker = DetectionEvasionAttacker(model=model, device=device, nc=args.nc, img_size=args.img_size, verbose=True) # 3) image list img_paths = sorted([str(p) for p in source_images.glob('*') if p.suffix.lower() in ('.jpg','.jpeg','.png')]) if not img_paths: raise SystemExit("No images found in source images folder: " + str(source_images)) # 4) require n_samples if args.n_samples <= 0: raise SystemExit("--n-samples must be > 0") img_paths = img_paths[: args.n_samples] print(f"[run_det_attacks] attacking {len(img_paths)} images (n-samples={args.n_samples})") # 5) for each method, generate advs into outroot//images and then run ./main there method_cfg = {} if args.method_config: try: if os.path.exists(args.method_config): with open(args.method_config, 'r', encoding='utf-8') as f: method_cfg = json.load(f) else: method_cfg = json.loads(args.method_config) except Exception as e: raise SystemExit(f"Failed to parse --method-config: {e}") method_cfg = {k.upper(): v for k, v in method_cfg.items()} for method in methods: print(f"\n[run_det_attacks] Running method: {method}") method_images_dir = outroot / method / 'images' method_images_dir.mkdir(parents=True, exist_ok=True) # 确保 main 文件在 method 文件夹中 method_root = outroot / method method_main_path = method_root / "main" clean_main_path = Path("main") if not method_main_path.exists(): try: # 复制 main 文件 shutil.copy(str(clean_main_path), str(method_main_path)) method_main_path.chmod(0o755) # 设置为可执行 print(f"[run_det_attacks] Copied 'main' into method folder: {method_main_path}") except Exception as e: print(f"[run_det_attacks] Failed to copy main into {method_root}: {e}") # method-specific kwargs (from config) method_key = method.upper() method_kwargs = method_cfg.get(method_key, {}) if method_cfg else {} print(f"[run_det_attacks] Generating adversarials to: {method_images_dir}") try: adv_np, _, saved_paths = attacker.generate( method=method, img_paths=img_paths, source_folder=None, save_path=str(method_images_dir), batch=args.batch, img_size=args.img_size, **method_kwargs ) print(f"[run_det_attacks] attacker.generate returned adv_np.shape {getattr(adv_np,'shape',None)} and saved {len(saved_paths)} files") except Exception as e: print(f"[run_det_attacks] ERROR: attacker.generate failed for method {method}: {e}") continue # ensure the method root has main executable (copy or symlink) method_root = outroot / method try: if not args.no_copy_main: tgt = method_root / "main" if not tgt.exists(): make_symlink_or_copy(str(main_exec_path), str(tgt)) tgt.chmod(0o755) print(f"[run_det_attacks] Installed main into method folder: {tgt}") except Exception as e: print("[run_det_attacks] Warning: failed to install main into method folder:", e) # run ./main inside method_root print(f"[run_det_attacks] Running ./main in {method_root} to produce results (result/txt)...") try: rc_info = run_main_in_dir(str(main_exec_path), str(method_root), timeout=args.timeout_main) print(f"[run_det_attacks] main rc: {rc_info['rc']}") if rc_info['stderr']: print("[run_det_attacks] main stderr (truncated):", rc_info['stderr'][:800]) if rc_info['stdout']: print("[run_det_attacks] main stdout (truncated):", rc_info['stdout'][:800]) except Exception as e: print("[run_det_attacks] Error running main in method folder:", e) continue # quick sanity: check for result/txt or results/txt result_candidate_1 = method_root / 'result' / 'txt' result_candidate_2 = method_root / 'results' / 'txt' if result_candidate_1.exists(): print("[run_det_attacks] Found result txts at:", result_candidate_1) elif result_candidate_2.exists(): print("[run_det_attacks] Found result txts at:", result_candidate_2) else: print("[run_det_attacks] WARNING: no result txt folder found under method root after running main. Check main output and stderr above.") print("\n[run_det_attacks] All done.") if __name__ == '__main__': main()