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 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()