def create():
url = 'https://storage.googleapis.com/luizgh-datasets/avc_models/resnext50_32x4d_ddn.pt'
weights_path = zoo.fetch_weights(url)
state_dict = torch.load(weights_path)
image_mean = torch.tensor([0.4802, 0.4481, 0.3975]).view(1, 3, 1, 1)
image_std = torch.tensor([0.2770, 0.2691, 0.2821]).view(1, 3, 1, 1)
m = resnext50_32x4d()
model = NormalizedModel(model=m, mean=image_mean, std=image_std)
model.load_state_dict(state_dict)
model.eval()
fmodel = foolbox.models.PyTorchModel(model, (0, 1), num_classes=200)
return fmodel
# Data loading code
args = parser.parse_args()
start_time = time.time()
img = imread(args.attack_image)
path = args.data
print(args.targeted)
if args.targeted == 0:
image_mean = torch.tensor([0.4802, 0.4481, 0.3975]).view(1, 3, 1, 1)
image_std = torch.tensor([0.2770, 0.2691, 0.2821]).view(1, 3, 1, 1)
m = resnet18()
attacks = [
DDN(100, device=device),
]
model = NormalizedModel(m, image_mean, image_std)
state_dict = torch.load(args.model_path)
model.load_state_dict(state_dict)
model.eval().to(device)
def black_box_model(img):
t_img = torch.from_numpy(img).float().div(255).permute(2, 0, 1)
t_img = t_img.unsqueeze(0).to(device)
with torch.no_grad():
return model(t_img).argmax()
smodel = resnext50_32x4d()
smodel = NormalizedModel(smodel, image_mean, image_std)
state_dict = torch.load(args.surrogate_model_path)
smodel.load_state_dict(state_dict)
smodel.eval().to(device)
surrogate_models = [smodel]
label = black_box_model(img)
print('Epoch {} | Validation | Loss: {:.4f}, Accs: {:.4f}'.format(
epoch, val_losses.avg, val_accs.avg))
if val_accs.avg >= best_acc:
best_acc = val_accs.avg
best_epoch = epoch
best_dict = model.state_dict()
if not (epoch + 1) % args.save_freq:
save_checkpoint(model.state_dict(),
os.path.join(
args.save_folder,
args.save_name + '_{}.pth'.format(epoch + 1)),
cpu=True)
model.load_state_dict(best_dict)
test_accs = AverageMeter()
test_losses = AverageMeter()
with torch.no_grad():
for i, (images, labels) in enumerate(tqdm.tqdm(test_loader, ncols=80)):
images, labels = images.to(DEVICE), labels.to(DEVICE)
logits = model(images)
loss = F.cross_entropy(logits, labels)
test_accs.append((logits.argmax(1) == labels).float().mean().item())
test_losses.append(loss.item())
print('\nTest accuracy with model from epoch {}: {:.4f} with loss: {:.4f}'.
])
test_set = CIFAR10(args.data,
train=False,
transform=test_transform,
download=True)
test_loader = data.DataLoader(test_set,
batch_size=50,
shuffle=True,
num_workers=args.workers,
pin_memory=True)
m = wide_resnet(num_classes=10, depth=28, widen_factor=10)
model = NormalizedModel(model=m, mean=image_mean, std=image_std).to(DEVICE)
model_dict = model.load_state_dict(torch.load('./model/cifar10_wrn.pth'))
if torch.cuda.device_count() > 1:
model = torch.nn.DataParallel(model)
#attacker = FGSM(eps=0.3, device=DEVICE)
#attacker = IFGSM(steps=20,eps=0.3,eps_iter=0.1, device=DEVICE)
#attacker = PGD(steps=20,eps=4,eps_iter=3, device=DEVICE)
attacker = BP(steps=100, device=DEVICE)
#attacker = DDN(steps=100, device=DEVICE)
requires_grad_(model, True)
model.eval()
ori_image = np.zeros((10000, 3, 32, 32))
ori_label = np.zeros((10000, 1))
adv_image = np.zeros((10000, 3, 32, 32))
# model = resnet101_denoise().to(DEVICE)
# weight = '../defenses/weights/adv_denoise_model/Adv_Denoise_Resnext101.pytorch'
# loaded_state_dict = torch.load(weight)
# model.load_state_dict(loaded_state_dict, strict=True)
# model = models.inception_v3(pretrained=True).to(DEVICE).eval()
model1 = models.resnet152(pretrained=False)
model1 = NormalizedModel(model=model1, mean=image_mean, std=image_std)
# model = EfficientNet.from_pretrained("efficientnet-b8", advprop=True).to(DEVICE).eval()
# model = NormalizedModel(model=model, mean=image_mean, std=image_std).to(DEVICE).eval()
weight = '../defenses/weights/imagenet_resnet152_jpeg/Imagenetacc0.9553571428571429_20.pth'
loaded_state_dict = torch.load(weight)
model1.load_state_dict(loaded_state_dict)
# model2 = models.inception_v3(pretrained=False)
#
# model2 = NormalizedModel(model=model2, mean=image_mean, std=image_std)
# weight = '../defenses/weights/imagenet_inception_v3_jpeg/'
# loaded_state_dict = torch.load(weight)
# model2.load_state_dict(loaded_state_dict)
class Ensemble(torch.nn.Module):
def __init__(self, model1, model2):
super(Ensemble, self).__init__()
self.model1 = model1
self.model2 = model2