Upload 5 files

.gitattributes

@@ -58,3 +58,4 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 # Video files - compressed
 *.mp4 filter=lfs diff=lfs merge=lfs -text
 *.webm filter=lfs diff=lfs merge=lfs -text
+main filter=lfs diff=lfs merge=lfs -text

attack_api_det.py

@@ -0,0 +1,373 @@
+# function/attack/attack_api_det.py
+"""
+Detection attack helpers - detection-specific attack interface for YOLOv7-like models.
+
+(修改点：_save_adv_tensor 支持 ref_path，用于保持原图片的格式与尺寸；generate() 在保存时传入 ref_path)
+"""
+import os
+from pathlib import Path
+from typing import List, Optional, Tuple
+import numpy as np
+from PIL import Image
+import torch
+import torch.nn.functional as F
+
+# Optional imports from yolov7 utils (letterbox / nms). If missing, use simple fallback.
+try:
+    from utils.datasets import letterbox
+    from utils.general import non_max_suppression
+    _HAS_YOLO_UTILS = True
+except Exception:
+    _HAS_YOLO_UTILS = False
+
+# -------------------------
+# Helpers: image <-> tensor
+# -------------------------
+def _letterbox_to_tensor(path: str, img_size: int = 640, device='cpu') -> Tuple[torch.Tensor, Tuple[int,int], Tuple[int,int,int]]:
+    img0 = Image.open(path).convert('RGB')
+    w0, h0 = img0.size
+
+    if _HAS_YOLO_UTILS:
+        np_img = np.array(img0)
+        img_lb, ratio, (dw, dh) = letterbox(np_img, new_shape=img_size)
+        img_arr = img_lb
+        try:
+            r = float(ratio) if ratio is not None else min(img_size / h0, img_size / w0)
+        except:
+            r = min(img_size / h0, img_size / w0)
+    else:
+        r = min(img_size / h0, img_size / w0)
+        new_w, new_h = int(w0 * r), int(h0 * r)
+        img_resized = img0.resize((new_w, new_h), Image.BILINEAR)
+        canvas = Image.new('RGB', (img_size, img_size), (114, 114, 114))
+        dw = (img_size - new_w) // 2
+        dh = (img_size - new_h) // 2
+        canvas.paste(img_resized, (dw, dh))
+        img_arr = np.array(canvas)
+
+    img_bgr = img_arr[:, :, ::-1].transpose(2, 0, 1).copy()
+    tensor = torch.from_numpy(img_bgr).float().unsqueeze(0) / 255.0  # 1,C,H,W
+    return tensor.to(device), (w0, h0), (int(dw) if 'dw' in locals() else 0, int(dh) if 'dh' in locals() else 0, float(r))
+
+def _tensor_to_pil_rgb(tensor_bchw: torch.Tensor) -> Image.Image:
+    arr = (tensor_bchw.detach().cpu().squeeze(0).permute(1, 2, 0).numpy() * 255.0).round().astype('uint8')  # HWC BGR
+    arr = arr[:, :, ::-1]  # to RGB
+    return Image.fromarray(arr)
+
+# -------------------------
+# DetectionEvasionAttacker
+# -------------------------
+class DetectionEvasionAttacker:
+    def __init__(self, model: torch.nn.Module, device: str = 'cuda:0', nc: int = 5, img_size: int = 640, verbose: bool = False):
+        self.device = torch.device(device if isinstance(device, str) else device)
+        self.model = model.to(self.device)
+        self.nc = int(nc)
+        self.img_size = int(img_size)
+        self.verbose = verbose
+
+    def _model_dtype(self):
+        try:
+            return next(self.model.parameters()).dtype
+        except StopIteration:
+            return torch.float32
+
+    def _align_tensor_dtype(self, x: torch.Tensor) -> torch.Tensor:
+        x = x.to(self.device)
+        target_dtype = self._model_dtype()
+        if x.dtype != target_dtype:
+            x = x.to(dtype=target_dtype)
+        return x
+
+    def _preds_forward(self, imgs: torch.Tensor) -> torch.Tensor:
+        imgs = self._align_tensor_dtype(imgs)
+        out = self.model(imgs)
+        if isinstance(out, (tuple, list)):
+            preds = out[0]
+        else:
+            preds = out
+        if torch.is_tensor(preds):
+            return preds
+        try:
+            return torch.stack(preds, dim=0).to(self.device)
+        except Exception as e:
+            raise RuntimeError(f"Cannot parse model(...) output as preds tensor: {e}")
+
+    def _try_loss_forward(self, imgs: torch.Tensor, targets) -> torch.Tensor:
+        imgs = self._align_tensor_dtype(imgs)
+        out = self.model(imgs, targets)
+        if isinstance(out, (tuple, list)) and len(out) >= 1 and torch.is_tensor(out[0]):
+            return out[0]
+        if isinstance(out, dict) and 'loss' in out:
+            return out['loss']
+        raise RuntimeError("Model does not return training loss via model(imgs, targets).")
+
+    def _proxy_loss_from_preds(self, preds: torch.Tensor) -> torch.Tensor:
+        if preds is None:
+            return torch.tensor(0.0, device=self.device)
+        if preds.ndim == 3 and preds.shape[-1] >= 6:
+            obj = preds[..., 4].unsqueeze(-1)
+            cls_scores = preds[..., 5:5 + self.nc]
+            cls_prob = torch.softmax(cls_scores, dim=-1)
+            per_box = obj * cls_prob
+            per_image = per_box.sum(dim=1)
+            loss = per_image.sum()
+            return loss
+        return preds.sum()
+
+    def generate_fgsm_from_loss(self, imgs: torch.Tensor, targets, eps: float = 8/255.0) -> torch.Tensor:
+        self.model.train()
+        imgs = imgs.to(self.device)
+        imgs = self._align_tensor_dtype(imgs)
+        orig = imgs.detach().clone()
+        adv = orig.clone().detach().requires_grad_(True)
+        loss = self._try_loss_forward(adv, targets)
+        loss.backward()
+        grad = adv.grad.detach()
+        adv = adv + eps * grad.sign()
+        adv = torch.max(torch.min(adv, orig + eps), orig - eps)
+        adv = torch.clamp(adv, 0.0, 1.0)
+        return adv.detach()
+
+    def generate_pgd_from_loss(self, imgs: torch.Tensor, targets, eps: float = 8/255.0, alpha: float = 2/255.0, iters: int = 10, random_start: bool = True) -> torch.Tensor:
+        self.model.train()
+        imgs = imgs.to(self.device)
+        imgs = self._align_tensor_dtype(imgs)
+        orig = imgs.detach().clone()
+        if random_start:
+            adv = orig + (torch.rand_like(orig) * 2 - 1) * eps
+        else:
+            adv = orig.clone()
+        adv = torch.clamp(adv, 0.0, 1.0).detach().requires_grad_(True)
+        for i in range(iters):
+            if adv.grad is not None:
+                adv.grad.zero_()
+            loss = self._try_loss_forward(adv, targets)
+            loss.backward()
+            grad = adv.grad.detach()
+            adv = adv + alpha * grad.sign()
+            adv = torch.max(torch.min(adv, orig + eps), orig - eps)
+            adv = torch.clamp(adv, 0.0, 1.0).detach().requires_grad_(True)
+            if self.verbose and i % 5 == 0:
+                try:
+                    print(f"[PGD loss] iter {i} loss {loss.item():.4f}")
+                except:
+                    pass
+        return adv.detach()
+
+    def generate_fgsm_proxy(self, imgs: torch.Tensor, eps: float = 8/255.0) -> torch.Tensor:
+        self.model.eval()
+        imgs = imgs.to(self.device)
+        imgs = self._align_tensor_dtype(imgs)
+        orig = imgs.detach().clone()
+        adv = orig.clone().detach().requires_grad_(True)
+        preds = self._preds_forward(adv)
+        loss = self._proxy_loss_from_preds(preds)
+        loss.backward()
+        grad = adv.grad.detach()
+        adv = adv - eps * grad.sign()
+        adv = torch.max(torch.min(adv, orig + eps), orig - eps)
+        adv = torch.clamp(adv, 0.0, 1.0)
+        return adv.detach()
+
+    def generate_pgd_proxy(self, imgs: torch.Tensor, eps: float = 8/255.0, alpha: float = 2/255.0, iters: int = 10, random_start: bool = True) -> torch.Tensor:
+        self.model.eval()
+        imgs = imgs.to(self.device)
+        imgs = self._align_tensor_dtype(imgs)
+        orig = imgs.detach().clone()
+        if random_start:
+            adv = orig + (torch.rand_like(orig) * 2 - 1) * eps
+        else:
+            adv = orig.clone()
+        adv = torch.clamp(adv, 0.0, 1.0).detach().requires_grad_(True)
+        for i in range(iters):
+            if adv.grad is not None:
+                adv.grad.zero_()
+            preds = self._preds_forward(adv)
+            loss = self._proxy_loss_from_preds(preds)
+            loss.backward()
+            grad = adv.grad.detach()
+            adv = adv - alpha * grad.sign()
+            adv = torch.max(torch.min(adv, orig + eps), orig - eps)
+            adv = torch.clamp(adv, 0.0, 1.0).detach().requires_grad_(True)
+            if self.verbose and i % 5 == 0:
+                try:
+                    print(f"[PGD proxy] iter {i} loss {loss.item():.4f}")
+                except:
+                    pass
+        return adv.detach()
+
+    # -------------------------
+    # Batch helpers & generate API
+    # -------------------------
+    def _save_adv_tensor(self, tensor: torch.Tensor, out_path: str, ref_path: Optional[str] = None):
+        """
+        Save adv tensor (1,C,H,W) as an image.
+        If ref_path is provided, mimic ref image's size & format (e.g., JPEG 448x416).
+        """
+        pil = _tensor_to_pil_rgb(tensor)  # PIL RGB
+        # If a reference image provided, try to read its format/size/mode
+        target_size = None
+        target_format = None
+        try:
+            if ref_path is not None and os.path.exists(ref_path):
+                ref_im = Image.open(ref_path)
+                target_format = ref_im.format  # e.g., 'JPEG' or 'PNG'
+                target_size = ref_im.size  # (W,H)
+        except Exception:
+            target_format = None
+            target_size = None
+
+        if target_size is not None:
+            # resize to reference size (width, height)
+            pil = pil.resize(target_size, Image.BILINEAR)
+
+        # Ensure directory exists
+        os.makedirs(os.path.dirname(out_path), exist_ok=True)
+        # Decide save format by reference or by extension
+        ext = Path(out_path).suffix.lower()
+        fmt = None
+        if target_format:
+            fmt = target_format.upper()
+        else:
+            if ext in ('.jpg', '.jpeg'):
+                fmt = 'JPEG'
+            elif ext in ('.png',):
+                fmt = 'PNG'
+            else:
+                fmt = 'PNG'
+
+        # Save accordingly
+        if fmt == 'JPEG':
+            pil.save(out_path, format='JPEG', quality=95)
+        else:
+            pil.save(out_path, format=fmt)
+
+    def generate(self, method: str = "FGSM",
+             img_paths: Optional[List[str]] = None,
+             source_folder: Optional[str] = None,
+             save_path: Optional[str] = None,
+             batch: int = 4,
+             img_size: int = None,
+             use_loss: bool = False,
+             targets_list: Optional[List] = None,
+             **kwargs):
+        """
+        General generate API supporting multiple methods and per-method kwargs.
+
+        Parameters of interest in kwargs:
+        - eps (float)
+        - alpha (float)
+        - iters/int (int)
+        - random_start (bool)
+        - norm ('inf','2','1')
+        - other method-specific params forwarded.
+
+        img_paths: if provided, use this list (preferred).
+        source_folder: fallback to read all images from folder.
+        """
+        if img_paths is None:
+            if source_folder:
+                p = Path(source_folder)
+                img_paths = sorted([str(x) for x in p.glob('*') if x.suffix.lower() in ('.jpg','.jpeg','.png')])
+            else:
+                raise ValueError("Either img_paths or source_folder must be provided")
+        # clip / cast
+        if img_size is None:
+            img_size = self.img_size
+        else:
+            img_size = int(img_size)
+
+        method_key = method.upper()
+        # default args
+        eps = float(kwargs.get('eps', kwargs.get('epsilon', 8/255.0)))
+        alpha = float(kwargs.get('alpha', 2/255.0))
+        iters = int(kwargs.get('iters', kwargs.get('steps', 10)))
+        random_start = bool(kwargs.get('random_start', True))
+        norm = str(kwargs.get('norm', 'inf')).lower()
+
+        # Prepare image list
+        if len(img_paths) == 0:
+            raise ValueError("No images to attack")
+        piclist = []
+        advs = []
+
+        # helper to chunk
+        for i in range(0, len(img_paths), batch):
+            batch_paths = img_paths[i:i + batch]
+            batch_tensors = []
+            for pth in batch_paths:
+                t, _, _ = _letterbox_to_tensor(pth, img_size=img_size, device=self.device)
+                t = t.float()
+                batch_tensors.append(t.squeeze(0))
+            x = torch.stack(batch_tensors, dim=0)  # B,C,H,W
+
+            # Choose implementation
+            try:
+                if method_key in ("FGSM", "FFGSM"):
+                    if use_loss and targets_list:
+                        adv = self.generate_fgsm_from_loss(x, targets_list[i:i+batch], eps=eps)
+                    else:
+                        adv = self.generate_fgsm_proxy(x, eps=eps)
+                elif method_key in ("PGD", "PGDL", "BIM", "IFGSM", "I-FGSM", "BASIC_ITERATIVE"):
+                    # PGD-like attacks: use proxy or loss versions
+                    if use_loss and targets_list:
+                        adv = self.generate_pgd_from_loss(x, targets_list[i:i+batch], eps=eps, alpha=alpha, iters=iters, random_start=random_start)
+                    else:
+                        adv = self.generate_pgd_proxy(x, eps=eps, alpha=alpha, iters=iters, random_start=random_start)
+                elif method_key in ("CW", "C&W", "CARLINI", "CARLINI-WAGNER"):
+                    try:
+                        import torchattacks
+                        atk = torchattacks.CW(self.model, c=kwargs.get('c', 1e-3), kappa=kwargs.get('kappa', 0), steps=kwargs.get('cw_steps', 1000))
+                        adv = atk(x, torch.zeros(x.size(0), dtype=torch.long, device=self.device))
+                    except Exception as e:
+                        raise RuntimeError("C&W attack requires 'torchattacks' package or custom implementation. "
+                                        "Fallback: use PGD-from-loss for detection models. Error: " + str(e))
+                elif method_key in ("DEEPLF", "DEEPOF", "DEEPLFOOL", "DEEPFOOL"):
+                    try:
+                        import torchattacks
+                        atk = torchattacks.DeepFool(self.model)
+                        adv = atk(x, torch.zeros(x.size(0), dtype=torch.long, device=self.device))
+                    except Exception as e:
+                        raise RuntimeError("DeepFool requires 'torchattacks' or custom impl. Fallback use PGD-from-loss.")
+                elif method_key in ("AUTOATTACK", "AUTO"):
+                    try:
+                        import torchattacks
+                        atk = torchattacks.AutoAttack(self.model)
+                        adv = atk(x, torch.zeros(x.size(0), dtype=torch.long, device=self.device))
+                    except Exception as e:
+                        raise RuntimeError("AutoAttack requires 'torchattacks' package. Fallback: use PGD.")
+                else:
+                    # default fallback: PGD proxy
+                    if use_loss and targets_list:
+                        adv = self.generate_pgd_from_loss(x, targets_list[i:i+batch], eps=eps, alpha=alpha, iters=iters, random_start=random_start)
+                    else:
+                        adv = self.generate_pgd_proxy(x, eps=eps, alpha=alpha, iters=iters, random_start=random_start)
+            except Exception as e:
+                raise RuntimeError(f"Attack generation failed for method {method_key} on batch starting at {i}: {e}")
+
+            # save adv images if requested (preserve ref)
+            for bi, pth in enumerate(batch_paths):
+                tensor_single = adv[bi:bi + 1]  # 1,C,H,W
+                if save_path:
+                    orig_ext = Path(pth).suffix.lower()
+                    fname = Path(pth).stem + f"_adv_{method_key}" + orig_ext
+                    outp = os.path.join(save_path, fname)
+                    # Save adversarial image
+                    self._save_adv_tensor(tensor_single, outp, ref_path=pth)
+                    piclist.append(outp)
+
+                    # Calculate and save the perturbation to /jjs_tmp/perturbation/
+                    orig_tensor, _, _ = _letterbox_to_tensor(pth, img_size=img_size, device=self.device)
+                    perturbation = tensor_single - orig_tensor  # Calculate perturbation
+                    perturbation_dir = "jjs_tmp/perturbation/"  # Specify the directory
+                    os.makedirs(perturbation_dir, exist_ok=True)  # Ensure directory exists
+                    perturbation_path = os.path.join(perturbation_dir, f"{Path(pth).stem}_perturbation.bin")
+                    perturbation.detach().cpu().numpy().tofile(perturbation_path)
+                    #np.save(perturbation_path, perturbation.detach().cpu().numpy())  # Save perturbation as .npy
+                advs.append(tensor_single.detach().cpu().numpy())
+
+        adv_np = np.concatenate(advs, axis=0) if advs else np.zeros((0,3,img_size,img_size), dtype=np.float32)
+        return adv_np, None, piclist
+
+
+

best.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:418f908937b56867b01894035f0ce71f21edd1761ca87f7085982aa2f056620a
+size 74839704

clip_coordinates.py

@@ -0,0 +1,150 @@
+"""Batch-clamp four-point detection coordinates; dry-run unless --apply is set.
+
+Example:
+  python clip_coordinates.py --apply
+Default bounds: x in [0,447], y in [0,415] for a 448x416 image.
+Use --max-x 448 --max-y 416 only if your format uses continuous image-edge coordinates.
+"""
+import argparse
+import hashlib
+import json
+import math
+import os
+from pathlib import Path
+import re
+import shutil
+import tempfile
+from datetime import datetime
+
+
+def transform(data, path, max_x, max_y):
+    output = []
+    changed_rows = changed_values = upper = negative = rows = 0
+    for number, line in enumerate(data.splitlines(keepends=True), 1):
+        # Preserve a UTF-8 BOM, whitespace, line endings, class ID and confidence.
+        prefix = b'\xef\xbb\xbf' if number == 1 and line.startswith(b'\xef\xbb\xbf') else b''
+        body = line[len(prefix):]
+        tokens = list(re.finditer(rb'\S+', body))
+        if not tokens:
+            output.append(line)
+            continue
+        if len(tokens) != 10:
+            raise ValueError(f'{path}:{number}: expected 10 fields, got {len(tokens)}')
+        rows += 1
+        replacements = []
+        for i, token in enumerate(tokens[:8]):
+            value = float(token.group())
+            if not math.isfinite(value):
+                raise ValueError(f'{path}:{number}: non-finite coordinate')
+            limit = max_x if i % 2 == 0 else max_y
+            clipped = min(limit, max(0, value))
+            if clipped != value:
+                # Retain fixed-point precision of the original coordinate.
+                raw = token.group().decode('ascii')
+                precision = len(raw.split('.')[1]) if '.' in raw and 'e' not in raw.lower() else 6
+                replacements.append((token.start(), token.end(), f'{clipped:.{precision}f}'.encode('ascii')))
+                upper += value > limit
+                negative += value < 0
+        if replacements:
+            changed_rows += 1
+            changed_values += len(replacements)
+            for start, end, replacement in reversed(replacements):
+                body = body[:start] + replacement + body[end:]
+        output.append(prefix + body)
+    return b''.join(output), dict(rows=rows, changed_rows=changed_rows,
+                                  changed_values=changed_values,
+                                  upper_coordinates=upper, negative_coordinates=negative)
+
+
+def atomic_write(path, data):
+    fd, name = tempfile.mkstemp(prefix='.clip-', suffix='.tmp', dir=path.parent)
+    try:
+        with os.fdopen(fd, 'wb') as stream:
+            stream.write(data)
+            stream.flush()
+            os.fsync(stream.fileno())
+        os.replace(name, path)
+    finally:
+        if os.path.exists(name):
+            os.unlink(name)
+
+
+def main():
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument('--root', type=Path, default=Path(r'D:\寅家验收\Perception'))
+    parser.add_argument('--max-x', type=float, default=447)
+    parser.add_argument('--max-y', type=float, default=415)
+    parser.add_argument('--apply', action='store_true')
+    parser.add_argument('--backup-dir', type=Path)
+    parser.add_argument('--report', type=Path)
+    args = parser.parse_args()
+    if not all(math.isfinite(v) and v > 0 for v in (args.max_x, args.max_y)):
+        parser.error('Bounds must be positive and finite')
+    root = args.root.resolve(strict=True)
+    directories = [root / name for name in ('JMC_Yichi_05S', 'Neta_S')]
+    if not all(p.is_dir() for p in directories):
+        parser.error('Both JMC_Yichi_05S and Neta_S directories are required')
+    plan = []
+    stats = {}
+    # Validate EVERY file before modifying any source file.
+    for directory in directories:
+        totals = dict(files=0, rows=0, changed_files=0, changed_rows=0,
+                      changed_values=0, upper_coordinates=0, negative_coordinates=0)
+        paths = []
+        for parent, _, names in os.walk(directory):
+            paths.extend(Path(parent) / name for name in names if name.lower().endswith('.txt'))
+        for index, path in enumerate(sorted(paths), 1):
+            if index % 2000 == 0:
+                print(f'Checking {directory.name}: {index}/{len(paths)} TXT files', flush=True)
+            resolved = path.resolve(strict=True)
+            if not resolved.is_relative_to(directory.resolve()):
+                raise ValueError(f'File resolves outside intended directory: {path}')
+            original = path.read_bytes()
+            updated, counts = transform(original, path, args.max_x, args.max_y)
+            totals['files'] += 1
+            for key, value in counts.items():
+                totals[key] += value
+            if original != updated:
+                totals['changed_files'] += 1
+                plan.append((path, original, updated, counts))
+        stats[directory.name] = totals
+        print(f'Checked {directory.name}: {totals}', flush=True)
+    report = dict(mode='apply' if args.apply else 'dry-run', root=str(root),
+                  bounds=dict(x=[0, args.max_x], y=[0, args.max_y]), statistics=stats)
+    if args.apply and plan:
+        backup = (args.backup_dir or Path(__file__).resolve().parent / 'coordinate_backups' /
+                  datetime.now().strftime('%Y%m%d_%H%M%S_%f')).resolve()
+        if backup.is_relative_to(root):
+            raise ValueError('Backup directory must be outside the source root')
+        backup.mkdir(parents=True, exist_ok=False)
+        # Back up ALL affected files before the first overwrite.
+        for path, original, _, _ in plan:
+            if path.read_bytes() != original:
+                raise RuntimeError(f'Source changed during preflight: {path}')
+            dest = backup / path.relative_to(root)
+            dest.parent.mkdir(parents=True, exist_ok=True)
+            shutil.copy2(path, dest)
+            if dest.read_bytes() != original:
+                raise RuntimeError(f'Backup verification failed: {path}')
+        print(f'Backed up {len(plan)} files to {backup}', flush=True)
+        report['backup_directory'] = str(backup)
+        report['modified_files'] = []
+        for path, original, updated, counts in plan:
+            if path.read_bytes() != original:
+                raise RuntimeError(f'Source changed before overwrite: {path}')
+            atomic_write(path, updated)
+            actual = path.read_bytes()
+            if actual != updated or transform(actual, path, args.max_x, args.max_y)[1]['changed_values']:
+                raise RuntimeError(f'Post-write verification failed: {path}')
+            report['modified_files'].append(dict(path=str(path), **counts,
+                original_sha256=hashlib.sha256(original).hexdigest(),
+                clipped_sha256=hashlib.sha256(updated).hexdigest()))
+        report['verification'] = 'All modified files match expected bytes and have in-range coordinates.'
+    if args.report:
+        args.report.parent.mkdir(parents=True, exist_ok=True)
+        args.report.write_text(json.dumps(report, ensure_ascii=False, indent=2), encoding='utf-8')
+    print(json.dumps({k: v for k, v in report.items() if k != 'modified_files'}, ensure_ascii=False, indent=2))
+
+
+if __name__ == '__main__':
+    main()

main

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:4723f0488c788cd426cab5890175eb9b178cefd895b52d78895900369e8e368e
+size 229517184

run_det_attacks.py

@@ -0,0 +1,279 @@
+#!/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/<METHOD>/images/
+- After generation, the script symlinks or copies your provided main executable into OUT/<METHOD>/main
+  and runs it in that directory (so it will create OUT/<METHOD>/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/<METHOD>/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/<METHOD>/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()