def get_architecture(arch: str, dataset: str) -> torch.nn.Module:
""" Return a neural network (with random weights)
:param arch: the architecture - should be in the ARCHITECTURES list above
:param dataset: the dataset - should be in the datasets.DATASETS list
:return: a Pytorch module
"""
if arch == "resnet50" and dataset in ["imagenet", "restricted_imagenet"]:
model = resnet50(pretrained=False)
if dataset == "restricted_imagenet":
model.fc = torch.nn.Linear(in_features=2048,
out_features=10,
bias=True)
model = torch.nn.DataParallel(model).cuda()
cudnn.benchmark = True
elif arch == "cifar_resnet20":
model = resnet_cifar(depth=20, num_classes=10).cuda()
elif arch == "cifar_resnet110":
model = resnet_cifar(depth=110, num_classes=10).cuda()
elif arch == "imagenet32_resnet110":
model = resnet_cifar(depth=110, num_classes=1000).cuda()
# Both layers work fine, We tried both, and they both
# give very similar results
# IF YOU USE ONE OF THESE FOR TRAINING, MAKE SURE
# TO USE THE SAME WHEN CERTIFYING.
normalize_layer = get_normalize_layer(dataset)
# normalize_layer = get_input_center_layer(dataset)
if dataset == 'cifar10':
V = VingetteModule((3, 32, 32), 'circ', 2).to('cuda')
else:
V = VingetteModule((3, 224, 224), 'circ', 2).to('cuda')
return torch.nn.Sequential(V, normalize_layer, model)
def get_architecture(arch: str, dataset: str, device) -> torch.nn.Module:
""" Return a neural network (with random weights)
:param arch: the architecture - should be in the ARCHITECTURES list above
:param dataset: the dataset - should be in the datasets.DATASETS list
:return: a Pytorch module
"""
if arch == "resnet50" and dataset == "imagenet":
model = torch.nn.DataParallel(resnet50(pretrained=False)).to(device)
cudnn.benchmark = True
elif arch == "cifar_resnet20":
model = resnet_cifar(depth=20, num_classes=10).to(device)
elif arch == "cifar_resnet32":
model = resnet_cifar(depth=32, num_classes=10).to(device)
elif arch == "cifar_resnet110":
model = resnet_cifar(depth=110, num_classes=10).to(device)
elif arch == "lenet300":
model = lenet300(num_classes=10).to(device)
elif arch == "lenet5":
model = lenet5(num_classes=10).to(device)
elif arch == "fcn":
model = fcn(num_classes=10).to(device)
elif arch == "vgg19":
model = vgg().to(device)
elif arch == "vgg16":
model = vgg_16().to(device)
elif arch == "wide_resnet":
model = wide_resnet().to(device)
elif arch == "resnet20":
model = resnet20().to(device)
elif arch == "resnet32":
model = resnet32().to(device)
return model
def get_architecture(arch: str) -> torch.nn.Module:
""" Return a neural network (with random weights)
:param arch: the architecture - should be in the ARCHITECTURES list above
:param dataset: the dataset - should be in the datasets.DATASETS list
:return: a Pytorch module
"""
if arch == "cifar_resnet20":
model = resnet_cifar(depth=20, num_classes=10).cuda()
elif arch == "cifar_resnet110":
model = resnet_cifar(depth=110, num_classes=10).cuda()
normalize_layer = NormalizeLayer(_CIFAR10_MEAN, _CIFAR10_STDDEV)
return torch.nn.Sequential(normalize_layer, model)
def get_architecture(arch: str, dataset: str) -> torch.nn.Module:
""" Return a neural network (with random weights)
:param arch: the architecture - should be in the ARCHITECTURES list above
:param dataset: the dataset - should be in the datasets.DATASETS list
:return: a Pytorch module
"""
ORDERED_CLASS_LABELS = ['airplane', 'automobile', 'bird', 'cat', 'deer', 'dog', 'frog', 'horse', 'ship', 'truck']
if arch == "resnet50" and dataset == "imagenet":
model = torch.nn.DataParallel(resnet50(pretrained=False)).cuda()
cudnn.benchmark = True
elif arch == "cifar_resnet20":
model = DeepCNN(len(ORDERED_CLASS_LABELS))
# model = resnet_cifar(depth=20, num_classes=10).cuda()
elif arch == "cifar_resnet110":
model = DeepCNN(len(ORDERED_CLASS_LABELS))
# model = resnet_cifar(depth=110, num_classes=10).cuda()
elif arch == "imagenet32_resnet110":
model = resnet_cifar(depth=110, num_classes=1000).cuda()
# Both layers work fine, We tried both, and they both
# give very similar results
# IF YOU USE ONE OF THESE FOR TRAINING, MAKE SURE
# TO USE THE SAME WHEN CERTIFYING.
normalize_layer = get_normalize_layer(dataset)
# normalize_layer = get_input_center_layer(dataset)
return torch.nn.Sequential(normalize_layer, model)
def get_architecture(arch: str, dataset: str) -> torch.nn.Module:
""" Return a neural network (with random weights)
:param arch: the architecture - should be in the ARCHITECTURES list above
:param dataset: the dataset - should be in the datasets.DATASETS list
:return: a Pytorch module
"""
if arch == "resnet50" and dataset == "imagenet":
model = torch.nn.DataParallel(resnet50(pretrained=False)).cuda()#resnet50(pretrained=False)
cudnn.benchmark = True
elif arch == "cifar_resnet20":
model = resnet_cifar(depth=20, num_classes=10).cuda()
elif arch == "cifar_resnet110":
model = resnet_cifar(depth=110, num_classes=10).cuda()
normalize_layer = get_normalize_layer(dataset)
return torch.nn.Sequential(normalize_layer, model)#torch.nn.DataParallel(torch.nn.Sequential(normalize_layer, model))#
def main():
# init model, other architectures can be also used here for training
model = resnet_cifar(depth=110, num_classes=10).to(device)
model = nn.DataParallel(model)
optimizer = optim.SGD(model.parameters(),
lr=args.lr,
momentum=args.momentum,
weight_decay=args.weight_decay)
for epoch in range(0, args.epochs + 1):
# adjust learning rate for SGD
adjust_learning_rate(optimizer, epoch)
# adversarial training
train(args, model, device, train_loader, optimizer, epoch)
# evaluation on natural examples
print(
'================================================================')
eval_train(model, device, train_loader)
eval_test(model, device, test_loader)
# save checkpoint
torch.save(model.state_dict(),
os.path.join(model_dir, 'model-res110-epoch.pt'))
torch.save(optimizer.state_dict(),
os.path.join(model_dir, 'opt-res110-checkpoint-epoch.tar'))
print(
'================================================================')
def get_architecture(arch: str,
dataset: str,
pytorch_pretrained: bool = False) -> torch.nn.Module:
""" Return a neural network (with random weights)
:param arch: the architecture - should be in the ARCHITECTURES list above
:param dataset: the dataset - should be in the datasets.DATASETS list
:return: a Pytorch module
"""
## ImageNet classifiers
if arch == "resnet18" and dataset == "imagenet":
model = torch.nn.DataParallel(
resnet18(pretrained=pytorch_pretrained)).cuda()
cudnn.benchmark = True
elif arch == "resnet34" and dataset == "imagenet":
model = torch.nn.DataParallel(
resnet34(pretrained=pytorch_pretrained)).cuda()
cudnn.benchmark = True
elif arch == "resnet50" and dataset == "imagenet":
model = torch.nn.DataParallel(
resnet50(pretrained=pytorch_pretrained)).cuda()
cudnn.benchmark = True
## Cifar classifiers
elif arch == "cifar_resnet20":
model = resnet_cifar(depth=20, num_classes=10).cuda()
elif arch == "cifar_resnet110":
model = resnet_cifar(depth=110, num_classes=10).cuda()
elif arch == "imagenet32_resnet110":
model = resnet_cifar(depth=110, num_classes=1000).cuda()
elif arch == "imagenet32_wrn":
model = WideResNet(depth=28, num_classes=1000, widen_factor=10).cuda()
# Cifar10 Models from https://github.com/kuangliu/pytorch-cifar
# The 14 models we use in the paper as surrogate models
elif arch == "cifar_wrn":
model = WideResNet(depth=28, num_classes=10, widen_factor=10).cuda()
elif arch == "cifar_wrn40":
model = WideResNet(depth=40, num_classes=10, widen_factor=10).cuda()
elif arch == "VGG16":
model = VGG('VGG16').cuda()
elif arch == "VGG19":
model = VGG('VGG19').cuda()
elif arch == "ResNet18":
model = ResNet18().cuda()
elif arch == "PreActResNet18":
model = PreActResNet18().cuda()
elif arch == "GoogLeNet":
model = GoogLeNet().cuda()
elif arch == "DenseNet121":
model = DenseNet121().cuda()
elif arch == "ResNeXt29_2x64d":
model = ResNeXt29_2x64d().cuda()
elif arch == "MobileNet":
model = MobileNet().cuda()
elif arch == "MobileNetV2":
model = MobileNetV2().cuda()
elif arch == "SENet18":
model = SENet18().cuda()
elif arch == "ShuffleNetV2":
model = ShuffleNetV2(1).cuda()
elif arch == "EfficientNetB0":
model = EfficientNetB0().cuda()
## Image Denoising Architectures
elif arch == "cifar_dncnn":
model = DnCNN(image_channels=3, depth=17, n_channels=64).cuda()
return model
elif arch == "cifar_dncnn_wide":
model = DnCNN(image_channels=3, depth=17, n_channels=128).cuda()
return model
elif arch == 'memnet':
model = MemNet(in_channels=3,
channels=64,
num_memblock=3,
num_resblock=6).cuda()
return model
elif arch == "imagenet_dncnn":
model = torch.nn.DataParallel(
DnCNN(image_channels=3, depth=17, n_channels=64)).cuda()
cudnn.benchmark = True
return model
elif arch == 'imagenet_memnet':
model = torch.nn.DataParallel(
MemNet(in_channels=3, channels=64, num_memblock=3,
num_resblock=6)).cuda()
cudnn.benchmark = True
return model
else:
raise Exception('Unknown architecture.')
normalize_layer = get_normalize_layer(dataset)
return torch.nn.Sequential(normalize_layer, model)
"""
h = img.size(1)
w = img.size(2)
mask = np.ones((h, w), np.float32)
mask = torch.from_numpy(mask)
mask = mask.repeat(3, 1, 1)
return mask
if __name__ == "__main__":
# load the base classifier
# base_classifier = WideResNet().cuda()
base_classifier = resnet_cifar(depth=110, num_classes=10).to(device)
base_classifier = nn.DataParallel(base_classifier)
base_classifier.load_state_dict(torch.load(args.load_dir))
# create the smooothed classifier g
smoothed_classifier = Smooth(base_classifier,
get_num_classes(args.dataset), args.sigma)
# prepare output file
f = open(args.outfile, 'w')
print("idx\tlabel\tpredict\tradius\tcorrect\ttime", file=f, flush=True)
# iterate through the dataset
dataset = get_dataset(args.dataset, args.split, args.imagesize)
for i in tqdm(range(len(dataset))):
