def net_generation_and_train(X_train, y_train, net_type):
loss = nn.CrossEntropyLoss()
net = net_type(n_features=2, n_classes=2)
optimizer = optim.SGD(net.parameters(),
lr=0.1, momentum=0.9)
clf = PyTorchClassifier(model=net, loss=loss, input_shape=(1,2),
nb_classes=2, optimizer=optimizer)
clf.fit(X_train, y_train, batch_size=10, nb_epochs=100)
return clf
def test_pickle(art_warning, get_default_mnist_subset, image_dl_estimator):
try:
(x_train_mnist,
y_train_mnist), (x_test_mnist,
y_test_mnist) = get_default_mnist_subset
from art import config
full_path = os.path.join(config.ART_DATA_PATH, "my_classifier")
folder = os.path.split(full_path)[0]
if not os.path.exists(folder):
os.makedirs(folder)
# The model used within the common ART pytorch get_image_classifier_list does not support pickling
model = Model()
loss_fn = nn.CrossEntropyLoss()
optimizer = optim.Adam(model.parameters(), lr=0.01)
myclassifier_2 = PyTorchClassifier(model=model,
clip_values=(0, 1),
loss=loss_fn,
optimizer=optimizer,
input_shape=(1, 28, 28),
nb_classes=10)
myclassifier_2.fit(x_train_mnist,
y_train_mnist,
batch_size=100,
nb_epochs=1)
pickle.dump(myclassifier_2, open(full_path, "wb"))
with open(full_path, "rb") as f:
loaded_model = pickle.load(f)
np.testing.assert_equal(myclassifier_2._clip_values,
loaded_model._clip_values)
assert myclassifier_2._channel_index == loaded_model._channel_index
assert set(myclassifier_2.__dict__.keys()) == set(
loaded_model.__dict__.keys())
# Test predict
predictions_1 = myclassifier_2.predict(x_test_mnist)
accuracy_1 = np.sum(
np.argmax(predictions_1, axis=1) == np.argmax(
y_test_mnist, axis=1)) / y_test_mnist.shape[0]
predictions_2 = loaded_model.predict(x_test_mnist)
accuracy_2 = np.sum(
np.argmax(predictions_2, axis=1) == np.argmax(
y_test_mnist, axis=1)) / y_test_mnist.shape[0]
assert accuracy_1 == accuracy_2
except ARTTestException as e:
art_warning(e)
def test_pytorch_binary_pgd(art_warning, get_mnist_dataset):
"""
This test instantiates a binary classification PyTorch model, then attacks it using PGD
"""
class BasicModel(nn.Module):
def __init__(self):
super(BasicModel, self).__init__()
self.layer_1 = nn.Linear(20, 32)
self.layer_2 = nn.Linear(32, 1)
def forward(self, x):
x = F.relu(self.layer_1(x))
x = torch.sigmoid(self.layer_2(x))
return x
try:
device = "cpu"
x, y = sklearn.datasets.make_classification(n_samples=10000,
n_features=20,
n_informative=5,
n_redundant=2,
n_repeated=0,
n_classes=2)
train_x, test_x, train_y, test_y = sklearn.model_selection.train_test_split(
x, y, test_size=0.2)
train_x = test_x.astype(np.float32)
train_y = train_y.astype(np.float32)
test_x = test_x.astype(np.float32)
model = BasicModel()
loss_func = nn.BCELoss()
model.to(device)
opt = optim.Adam(model.parameters(), lr=0.001)
classifier = PyTorchClassifier(
model=model,
loss=loss_func,
optimizer=opt,
input_shape=(1, 28, 28),
nb_classes=2,
)
classifier.fit(train_x, train_y, batch_size=64, nb_epochs=3)
test_x_batch = test_x[0:16]
preds = classifier.predict(test_x_batch)
attacker = ProjectedGradientDescent(classifier, eps=0.5)
generated = attacker.generate(test_x_batch)
adv_predicted = classifier.predict(generated)
assert (adv_predicted != preds).all()
except ARTTestException as e:
art_warning(e)
def _fit_classifier(self, x: np.ndarray, y: np.ndarray, batch_size: int,
nb_epochs: int, **kwargs) -> None:
x = x.astype(ART_NUMPY_DTYPE)
return PyTorchClassifier.fit(self,
x,
y,
batch_size=batch_size,
nb_epochs=nb_epochs,
**kwargs)