Hello everyone,
I am a math student and I managed to create my first deep neural network (named “Net()”) for ‘CIFAR-10’. Now I tried to use “torchvision.modules.resnet18” instead and I get the following errors in my report file:
Report file (trimmed)
Precompute adversarial examples.: 0%| | 0/1 [00:00<?, ?it/s]
Precompute adversarial examples.: 100%|██████████| 1/1 [00:00<00:00, 22310.13it/s]
Adversarial training epochs: 0%| | 0/2 [00:00<?, ?it/s]
Adversarial training epochs: 0%| | 0/2 [00:00<?, ?it/s]
50000
Loaded data.
Loaded model.
Traceback (most recent call last):
File "AlternativModel1.py", line 115, in <module>
trainer.fit_generator(train_generator, nb_epochs=num_epochs)
File "/cluster/home/lgraz/RDNN/rdnn-env/lib64/python3.7/site-packages/art/defences/trainer/adversarial_trainer.py", line 167, in fit_generator
x_batch[adv_ids] = attack.generate(x_batch[adv_ids], y=y_batch[adv_ids])
File "/cluster/home/lgraz/RDNN/rdnn-env/lib64/python3.7/site-packages/art/attacks/attack.py", line 74, in replacement_function
return fdict[func_name](self, *args, **kwargs)
File "/cluster/home/lgraz/RDNN/rdnn-env/lib64/python3.7/site-packages/art/attacks/evasion/fast_gradient.py", line 227, in generate
batch_size=self.batch_size,
File "/cluster/home/lgraz/RDNN/rdnn-env/lib64/python3.7/site-packages/art/utils.py", line 581, in compute_success
attack_success = compute_success_array(classifier, x_clean, labels, x_adv, targeted, batch_size)
File "/cluster/home/lgraz/RDNN/rdnn-env/lib64/python3.7/site-packages/art/utils.py", line 551, in compute_success_array
adv_preds = np.argmax(classifier.predict(x_adv, batch_size=batch_size), axis=1)
File "/cluster/home/lgraz/RDNN/rdnn-env/lib64/python3.7/site-packages/art/estimators/classification/classifier.py", line 71, in replacement_function
return fdict[func_name](self, *args, **kwargs)
File "/cluster/home/lgraz/RDNN/rdnn-env/lib64/python3.7/site-packages/art/estimators/classification/pytorch.py", line 204, in predict
results[begin:end] = output.detach().cpu().numpy()
ValueError: could not broadcast input array from shape (32,1000) into shape (32,10)
Here is my source-code
"""
We recommend using a more complex model,
such as a ResNet (available in torchvision) and more complex attacks/defenses.
"""
import torch
import torch.nn as nn
import torchvision.models as models
import torchvision.datasets as datasets
import torch.nn.functional as F
import torch.optim as optim
import torch.utils.data as data
from torchvision import transforms
import numpy as np
from art.attacks.evasion import FastGradientMethod
from art.defences.trainer import AdversarialTrainer
from art.estimators.classification import PyTorchClassifier
import rdnn.torch
# Step 0: initialize some parameters that we will use later, as well as the dataset
batch_size = 128
num_epochs = 2
learning_rate = 1e-3
num_classes = 10 ##################################
# We use data augmentation to increase the test accuracy of our classifier
transform_train = transforms.Compose([
transforms.RandomHorizontalFlip(),
transforms.RandomRotation(15),
transforms.RandomAffine(degrees=0, translate=(0, 5./32)),
transforms.ToTensor(),
])
transform_test = transforms.Compose([
transforms.ToTensor(),
])
# Initialize the training and test datasets
train_dataset = rdnn.torch.CifarDataset(train=True, transform=transform_train)
train_dataloader = data.DataLoader(train_dataset, batch_size=batch_size, shuffle=True)
print(len(train_dataset))
train_generator = rdnn.torch.CustomDataGenerator(train_dataloader, size=len(train_dataset), batch_size=batch_size)
test_dataset = rdnn.torch.CifarDataset(train=False, transform=transform_test)
x_test = test_dataset.get_x()
y_test = test_dataset.get_y()
print("Loaded data.")
# Define Module Architecture
class Net(nn.Module):
def __init__(self):
super(Net, self).__init__()
self.conv1 = nn.Conv2d(3, 32, kernel_size=3, stride=2, padding=1)
self.pool1 = nn.MaxPool2d(2, 2)
self.conv2 = nn.Conv2d(32, 64, kernel_size=3, stride=1, padding=1)
self.pool2 = nn.MaxPool2d(2, 2)
self.conv3 = nn.Conv2d(64, 56, kernel_size=3, stride=1, padding=1)
self.dropout = nn.Dropout(0.2)
self.fc1 = nn.Linear(56 * 4 * 4, 512)
self.fc2 = nn.Linear(512, 256)
self.fc3 = nn.Linear(256, 10)
def forward(self, x):
x = self.pool1(F.relu(self.conv1(x)))
x = self.pool2(F.leaky_relu(self.conv2(x), negative_slope=0.1))
x = F.relu(self.conv3(x))
x = x.view(-1, 56 * 4 * 4)
x = self.dropout(x)
x = F.relu(self.fc1(x))
x = F.relu(self.fc2(x))
x = self.fc3(x)
return x
'''
instead of Net(), I would like to use resnet18()
what am I doing wrong?
'''
# model = Net()
model = models.resnet18()
model.train()
print("Loaded model.")
criterion = nn.CrossEntropyLoss()
optimizer = optim.Adam(model.parameters(), lr=learning_rate)
# Create the ART wrapper classifier (an instance of PyTorchClassifier).
classifier = PyTorchClassifier(
model=model,
clip_values=None,
loss=criterion,
optimizer=optimizer,
input_shape=(3, 32, 32),
nb_classes=10,
)
# Step 4: Train your classifier with natural examples
classifier.fit_generator(train_generator, nb_epochs=num_epochs)
# Create an FGSM attack. To do this, you should first create an instance
attacks = FastGradientMethod(estimator=classifier, eps=0.03)
# ======= Only fill in this step after having trained your classifier naturally =======
# Step 5: Train a robust classifier.
# Once that is done, we will use ART's AdversarialTrainer class to train your model using the
# attack you defined for 10 epochs with a batch size of 128. Use 0.5 for the ratio of adversarial
# examples to natural examples.
trainer = AdversarialTrainer(classifier, attacks, ratio=0.5)
trainer.fit_generator(train_generator, nb_epochs=num_epochs)
# =====================================================================================
# Step 6: Save model checkpoint using the util code introduced in the tutorial.
rdnn.torch.save_model(model, optimizer, num_epochs, name="my_second_checkpoint")
model.eval()
eval_attacks = FastGradientMethod(estimator=classifier, eps=0.03)
# Step 7: Evaluate the ART classifier on natural test examples and find the accuracy
x_test_adv = eval_attacks.generate(x_test)
predictions = classifier.predict(x_test)
accuracy = np.sum(np.argmax(predictions, axis=1) == y_test) / len(y_test)
print("Accuracy on benign test examples: {}%".format(accuracy * 100))
predictions_adv = classifier.predict(x_test_adv)
accuracy_adv = np.sum(np.argmax(predictions_adv, axis=1) == y_test) / len(y_test)
print("Accuracy on adversarial examples: {}%".format(accuracy_adv * 100))