def _create_clf(dnn):
"""Initialize the DNR classifier passing a single `layer_clf`"""
layers = ['conv2', 'relu']
combiner = CClassifierSVM(kernel=CKernelRBF(gamma=1), C=1)
layer_clf = CClassifierSVM(kernel=CKernelRBF(gamma=1), C=1)
return CClassifierDNR(combiner, layer_clf, dnn, layers, -inf)
def test_set(self):
from secml.ml.kernels import CKernelRBF
multiclass = CClassifierMulticlassOVA(classifier=CClassifierSVM,
C=1,
kernel=CKernelRBF())
# Test set before training
multiclass.set_params({'C': 100, 'kernel.gamma': 20})
for clf in multiclass._binary_classifiers:
self.assertEqual(clf.C, 100.0)
self.assertEqual(clf.kernel.gamma, 20.0)
# Restoring kernel
multiclass.set('kernel', CKernelRBF(gamma=50))
# Setting different parameter in single trained_classifiers
multiclass.prepare(num_classes=4)
different_c = (10, 20, 30, 40)
multiclass.set('C', different_c)
different_gamma = (50, 60, 70, 80)
multiclass.set('kernel.gamma', different_gamma)
# Fit multiclass classifier than test set after training
multiclass.fit(self.dataset)
for clf_idx, clf in enumerate(multiclass._binary_classifiers):
self.assertEqual(clf.C, different_c[clf_idx])
self.assertEqual(clf.kernel.gamma, different_gamma[clf_idx])
# Test set after training
multiclass.set_params({'C': 30, 'kernel.gamma': 200})
for clf in multiclass._binary_classifiers:
self.assertEqual(clf.C, 30.0)
self.assertEqual(clf.kernel.gamma, 200.0)
for clf in multiclass._binary_classifiers:
self.assertEqual(clf.C, 30.0)
self.assertEqual(clf.kernel.gamma, 200.0)
# Setting parameter in single trained_classifiers
multiclass._binary_classifiers[0].kernel.gamma = 300
for i in range(1, multiclass.num_classifiers):
self.assertNotEqual(multiclass._binary_classifiers[i].kernel.gamma,
300.0)
# Setting different parameter in single trained_classifiers
different_c = (100, 200, 300)
# ValueError is raised as not enough binary classifiers are available
with self.assertRaises(ValueError):
multiclass.set('C', different_c)
multiclass.prepare(num_classes=3)
multiclass.set('C', different_c)
for clf_idx, clf in enumerate(multiclass._binary_classifiers):
self.assertEqual(clf.C, different_c[clf_idx])
def test_explanation_svm_rbf(self):
self._clf = CClassifierSVM(kernel=CKernelRBF(gamma=0.01), C=10)
self._clf.kernel.gamma = 0.01
self._clf.store_dual_vars = True
self._clf_idx = 'rbf-svm'
self._test_explanation_simple_clf()
def setUp(self):
import numpy as np
np.random.seed(12345678)
# generate synthetic data
self.ds = CDLRandom(n_classes=3,
n_features=2,
n_redundant=0,
n_clusters_per_class=1,
class_sep=1,
random_state=0).load()
# Add a new class modifying one of the existing clusters
self.ds.Y[(self.ds.X[:, 0] > 0).logical_and(
self.ds.X[:, 1] > 1).ravel()] = self.ds.num_classes
# self.kernel = None
self.kernel = CKernelRBF(gamma=10)
# Data normalization
self.normalizer = CNormalizerMinMax()
self.ds.X = self.normalizer.fit_transform(self.ds.X)
self.multiclass = CClassifierMulticlassOVA(classifier=CClassifierSVM,
class_weight='balanced',
preprocess=None,
kernel=self.kernel)
self.multiclass.verbose = 0
# Training and classification
self.multiclass.fit(self.ds.X, self.ds.Y)
self.y_pred, self.score_pred = self.multiclass.predict(
self.ds.X, return_decision_function=True)
def setUp(self):
# 100 samples, 2 classes, 20 features
self.ds = CDLDigits().load()
self.clf = CClassifierMulticlassOVA(CClassifierSVM,
kernel=CKernelRBF(gamma=1e-3))
# Training classifier
self.clf.fit(self.ds.X, self.ds.Y)
self.explainer = CExplainerGradientInput(self.clf)
def setUpClass(cls):
CUnitTest.setUpClass()
# 100 samples, 2 classes, 20 features
cls.ds = CDLDigits().load()
cls.clf = CClassifierMulticlassOVA(CClassifierSVM,
kernel=CKernelRBF(gamma=1e-3))
# Training classifier
cls.clf.fit(cls.ds.X, cls.ds.Y)
def setUp(self):
import numpy as np
np.random.seed(12345678)
self._dataset_creation()
self.kernel = CKernelRBF(gamma=1)
self.multiclass = CClassifierMulticlassOVA(
classifier=CClassifierSVM, class_weight='balanced',
preprocess=None, kernel=self.kernel)
self.multiclass.verbose = 0
self.multiclass = CClassifierRejectThreshold(self.multiclass, 0.6)
# Training and classification
self.multiclass.fit(self.ds.X, self.ds.Y)
self.y_pred, self.score_pred = self.multiclass.predict(
self.ds.X, return_decision_function=True)
def test_svm(self):
self.X = CArray([[1, 2], [3, 4], [5, 6], [7, 8]])
self.Y = CArray([[0], [1], [1], [0]]).ravel()
self.dataset = CDataset(self.X, self.Y)
self.classifier = CClassifierSVM(kernel=CKernelRBF())
self.classifier.fit(self.dataset)
self.x_min, self.x_max = (self.X[:, [0]].min() - 1,
self.X[:, [0]].max() + 1)
self.y_min, self.y_max = (self.X[:, [1]].min() - 1,
self.X[:, [1]].max() + 1)
self.fig = CFigure(height=7,
width=10,
linewidth=5,
fontsize=24,
markersize=20)
self.fig.sp.title("Svm Test")
self.logger.info("Test plot dataset method...")
self.fig.sp.plot_ds(self.dataset)
self.logger.info("Test plot path method...")
path = CArray([[1, 2], [1, 3], [1.5, 5]])
self.fig.sp.plot_path(path)
self.logger.info("Test plot function method...")
bounds = [(self.x_min, self.x_max), (self.y_min, self.y_max)]
self.fig.sp.plot_fun(self.classifier.decision_function,
plot_levels=False,
grid_limits=bounds,
y=1)
self.fig.sp.xlim(self.x_min, self.x_max)
self.fig.sp.ylim(self.y_min, self.y_max)
self.fig.show()
def setUpClass(cls):
CAttackEvasionCleverhansTestCases.setUpClass()
cls.seed = 0
cls.y_target = None
cls.clf = CClassifierMulticlassOVA(CClassifierSVM,
kernel=CKernelRBF(gamma=10),
C=0.1,
preprocess=CNormalizerMinMax())
cls.ds = CDLRandomBlobs(n_features=0,
centers=[[0.1, 0.1], [0.5, 0], [0.8, 0.8]],
cluster_std=0.01,
n_samples=100,
random_state=cls.seed).load()
cls.clf.fit(cls.ds.X, cls.ds.Y)
cls.x0 = CArray([0.6, 0.2])
cls.y0 = CArray(cls.clf.predict(cls.x0))
# secml_sklearn_clf.fit(ds_tr_secml)
# preds = secml_sklearn_clf.predict(ds_te_secml.X)
# metric = CMetricAccuracy()
# acc = metric.performance_score(y_true = ds_te_secml.Y, y_pred = preds)
# print("Accuracy on test set: {:.2%}".format(acc))
# probs = secml_sklearn_clf.predict_proba(ds_te_secml.X) #Doesn't work
#
# #sklearn here isn't supported for performing adversarial attacks, only the native SVM of secml supports adversarial attacks
# ###############################################################
#
# =============================================================================
x, y = ds_te_secml[:, :].X, ds_te_secml[:, :].Y # This won't work if we want to specify the target
#class for each example
#secml_clf = CClassifierMulticlassOVA(CClassifierSVM, kernel = CKernelRBF(gamma = 10), C = 1)
secml_clf = CClassifierSVM(kernel=CKernelRBF(gamma=10), C=1)
secml_clf.fit(ds_tr_secml)
preds = secml_clf.predict(ds_te_secml.X)
metric = CMetricAccuracy()
acc = metric.performance_score(y_true=ds_te_secml.Y, y_pred=preds)
print("Accuracy on test set: {:.2%}".format(acc))
#Performing the attack
noise_type = 'l2'
dmax = 0.4
lb, ub = None, None # with 0, 1 it goes out of bounds
y_target = None #### Here y_target can be some class, indicating which class is expected for the adversarial example
#solver_params = {
# 'eta': 0.3,
# 'max_iter': 100,
test_size=setSamplesValidationNumber,
random_state=random_state)
training, validation = splitter.split(dataset)
# Normalize the data
normalizer = CNormalizerMinMax()
training.X = normalizer.fit_transform(training.X)
validation.X = normalizer.transform(validation.X)
test.X = normalizer.transform(test.X)
# Metric to use for training and performance evaluation
metric = CMetricAccuracy()
# Creation of the multiclass classifier
classifier = CClassifierSVM(kernel=CKernelRBF(gamma=10), C=1)
# We can now fit the classifier
classifier.fit(training.X, training.Y)
print("Training of classifier complete!")
# Compute predictions on a test set
predictionY = classifier.predict(test.X)
# Bounds of the attack space. Can be set to `None` for unbounded
lowerBound, upperBound = validation.X.min(), validation.X.max()
# Should be chosen depending on the optimization problem
solver_params = {
'eta': 0.05,
'eta_min': 0.05,
def test_explanation_svm_rbf(self):
self._clf = CClassifierSVM(kernel=CKernelRBF(gamma=0.01), C=10)
self._clf_idx = 'rbf-svm'
self._test_explanation_simple_clf()
te_X, te_Y = CArray(te_X), CArray(te_Y)
ds_tr_secml = CDataset(tr_X, tr_Y)
#print(ds_tr_secml.classes, ds_tr_secml.num_classes, ds_tr_secml.num_features, ds_tr_secml.num_samples)
ds_te_secml = CDataset(te_X, te_Y)
ds_cv_secml = CDataset(cv_X, cv_Y)
normalizer = CNormalizerMinMax()
ds_tr_secml.X = normalizer.fit_transform(ds_tr_secml.X)
ds_te_secml.X = normalizer.transform(ds_te_secml.X)
ds_cv_secml.X = normalizer.transform(ds_cv_secml.X)
x0, y0 = ds_te_secml[0, :].X, ds_te_secml[0, :].Y
secml_clf = CClassifierMulticlassOVA(CClassifierSVM,
kernel=CKernelRBF(gamma=10),
C=1)
secml_clf.fit(ds_tr_secml)
preds = secml_clf.predict(ds_te_secml.X)
metric = CMetricAccuracy()
acc = metric.performance_score(y_true=ds_te_secml.Y, y_pred=preds)
print("Accuracy on test set: {:.2%}".format(acc))
#Performing the attack
noise_type = 'l2'
dmax = 1
lb, ub = None, None # with 0, 1 it goes out of bounds
y_target = None #### Here y_target can be some class, indicating which class is expected for the adversarial example
x0, y0 = ds_te_secml[0, :].X, ds_te_secml[0, :].Y
x_train, x_val, y, y_val = train_test_split(x_train,
y,
test_size=n_val,
train_size=n_tr,
random_state=random_state)
training_data = CDataset(x_train, y)
validation_data = CDataset(x_val, y_val)
test_data = CDataset(xtt, ytt)
del xtr
del ytr
metric = CMetricAccuracy()
clf = CClassifierSVM(kernel=CKernelRBF(gamma=GAMMA), C=C)
# We can now fit the classifier
clf.fit(training_data.X, training_data.Y)
print("Training of classifier complete!")
# Compute predictions on a test set
y_pred = clf.predict(test_data.X)
lb, ub = validation_data.X.min(), validation_data.X.max(
) # Bounds of the attack space. Can be set to `None` for unbounded
n_poisoning_points = int(
n_tr * poison_percentage) # Number of poisoning points to generate
# Should be chosen depending on the optimization problem
solver_params = {
'eta': 0.05,
