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}")