Upload 6 files

README.md

@@ -1,3 +1,81 @@
----
-license: apache-2.0
----
+---
+license: mit
+datasets:
+- imagenet-1k
+metrics:
+- accuracy
+tags:
+- adversarial machine learning
+---
+
+
+
+## RobArch: Designing Robust Architectures against Adversarial Attacks
+*ShengYun Peng, Weilin Xu, Cory Cornelius, Kevin Li, Rahul Duggal, Duen Horng Chau, Jason Martin*
+
+Check https://github.com/ShengYun-Peng/RobArch for the complete code. 
+
+### Abstract
+Adversarial Training is the most effective approach for improving the robustness of Deep Neural Networks (DNNs). However, compared to the large body of research in optimizing the adversarial training process, there are few investigations into how architecture components affect robustness, and they rarely constrain model capacity. Thus, it is unclear where robustness precisely comes from. In this work, we present the first large-scale systematic study on the robustness of DNN architecture components under fixed parameter budgets. Through our investigation, we distill 18 actionable robust network design guidelines that empower model developers to gain deep insights. We demonstrate these guidelines' effectiveness by introducing the novel Robust Architecture (RobArch) model that instantiates the guidelines to build a family of top-performing models across parameter capacities against strong adversarial attacks. RobArch achieves the new state-of-the-art AutoAttack accuracy on the RobustBench ImageNet leaderboard.
+
+
+### Prerequisites
+1. Register Weights & Biases [account](https://wandb.ai/site)
+2. Prepare ImageNet via [Fast AT - Installation step 3 & 4](https://github.com/locuslab/fast_adversarial/tree/master/ImageNet)
+> Run step 4 only if you want to use Fast-AT.
+3. Set up venv:
+```bash
+make .venv_done
+```
+
+### Training
+Fast-AT is much faster than standard PGD AT. For RobArch-S, Fast-AT takes ~1.5 days on 2 Nvidia A100s, but ~5 days on 4 Nvidia A100s.
+#### Torchvision models - Fast AT (e.g., ResNet-50)
+```bash
+make BASE=<imagenet root dir> WANDB_ACCOUNT=<name> experiments/Torch_ResNet50/.done_test_pgd
+```
+If you want to test other off-the-shelf models in [torchvision](https://pytorch.org/vision/stable/models.html#classification), add the model name in [MODEL.mk](MODEL.mk), and create a new make target by following other ResNets/WideResNets in [Makefile](Makefile).
+#### RobArch - Fast AT (e.g., RobArch-S)
+```bash
+make BASE=<imagenet root dir> WANDB_ACCOUNT=<name> experiments/RobArch_S/.done_test_pgd
+```
+
+#### RobArch - Standard PGD AT (e.g., RobArch-S)
+```bash
+# Training
+make BASE=<imagenet root dir> WANDB_ACCOUNT=<name> experiments/PGDAT_RobArch_S/.done_train
+
+# Evaluation on PGD
+make BASE=<imagenet root dir> WANDB_ACCOUNT=<name> experiments/PGDAT_RobArch_S/.done_test_pgd
+
+# Evaluation on AutoAttack
+make BASE=<imagenet root dir> WANDB_ACCOUNT=<name> experiments/PGDAT_RobArch_S/.done_test_aa
+
+# Pretrained models evaluated on AutoAttack
+make BASE=<imagenet root dir> WANDB_ACCOUNT=<name> experiments/PGDAT_RobArch_S/.done_test_pretrained
+```
+
+
+### Pretrained models
+- ImageNet $\ell_\infty$-norm
+
+| Architecture | #Param | Natural | AutoAttack | PGD10-4 | PGD50-4 | PGD100-4 | PGD100-2 | PGD100-8 |
+| :--: | :--: | :--: | :--: | :--: | :--: | :--: | :--: | :--: |
+| [RobArch-S](https://huggingface.co/poloclub/RobArch/resolve/main/pretrained/robarch_s.pt) | 26M | 70.17% | 44.14% | 48.19% | 47.78% | 47.77% | 60.06% | 21.77% |
+| [RobArch-M](https://huggingface.co/poloclub/RobArch/resolve/main/pretrained/robarch_m.pt) | 46M | 71.88% | 46.26% | 49.84% | 49.32% | 49.30% | 61.89% | 23.01% |
+| [RobArch-L](https://huggingface.co/poloclub/RobArch/resolve/main/pretrained/robarch_l.pt) | 104M | 73.44% | 48.94% | 51.72% | 51.04% | 51.03% | 63.49% | 25.31% |
+
+
+
+### Citation
+
+```bibtex
+@misc{peng2023robarch,
+      title={RobArch: Designing Robust Architectures against Adversarial Attacks}, 
+      author={ShengYun Peng and Weilin Xu and Cory Cornelius and Kevin Li and Rahul Duggal and Duen Horng Chau and Jason Martin},
+      year={2023},
+      eprint={2301.03110},
+      archivePrefix={arXiv},
+      primaryClass={cs.CV}
+}
+```

adv_train.py

@@ -0,0 +1,240 @@
+from typing import Any, Callable
+import torch
+from torch.distributions import Uniform
+import time
+from torch.utils.data import DataLoader
+import torch.nn as nn
+import numpy as np
+from omegaconf import DictConfig
+import logging
+import wandb
+from apex import amp
+from advertorch.attacks import LinfPGDAttack
+
+from robustarch.utils import AverageMeter, accuracy, pad_str
+
+
+def train(model: nn.Module, train_loader: DataLoader, optimizer: torch.optim.Optimizer, criterion: nn.Module, lr_schedule: Any, epoch: int, device: torch.device, cfg: DictConfig, log: logging.Logger, eps_schedule: Callable = None):
+    """
+    Normalization step belongs to the model. It should be the first step of forward function.
+    epoch: current training epoch
+    """
+
+    # initialize all meters
+    batch_time = AverageMeter()
+    losses = AverageMeter()
+    top1 = AverageMeter()
+    top5 = AverageMeter()
+
+    model.train()  # train mode
+    mark_time = time.time()
+    train_eps = 1.0 * cfg.attack.train.eps / cfg.dataset.max_color_value
+    test_eps = 1.0 * cfg.attack.test.eps / cfg.dataset.max_color_value
+    assert train_eps <= 1.0
+    assert test_eps <= 1.0
+
+    if cfg.train_test.mode.lower() == "fat":
+        sampler = Uniform(low=-test_eps, high=test_eps)
+    else:
+        if eps_schedule:
+            log.info(pad_str(f" Train with eps={eps_schedule(epoch)} "))
+        else:
+            log.info(pad_str(f" Train with eps={train_eps} "))
+        if cfg.attack.train.norm == "linf":
+            train_gamma = 1.0 * cfg.attack.train.gamma / cfg.dataset.max_color_value
+            assert train_gamma <= 1.0
+            adversary = LinfPGDAttack(
+                predict=model,
+                loss_fn=criterion,
+                eps=eps_schedule(epoch) if eps_schedule else train_eps,
+                nb_iter=cfg.attack.train.step,
+                eps_iter=train_gamma,
+                rand_init=cfg.attack.train.random_init,
+                clip_min=0.0, clip_max=1.0, targeted=False
+            )
+        else:
+            raise NotImplementedError
+
+    for i, (input, target) in enumerate(train_loader):
+        input = input.to(device, non_blocking=True)
+        target = target.to(device, non_blocking=True)
+
+        N, C, W, H = input.shape
+        assert C == 3
+        total_batch = len(train_loader)
+
+        ## inner maximization (move normalization into the model)
+        if cfg.train_test.mode.lower() == "fat":
+            batch_shape = (N, C, W, H)
+            if cfg.attack.train.random_init:
+                init_noise = sampler.sample(batch_shape).to(device)
+            else:
+                init_noise = torch.zeros(batch_shape).to(device)
+
+            # update lr only for FAT
+            lr = lr_schedule(epoch + (i + 1) / total_batch)
+            for param_group in optimizer.param_groups:
+                param_group["lr"] = lr
+
+            # fgsm for FAT
+            batch_noise = init_noise.clone().detach().requires_grad_(True)
+            input_adv = input + batch_noise
+            input_adv.clamp_(0., 1.)
+            output = model(input_adv)
+
+            loss = criterion(output, target)
+            if cfg.train_test.half:
+                with amp.scale_loss(loss, optimizer) as scaled_loss:
+                    scaled_loss.backward()
+            else:
+                loss.backward()
+
+            # 1-iter pdg attack
+            fgsm_noise = torch.sign(batch_noise.grad) * train_eps
+            init_noise += fgsm_noise.data
+            init_noise.clamp_(-test_eps, test_eps)
+
+            batch_noise = init_noise.clone().detach().requires_grad_(False)
+            input_adv = input + batch_noise
+            input.clamp_(0., 1.)
+        else:
+            input_adv = adversary.perturb(input, target)
+        lr = optimizer.param_groups[0]["lr"]
+
+        ## outer minimization
+        output = model(input_adv)
+        loss = criterion(output, target)
+
+        # optimizer
+        optimizer.zero_grad()
+        if cfg.train_test.half:
+            with amp.scale_loss(loss, optimizer) as scaled_loss:
+                scaled_loss.backward()
+        else:
+            loss.backward()
+
+        optimizer.step()
+
+        ## record results and elapsed time
+        prec1, prec5 = accuracy(output, target, topk=(1, 5))
+        losses.update(loss.item(), N)
+        top1.update(prec1, N)
+        top5.update(prec5, N)
+        batch_time.update(time.time() - mark_time)
+
+        mark_time = time.time()
+
+        # log results
+        if i % cfg.train_test.print_freq == 0:
+            log.info(f"Train Epoch: [{epoch}][{i}/{total_batch}]  Time {batch_time.val:.3f} ({batch_time.avg:.3f})  Loss {losses.val:.4f} ({losses.avg:.4f})  Prec@1 {top1.val:.3f} ({top1.avg:.3f})  Prec@5 {top5.val:.3f} ({top5.avg:.3f})  LR {lr:.3f}")
+
+    # update lr schedule for non-FAT
+    if cfg.train_test.mode.lower() != "fat":
+        lr_schedule.step(epoch + 1)
+
+    if cfg.visualization.tool == "wandb":
+        wandb.log({"Train top1 accuracy": top1.avg}, step=epoch)
+        wandb.log({"Train top5 accuracy": top5.avg}, step=epoch)
+        wandb.log({"Train loss": losses.avg}, step=epoch)
+
+
+def test_natural(model: nn.Module, val_loader: DataLoader, criterion: nn.Module, device: torch.device, cfg: DictConfig, log: logging.Logger) -> float:
+    # initialize all meters
+    batch_time = AverageMeter()
+    losses = AverageMeter()
+    top1 = AverageMeter()
+    top5 = AverageMeter()
+
+    model.eval()  # eval mode
+    mark_time = time.time()
+    for i, (input, target) in enumerate(val_loader):
+        with torch.no_grad():
+            input = input.to(device, non_blocking=True)
+            target = target.to(device, non_blocking=True)
+
+            N = input.shape[0]
+            if cfg.model.model_source == "madry":
+                output = model(input, with_image=False)
+            else:
+                output = model(input)
+            loss = criterion(output, target)
+
+        ## record results and elapsed time
+        prec1, prec5 = accuracy(output, target, topk=(1, 5))
+        losses.update(loss.item(), N)
+        top1.update(prec1, N)
+        top5.update(prec5, N)
+        batch_time.update(time.time() - mark_time)
+
+        mark_time = time.time()
+
+        # log results
+        if i % cfg.train_test.print_freq == 0:
+                log.info(f"Test: [{i}/{len(val_loader)}] Time {batch_time.val:.3f} ({batch_time.avg:.3f})  Loss {losses.val:.4f} ({losses.avg:.4f})  Prec@1 {top1.val:.3f} ({top1.avg:.3f})  Prec@5 {top5.val:.3f} ({top5.avg:.3f})")
+
+    log.info(f"Final Prec@1 {top1.avg:.3f} Prec@5 {top5.avg:.3f}")
+    return top1.avg
+
+def test_pgd(model: nn.Module, val_loader: DataLoader, criterion: nn.Module, device: torch.device, cfg: DictConfig, log: logging.Logger):
+    ## attack
+    if cfg.attack.test.norm == "linf":
+        adversary = LinfPGDAttack(
+            model, loss_fn=criterion,
+            eps=1.0 * cfg.attack.test.eps / cfg.dataset.max_color_value,
+            nb_iter=cfg.attack.test.step,
+            eps_iter=1.0 * cfg.attack.test.gamma / cfg.dataset.max_color_value,
+            rand_init=cfg.attack.test.random_init,
+            clip_min=0.0, clip_max=1.0, targeted=False
+        )
+    else:
+        raise NotImplementedError
+
+    ## initialize all meters
+    batch_time = AverageMeter()
+    losses = AverageMeter()
+    top1 = AverageMeter()
+    top5 = AverageMeter()
+    log.info(pad_str(f" PGD eps: {cfg.attack.test.eps}, step: {cfg.attack.test.step}, gamma: {cfg.attack.test.gamma}, restarts: {cfg.attack.test.restart} "))
+
+    model.eval()  # eval mode
+    mark_time = time.time()
+    for i, (input, target) in enumerate(val_loader):
+        input = input.to(device, non_blocking=True)
+        target = target.to(device, non_blocking=True)
+
+        ## adversarial inputs
+        for j in range(cfg.attack.test.restart):
+            input_adv = adversary.perturb(input, target)
+            with torch.no_grad():
+                if j == 0:
+                    final_input_adv = input_adv
+                else:
+                    # record misclassified images
+                    I = output.max(1)[1] != target
+                    final_input_adv[I] = input[I]
+
+        with torch.no_grad():
+            N = input.shape[0]
+            if cfg.model.model_source == "madry":
+                output = model(input_adv, with_image=False)
+            else:
+                output = model(input_adv)
+            loss = criterion(output, target)
+
+        ## record results and elapsed time
+        prec1, prec5 = accuracy(output, target, topk=(1, 5))
+        losses.update(loss.item(), N)
+        top1.update(prec1, N)
+        top5.update(prec5, N)
+        batch_time.update(time.time() - mark_time)
+        mark_time = time.time()
+
+        # log results
+        if i % cfg.train_test.print_freq == 0:
+            log.info(f"PGD Test: [{i}/{len(val_loader)}]  Time {batch_time.val:.3f} ({batch_time.avg:.3f})  Loss {losses.val:.4f} ({losses.avg:.4f})  Prec@1 {top1.val:.3f} ({top1.avg:.3f})  Prec@5 {top5.val:.3f} ({top5.avg:.3f})")
+
+    log.info(f" PGD Final Prec@1 {top1.avg:.3f} Prec@5 {top5.avg:.3f}")
+
+
+
+

attacks_per_round.py

@@ -0,0 +1,107 @@
+import networkx as nx
+import random
+import matplotlib.pyplot as plt
+from matplotlib.colors import Normalize, LinearSegmentedColormap
+
+n = 20000000
+G = nx.barabasi_albert_graph(n, m)
+
+trust = {node: 0 for node in G.nodes}  
+num_mainstream = 500  
+num_fake = 200  
+
+mainstream_nodes = random.sample(list(G.nodes), num_mainstream)
+fake_nodes = random.sample(list(G.nodes), num_fake)
+
+
+pos = nx.spring_layout(G, k=0.2)  # 增大k值使布局更松散
+
+# 更新信任度函数
+def update_trust(node, is_mainstream, delta_x):
+    if is_mainstream:
+        trust[node] += delta_x  # 主流媒体信任度提升
+    else:
+        trust[node] -= delta_x * 3.7  # 虚假信息传播强度
+    trust[node] = max(-1, min(1, trust[node]))
+
+# 传播函数，动态调整传播强度并引入成功率
+def propagate_info(source_node, is_mainstream, success_rate=0.8):
+    neighbors = list(G.neighbors(source_node))
+    degree = len(neighbors)
+    delta_x = 0.8 / (degree + 1)  # 传播强度与节点度成反比
+    
+    for neighbor in neighbors:
+        if random.random() < success_rate:  # 按照传染成功率传播
+            update_trust(neighbor, is_mainstream, delta_x)
+
+# 蓄意攻击函数，攻击主流媒体节点及其邻居
+def attack_targeted_mainstream(num_attack, success_rate=0.75):
+    targeted_nodes = []
+    for node in mainstream_nodes:
+        neighbors = list(G.neighbors(node))
+        targeted_nodes.append(node)
+        targeted_nodes.extend(neighbors)
+    
+    targeted_nodes = list(set(targeted_nodes))
+    if len(targeted_nodes) > num_attack:
+        targeted_nodes = random.sample(targeted_nodes, num_attack)
+
+    for node in targeted_nodes:
+        propagate_info(node, False, success_rate)
+    
+    return targeted_nodes
+
+def repair_network(success_rate=0.4):
+    for node in mainstream_nodes:
+        if random.random() < success_rate:
+            propagate_info(node, True, success_rate)
+
+def check_cascade_failure(threshold=0.15, accelerate_threshold=0.25):
+    fake_trust_count = sum(1 for v in trust.values() if v < -0.5)
+    fake_ratio = fake_trust_count / n
+    
+    if fake_ratio > accelerate_threshold:
+        return True, fake_ratio, 0.95
+    if fake_ratio > threshold:
+        return True, fake_ratio, 0.85
+    return False, fake_ratio, 0.8
+
+def record_data(round_num, fake_ratio, trust_values):
+    print(f"Round {round_num}: Fake info ratio = {fake_ratio:.2f}")
+
+def visualize_trust_custom(ax, round_num):
+    node_colors = [trust[node] for node in G.nodes]
+    norm = Normalize(vmin=-1, vmax=1)
+    node_colors_normalized = [norm(trust[node]) for node in G.nodes]
+
+    cmap_custom = LinearSegmentedColormap.from_list("custom_heatmap", ["#440154", "#3b0f70", "#8c2981", "#de4968", "#fba238", "#fcffa4"])
+    nx.draw(G, pos, node_color=node_colors_normalized, node_size=5, cmap=cmap_custom, with_labels=False, ax=ax)
+    
+    ax.set_title(f"Round {round_num}", fontsize=10)
+    ax.axis('off')
+
+# 模拟主流媒体与虚假信息的博弈
+def simulate_rounds_custom(num_rounds, num_attacks_per_round, initial_success_rate=0.8, collapse_threshold=0.2, accelerate_threshold=0.4):
+    success_rate = initial_success_rate
+    fig, axes = plt.subplots(4, 5, figsize=(14, 15)) 
+    axes = axes.flatten()
+    
+    for i in range(num_rounds):
+        attacked_nodes = attack_targeted_mainstream(num_attacks_per_round, success_rate)
+        repair_network()
+        is_cascading, fake_ratio, new_success_rate = check_cascade_failure(collapse_threshold, accelerate_threshold)
+        success_rate = new_success_rate
+        
+        visualize_trust_custom(axes[i], i + 1)
+        record_data(i + 1, fake_ratio, trust)
+        
+        if is_cascading:
+            print(f"Network is cascading in round {i + 1} with fake info ratio {fake_ratio:.2f}. Transmission rate increased to {success_rate}.")
+        if fake_ratio > 0.4:
+            print(f"Network collapsed in round {i + 1} with fake info ratio {fake_ratio:.2f}")
+            break
+    plt.tight_layout()
+    plt.show()
+
+simulate_rounds_custom(num_rounds=20, num_attacks_per_round=30, initial_success_rate=0.8, collapse_threshold=0.2, accelerate_threshold=0.4)
+

gitattributes

@@ -0,0 +1,34 @@
+*.7z filter=lfs diff=lfs merge=lfs -text
+*.arrow filter=lfs diff=lfs merge=lfs -text
+*.bin filter=lfs diff=lfs merge=lfs -text
+*.bz2 filter=lfs diff=lfs merge=lfs -text
+*.ckpt filter=lfs diff=lfs merge=lfs -text
+*.ftz filter=lfs diff=lfs merge=lfs -text
+*.gz filter=lfs diff=lfs merge=lfs -text
+*.h5 filter=lfs diff=lfs merge=lfs -text
+*.joblib filter=lfs diff=lfs merge=lfs -text
+*.lfs.* filter=lfs diff=lfs merge=lfs -text
+*.mlmodel filter=lfs diff=lfs merge=lfs -text
+*.model filter=lfs diff=lfs merge=lfs -text
+*.msgpack filter=lfs diff=lfs merge=lfs -text
+*.npy filter=lfs diff=lfs merge=lfs -text
+*.npz filter=lfs diff=lfs merge=lfs -text
+*.onnx filter=lfs diff=lfs merge=lfs -text
+*.ot filter=lfs diff=lfs merge=lfs -text
+*.parquet filter=lfs diff=lfs merge=lfs -text
+*.pb filter=lfs diff=lfs merge=lfs -text
+*.pickle filter=lfs diff=lfs merge=lfs -text
+*.pkl filter=lfs diff=lfs merge=lfs -text
+*.pt filter=lfs diff=lfs merge=lfs -text
+*.pth filter=lfs diff=lfs merge=lfs -text
+*.rar filter=lfs diff=lfs merge=lfs -text
+*.safetensors filter=lfs diff=lfs merge=lfs -text
+saved_model/**/* filter=lfs diff=lfs merge=lfs -text
+*.tar.* filter=lfs diff=lfs merge=lfs -text
+*.tflite filter=lfs diff=lfs merge=lfs -text
+*.tgz filter=lfs diff=lfs merge=lfs -text
+*.wasm filter=lfs diff=lfs merge=lfs -text
+*.xz filter=lfs diff=lfs merge=lfs -text
+*.zip filter=lfs diff=lfs merge=lfs -text
+*.zst filter=lfs diff=lfs merge=lfs -text
+*tfevents* filter=lfs diff=lfs merge=lfs -text

main.py

@@ -0,0 +1,196 @@
+import os
+import time
+import torch
+import torch.nn as nn
+import torch.backends.cudnn as cudnn
+import torch.optim
+import torchvision.transforms as transforms
+import torchvision.datasets as datasets
+import torchvision.models as models
+from torch.utils.data import DataLoader
+import wandb
+import numpy as np
+from pathlib import Path
+from ptflops import get_model_complexity_info
+from timm.scheduler.cosine_lr import CosineLRScheduler
+from timm.scheduler.step_lr import StepLRScheduler
+from robustbench import benchmark
+
+from omegaconf import DictConfig, OmegaConf
+import hydra
+from hydra.utils import get_original_cwd
+import logging
+from apex import amp
+from robustarch.utils import configure_optimizers, get_datasets, pad_str, save_checkpoint, make_linear_schedule
+from robustarch.adv_train import train, test_natural, test_pgd
+
+from robustarch.models.model_torch import TorchModel
+from robustarch.models.model import NormalizedConfigurableModel
+
+log = logging.getLogger(__name__)
+
+@hydra.main(config_path="../configs", config_name="main", version_base="1.2")
+def main(cfg: DictConfig):
+    ### initialize parameters and folders
+    device = torch.device(cfg.train_test.device)
+    cwd = get_original_cwd()
+    cudnn.benchmark = True
+
+    # log all configurations
+    log.info(f"\n{pad_str(' ARGUMENTS ')}\n{OmegaConf.to_yaml(cfg)}\n{pad_str('')}")
+
+    ### Create models (configurable models not implemented)
+    log.info(f"=> creating model:")
+    assert cfg.model.model_source in ["torch", "local", "madry"], f"{cfg.model.model_source} not supported"
+    if cfg.model.model_source == "torch":
+        model = TorchModel(cfg.model.arch, cfg.dataset.mean, cfg.dataset.std, **cfg.model.kwargs)
+    elif cfg.model.model_source == "local":
+        model = NormalizedConfigurableModel(cfg.dataset.mean, cfg.dataset.std, **hydra.utils.instantiate(cfg.model.kwargs))
+    else:
+        raise NotImplementedError
+    model.to(device)
+    log.info(model)
+
+    # compute model complexity
+    log.info(pad_str(" Model Complexity Info "))
+    macs, params = get_model_complexity_info(model, (3, cfg.train_test.crop_size, cfg.train_test.crop_size), as_strings=True,
+                                           print_per_layer_stat=False, verbose=False)
+    log.info(f"{'Computational complexity: ':<30}  {macs:<8}")
+    log.info(f"{'Number of parameters: ':<30}  {params:<8}")
+
+    ### criterion, optimizer and lr scheduler
+    criterion = nn.CrossEntropyLoss().to(device)
+
+    param_groups = configure_optimizers(model)
+    optimizer_name = cfg.train_test.optim.lower()
+    if optimizer_name == "sgd":
+        optimizer = torch.optim.SGD(params=param_groups, lr=cfg.train_test.lr, momentum=cfg.train_test.momentum, weight_decay=cfg.train_test.weight_decay)
+    elif optimizer_name == "adamw":
+        raise NotImplementedError
+
+    ### amp half precision
+    if cfg.train_test.half and not cfg.train_test.evaluate:
+        model, optimizer = amp.initialize(model, optimizer, opt_level="O1")
+    model = nn.DataParallel(model)
+
+    ### Resume if training <accidentally stops/enters next phase>
+    if cfg.train_test.resume:
+        prev_model_dir = os.path.normpath(Path(cwd) / cfg.train_test.resume)
+        if os.path.isfile(prev_model_dir):
+            log.info(f"=> loading checkpoint '{prev_model_dir}'")
+            ckpt = torch.load(prev_model_dir)
+            start_epoch = ckpt["epoch"]
+            best_prec1 = ckpt["best_prec1"]
+            model.load_state_dict(ckpt["state_dict"])
+            optimizer.load_state_dict(ckpt["optimizer"])
+    else:
+        log.info(f"=> no checkpoint found at '{cfg.train_test.resume}'")
+        start_epoch = cfg.train_test.start_epoch
+
+    ### Load dataset
+    train_loader, test_loader = get_datasets(cfg)
+
+    ### Evaluate/Test
+    if cfg.train_test.evaluate:
+        if cfg.attack.test.name == "pgd":
+            log.info(pad_str(" Performing PGD Attacks "))
+            test_pgd(model, test_loader, criterion, device, cfg, log)
+            test_natural(model, test_loader, criterion, device, cfg, log)
+        elif cfg.attack.test.name == "aa":
+            model.eval()
+            test_aug = list()
+            if cfg.train_test.mode == "at_pgd":
+                if cfg.dataset.dataset == "imagenet":
+                    test_aug.append(transforms.Resize(256))
+                elif cfg.dataset.dataset == "cifar10":
+                    test_aug.append(transforms.Resize(cfg.train_test.crop_size))
+            test_aug.extend([
+                transforms.CenterCrop(cfg.train_test.crop_size),
+                transforms.ToTensor(),
+            ])
+            test_transform = transforms.Compose(test_aug)
+            log.info(benchmark(
+                model,
+                dataset=cfg.dataset.dataset,
+                data_dir=cfg.dataset.data_dir,
+                device=device,
+                batch_size=cfg.attack.test.batch_size,
+                eps=cfg.attack.test.eps / 255.,
+                preprocessing=test_transform,
+                n_examples=cfg.attack.test.n_examples,
+                threat_model="Linf" if cfg.attack.test.norm == "linf" else cfg.attack.test.norm
+            ))
+
+        return
+
+    # visualization
+    if cfg.visualization.tool == "wandb":
+        log.info(f"=> Visualization with wandb")
+        wandb.init(project=cfg.visualization.project, entity=cfg.visualization.entity, resume=True)
+        wandb.run.name = cfg.name
+
+    # trained model dir (add if)
+    model_dir = Path(cwd) / cfg.train_test.model_dir
+    if cfg.train_test.mode == "fat":
+        model_dir = model_dir / cfg.train_test.phase
+    model_dir.mkdir(parents=True, exist_ok=True)
+
+    # lr + eps schedule
+    eps_schedule = None
+    if cfg.train_test.mode == "fat":
+        lr_schedule = lambda t: np.interp(t, cfg.train_test.lr_epochs, cfg.train_test.lr_values)
+        total_epochs = cfg.train_test.end_epoch
+    else:
+        total_epochs = cfg.train_test.end_epoch - cfg.train_test.start_epoch
+        if cfg.train_test.schedule.lower() == "cosine":
+            lr_schedule = CosineLRScheduler(
+                optimizer,
+                t_initial=total_epochs,
+                lr_min=cfg.train_test.min_lr,
+                warmup_lr_init=cfg.train_test.warmup_lr,
+                warmup_t=cfg.train_test.warmup_epochs,
+                cycle_mul=cfg.train_test.lr_cycle_mul,
+                cycle_decay=cfg.train_test.lr_cycle_decay,
+                cycle_limit=cfg.train_test.lr_cycle_limit,
+            )
+        elif cfg.train_test.schedule.lower() == "step":
+            lr_schedule = StepLRScheduler(
+                optimizer,
+                decay_t=cfg.train_test.decay_t,
+                decay_rate=cfg.train_test.decay_rate,
+                warmup_t=cfg.train_test.warmup_epochs,
+                warmup_lr_init=cfg.train_test.warmup_lr,
+            )
+        total_epochs = total_epochs + cfg.train_test.cooldown_epochs
+
+        # eps schedule
+        if cfg.attack.train.eps_schedule and cfg.attack.train.eps_schedule.lower() == "linear" and cfg.attack.train.eps_schedule_epochs:
+            eps_schedule = make_linear_schedule(1.0 * cfg.attack.train.eps / cfg.dataset.max_color_value, cfg.attack.train.eps_schedule_epochs, cfg.attack.train.zero_eps_epochs)
+
+    ### Train
+    best_prec1 = 0.
+    for epoch in range(start_epoch, total_epochs):
+        # Train one epoch
+        train(model, train_loader, optimizer, criterion, lr_schedule, epoch, device, cfg, log, eps_schedule)
+
+        # Test natural accuracy
+        prec1 = test_natural(model, test_loader, criterion, device, cfg, log)
+
+        if cfg.visualization.tool == "wandb":
+            wandb.log({"Test natural accuracy": prec1}, step=epoch)
+
+        # Save checkpoint based on best natural accuracy
+        is_best = prec1 > best_prec1
+        best_prec1 = max(prec1, best_prec1)
+        model_info = dict(
+            tag=cfg.name,
+            best_prec1=best_prec1,
+            epoch=epoch + 1,
+            state_dict=model.state_dict(),
+            optimizer=optimizer.state_dict()
+        )
+        save_checkpoint(model_info, model_dir, is_best)
+
+
+if __name__ == "__main__":
+    main()

utils.py

@@ -0,0 +1,239 @@
+from typing import List, Dict, Tuple, Callable
+import torch
+import os
+import torch.nn as nn
+from pathlib import Path
+from torch.utils.data import DataLoader
+import torchvision.transforms as transforms
+import torchvision.datasets as datasets
+import shutil
+
+IMAGENET_PCA = {
+    'eigval': torch.Tensor([0.2175, 0.0188, 0.0045]),
+    'eigvec': torch.Tensor([
+        [-0.5675,  0.7192,  0.4009],
+        [-0.5808, -0.0045, -0.8140],
+        [-0.5836, -0.6948,  0.4203],
+    ])
+}
+
+class Lighting(object):
+    """
+    Lighting noise (see https://git.io/fhBOc)
+    https://github.com/MadryLab/robustness/blob/a9541241defd9972e9334bfcdb804f6aefe24dc7/robustness/data_augmentation.py#L18
+    """
+    def __init__(self, alphastd, eigval, eigvec):
+        self.alphastd = alphastd
+        self.eigval = eigval
+        self.eigvec = eigvec
+
+    def __call__(self, img):
+        if self.alphastd == 0:
+            return img
+
+        alpha = img.new().resize_(3).normal_(0, self.alphastd)
+        rgb = self.eigvec.type_as(img).clone()\
+            .mul(alpha.view(1, 3).expand(3, 3))\
+            .mul(self.eigval.view(1, 3).expand(3, 3))\
+            .sum(1).squeeze()
+
+        return img.add(rgb.view(3, 1, 1).expand_as(img))
+
+class PSiLU(nn.Module):
+    def __init__(self, alpha: float = 1.0, device=None, dtype=None) -> None:
+        super().__init__()
+        factory_kwargs = {'device': device, 'dtype': dtype}
+        self.alpha = nn.Parameter(torch.empty(1, **factory_kwargs).fill_(alpha))
+
+    def forward(self, x: torch.Tensor) -> torch.Tensor:
+        return x * torch.sigmoid(self.alpha * x)
+
+class PSSiLU(nn.Module):
+    def __init__(self, alpha: float = 1.0, beta: float = 1e-4, device=None, dtype=None) -> None:
+        super().__init__()
+        factory_kwargs = {'device': device, 'dtype': dtype}
+        self.alpha = nn.Parameter(torch.empty(1, **factory_kwargs).fill_(alpha))
+        self.beta = nn.Parameter(torch.empty(1, **factory_kwargs).fill_(beta))
+
+    def forward(self, x: torch.Tensor) -> torch.Tensor:
+        self.beta.data = torch.clamp(self.beta.data, 0., 1.)
+        return x * (torch.sigmoid(self.alpha * x) - self.beta) / (1. - self.beta + 1e-6)
+class AverageMeter(object):
+    """Computes and stores the average and current value"""
+
+    def __init__(self):
+        self.reset()
+
+    def reset(self):
+        self.val = 0
+        self.avg = 0
+        self.sum = 0
+        self.count = 0
+
+    def update(self, val: float, n: int = 1):
+        self.val = val
+        self.sum += val * n
+        self.count += n
+        self.avg = self.sum / self.count
+
+def accuracy(output: torch.Tensor, target: torch.Tensor, topk: tuple = (1, 5)) -> List[float]:
+    """Computes the accuracy over the k top predictions for the specified values of k"""
+
+    with torch.no_grad():
+        maxk = max(topk)
+        batch_size = target.shape[0]
+
+        _, pred = output.topk(k=maxk, dim=1, largest=True, sorted=True)
+        pred = pred.t()
+        correct = pred.eq(target.view(1, -1).expand_as(pred))
+
+        res = []
+        for k in topk:
+            correct_k = correct[:k].flatten().float().sum(0)
+            res.append(correct_k.mul_(100.0 / batch_size))
+    return res
+
+def configure_optimizers(model: nn.Module) -> List[Dict]:
+    """
+    all normalization params and all bias shouldn't be weight decayed
+    code adapted from https://github.com/karpathy/minGPT/blob/3ed14b2cec0dfdad3f4b2831f2b4a86d11aef150/mingpt/model.py#L136  
+    """
+    decay = set()
+    no_decay = set()
+    weight_decay_blacklist = (nn.BatchNorm2d, nn.LayerNorm, nn.InstanceNorm2d, nn.PReLU, PSiLU, PSSiLU)
+    for mn, m in model.named_modules():
+        for pn, p in m.named_parameters(recurse=False):
+            full_name = f"{mn}.{pn}" if mn else pn
+            if pn.endswith("bias"):
+                # all biases are not decayed
+                no_decay.add(full_name)
+            elif pn.endswith("weight") and isinstance(m, weight_decay_blacklist):
+                # weights of blacklist are not decayed
+                no_decay.add(full_name)
+            else:
+                decay.add(full_name)
+
+    # assert all parameters are considered
+    param_dict = {pn: p for pn, p in model.named_parameters()}
+    inter_params = decay & no_decay
+    union_params = decay | no_decay
+    assert len(inter_params) == 0, f"parameters {str(inter_params)} made it into both decay/no_decay sets!"
+    assert len(param_dict.keys() - union_params) == 0, f"parameters {str(param_dict.keys() - union_params)} were not separated into either decay/no_decay set!"
+
+    optim_group = list([
+        {"params": [param_dict[fpn] for fpn in sorted(list(decay))]},
+        {"params": [param_dict[fpn] for fpn in sorted(list(no_decay))], "weight_decay": 0.0},
+    ])
+
+    return optim_group
+
+def get_cifar10(root_dir: str, batch_size: int, workers: int, crop_size: int) -> List[DataLoader]:
+    """
+    The transforms follow the robustness library: https://github.com/MadryLab/robustness/blob/a9541241defd9972e9334bfcdb804f6aefe24dc7/robustness/data_augmentation.py#L68
+    """
+    train_transform = transforms.Compose([
+        transforms.RandomCrop(crop_size, padding=4),
+        transforms.RandomHorizontalFlip(),
+        transforms.ColorJitter(.25, .25, .25),
+        transforms.RandomRotation(2),
+        transforms.ToTensor(),
+    ])
+
+    test_transform = transforms.Compose([
+        transforms.Resize(crop_size),
+        transforms.CenterCrop(crop_size),
+        transforms.ToTensor()
+    ])
+
+    train_dataset = datasets.CIFAR10(root=root_dir, train=True, download=True, transform=train_transform)
+    test_dataset = datasets.CIFAR10(root=root_dir, train=False, download=True, transform=test_transform)
+
+    train_loader =  DataLoader(train_dataset, batch_size=batch_size, shuffle=True, num_workers=workers, pin_memory=True)
+    test_loader = DataLoader(test_dataset, batch_size=batch_size, shuffle=True, num_workers=workers, pin_memory=True)
+
+    return train_loader, test_loader
+
+def get_imagenet(data_dir: str, batch_size: int, workers: int, crop_size: int, color_jitter: float = 0., use_lighting: bool = False, mode: str = "fat") -> List[DataLoader]:
+    train_aug = list([
+        transforms.RandomResizedCrop(crop_size),
+        transforms.RandomHorizontalFlip(),
+    ])
+
+    if color_jitter > 0:
+        cj = (float(color_jitter),) * 3
+        train_aug.append(transforms.ColorJitter(*cj))
+
+    train_aug.append(transforms.ToTensor())
+
+    if use_lighting:
+        train_aug.append(Lighting(0.05, IMAGENET_PCA['eigval'], IMAGENET_PCA['eigvec']))
+
+    train_transform = transforms.Compose(train_aug)
+
+    test_aug = list()
+
+    # Test Transform is exactly the same as `robustness` library
+    if mode == "at_pgd":
+        test_aug.append(transforms.Resize(256))
+    test_aug.extend([
+        transforms.CenterCrop(crop_size),
+        transforms.ToTensor(),
+    ])
+
+    test_transform = transforms.Compose(test_aug)
+
+    train_path = os.path.join(data_dir, 'train')
+    test_path = os.path.join(data_dir, 'val')
+
+    train_dataset = datasets.ImageFolder(root=train_path, transform=train_transform)
+    test_dataset = datasets.ImageFolder(root=test_path, transform=test_transform)
+
+    train_loader = DataLoader(train_dataset, batch_size=batch_size, shuffle=True, num_workers=workers, pin_memory=True)
+    test_loader = DataLoader(test_dataset, batch_size=batch_size, shuffle=False, num_workers=workers, pin_memory=True)
+
+    return train_loader, test_loader
+
+
+def get_datasets(cfg):
+    if cfg.dataset.dataset == "imagenet":
+        return get_imagenet(
+            data_dir=cfg.dataset.data_dir,
+            batch_size=cfg.train_test.batch_size,
+            workers=cfg.train_test.workers,
+            crop_size=cfg.train_test.crop_size,
+            color_jitter=cfg.train_test.color_jitter,
+            use_lighting=cfg.train_test.lighting,
+            mode=cfg.train_test.mode,
+        )
+    elif cfg.dataset.dataset == "cifar10":
+        return get_cifar10(
+            root_dir=cfg.dataset.data_dir,
+            batch_size=cfg.train_test.batch_size,
+            workers=cfg.train_test.workers,
+            crop_size=cfg.train_test.crop_size,
+        )
+
+def pad_str(msg: str, total_len: int=80) -> str:
+    rem_len = total_len - len(msg)
+    return f"{'*' * (rem_len // 2)}{msg}{'*' * (rem_len // 2)}"
+
+def save_checkpoint(model_info: dict, filepath: Path, is_best: bool):
+    filename = filepath / f"ckpt_epoch{model_info['epoch']}.pt"
+    torch.save(model_info, filename)
+    if is_best:
+        shutil.copyfile(filename, filepath / "model_best.pt")
+
+def compute_total_parameters(model: nn.Module) -> float:
+    # return # of parameters in million
+    pytorch_total_params = sum(p.numel() for p in model.parameters())
+    return pytorch_total_params / 1e6
+
+# linear scheduling for eps
+def make_linear_schedule(final: float, warmup: int, zero_eps_epochs: int) -> Callable[[int], float]:
+    def linear_schedule(step: int) -> float:
+        if step < zero_eps_epochs:
+            return 0.0
+        if step < warmup:
+            return (step - zero_eps_epochs) / warmup * final
+        return final
+    return linear_schedule