def plot_loss_after_attack(evasAttack):
"""
This function plots the evolution of the loss function of the surrogate classifier
after an attack is performed.
The loss function is normalized between 0 and 1.
It helps to know whether parameters given to the attack algorithm are well tuned are not;
the loss should be as minimal as possible.
The script is inspired from https://secml.gitlab.io/tutorials/11-ImageNet_advanced.html#Visualize-and-check-the-attack-optimization
"""
n_iter = evasAttack.x_seq.shape[0]
itrs = CArray.arange(n_iter)
# create a plot that shows the loss during the attack iterations
# note that the loss is not available for all attacks
fig = CFigure(width=10, height=4, fontsize=14)
# apply a linear scaling to have the loss in [0,1]
loss = evasAttack.f_seq
if loss is not None:
loss = CNormalizerMinMax().fit_transform(CArray(loss).T).ravel()
fig.subplot(1, 2, 1)
fig.sp.xlabel('iteration')
fig.sp.ylabel('loss')
fig.sp.plot(itrs, loss, c='black')
fig.tight_layout()
fig.show()
def _create_2D_plots(self, normalizer):
self._test_init(normalizer)
self.logger.info("Create 2-dimensional plot")
self.clf_orig = self.classifier.deepcopy()
pois_clf = self._clf_poisoning()[0]
fig = CFigure(height=4, width=10, title=self.clf_idx)
n_rows = 1
n_cols = 2
box = self._create_box()
fig.subplot(n_rows, n_cols, grid_slot=1)
fig.sp.title('Attacker objective and gradients')
self._plot_func(fig, self.poisoning.objective_function)
self._plot_obj_grads(fig, self.poisoning.objective_function_gradient)
fig.sp.plot_ds(self.tr)
fig.sp.plot_decision_regions(
self.clf_orig,
plot_background=False,
grid_limits=self.grid_limits,
n_grid_points=10,
)
fig.sp.plot_constraint(box,
grid_limits=self.grid_limits,
n_grid_points=10)
fig.sp.plot_path(self.poisoning.x_seq,
start_facecolor='r' if self.yc == 1 else 'b')
fig.subplot(n_rows, n_cols, grid_slot=2)
fig.sp.title('Classification error on val')
self._plot_func(fig, self.poisoning.objective_function, acc=True)
fig.sp.plot_ds(self.tr)
fig.sp.plot_decision_regions(
pois_clf,
plot_background=False,
grid_limits=self.grid_limits,
n_grid_points=10,
)
fig.sp.plot_constraint(box,
grid_limits=self.grid_limits,
n_grid_points=10)
fig.sp.plot_path(self.poisoning.x_seq,
start_facecolor='r' if self.yc == 1 else 'b')
fig.tight_layout()
exp_idx = "2d_pois_"
exp_idx += self.clf_idx
if self.classifier.class_type == 'svm':
if self.classifier.kernel.preprocess is not None:
exp_idx += "_norm"
else:
if self.classifier.preprocess is not None:
exp_idx += "_norm"
fig.savefig(exp_idx + '.pdf', file_format='pdf')
def test_explain(self):
"""Unittest for explain method."""
i = 67
x = self.ds.X[i, :]
attr = self.explainer.explain(x, y=1)
self.logger.info("Attributions:\n{:}".format(attr.tolist()))
self.assertIsInstance(attr, CArray)
self.assertEqual(attr.shape, attr.shape)
fig = CFigure(height=3, width=6)
# Plotting original image
fig.subplot(1, 2, 1)
fig.sp.imshow(attr.reshape((8, 8)), cmap='gray')
th = max(abs(attr.min()), abs(attr.max()))
# Plotting attributions
fig.subplot(1, 2, 2)
fig.sp.imshow(attr.reshape((8, 8)),
cmap='seismic',
vmin=-1 * th,
vmax=th)
fig.show()
def test_explain(self):
"""Unittest for explain method."""
i = 67
ds_i = self.ds[i, :]
x, y_true = ds_i.X, ds_i.Y.item()
self.logger.info("Explaining P{:} c{:}".format(i, y_true))
x_pred, x_score = self.clf.predict(x, return_decision_function=True)
self.logger.info("Predicted class {:}, scores:\n{:}".format(
x_pred.item(), x_score))
self.logger.info("Candidates: {:}".format(x_score.argsort()[::-1]))
fig = CFigure(height=1.5, width=12)
# Plotting original image
fig.subplot(1, self.ds.num_classes + 1, 1)
fig.sp.imshow(x.reshape((8, 8)), cmap='gray')
fig.sp.title("Origin c{:}".format(y_true))
fig.sp.yticks([])
fig.sp.xticks([])
attr = CArray.empty(shape=(self.ds.num_classes, x.size))
# Computing attributions
for c in self.ds.classes:
attr_c = self.explainer.explain(x, y=c)
attr[c, :] = attr_c
self.logger.info("Attributions class {:}:\n{:}".format(
c, attr_c.tolist()))
self.assertIsInstance(attr, CArray)
self.assertEqual(attr.shape, attr.shape)
th = max(abs(attr.min()), abs(attr.max()))
# Plotting attributions
for c in self.ds.classes:
fig.subplot(1, self.ds.num_classes + 1, 2 + c)
fig.sp.imshow(attr[c, :].reshape((8, 8)),
cmap='seismic',
vmin=-1 * th,
vmax=th)
fig.sp.title("Attr c{:}".format(c))
fig.sp.yticks([])
fig.sp.xticks([])
fig.tight_layout()
fig.show()
def test_explain(self):
"""Unittest for explain method."""
i = 67
ds_i = self.ds[i, :]
x, y_true = ds_i.X, ds_i.Y.item()
self.logger.info("Explaining P{:} c{:}".format(i, y_true))
x_pred, x_score = self.clf.predict(x, return_decision_function=True)
self.logger.info("Predicted class {:}, scores:\n{:}".format(
x_pred.item(), x_score))
self.logger.info("Candidates: {:}".format(x_score.argsort()[::-1]))
ref_img = None # Use default reference image
m = 100 # Number of steps
attr = CArray.empty(shape=(0, x.shape[1]), sparse=x.issparse)
for c in self.ds.classes: # Compute attributions for each class
a = self.explainer.explain(x, y=c, reference=ref_img, m=m)
attr = attr.append(a, axis=0)
self.assertIsInstance(attr, CArray)
self.assertEqual(attr.shape[1], x.shape[1])
self.assertEqual(attr.shape[0], self.ds.num_classes)
fig = CFigure(height=1.5, width=12)
# Plotting original image
fig.subplot(1, self.ds.num_classes + 1, 1)
fig.sp.imshow(x.reshape((8, 8)), cmap='gray')
fig.sp.title("Origin c{:}".format(y_true))
fig.sp.yticks([])
fig.sp.xticks([])
th = max(abs(attr.min()), abs(attr.max()))
# Plotting attributions
for c in self.ds.classes:
fig.subplot(1, self.ds.num_classes + 1, 2 + c)
fig.sp.imshow(attr[c, :].reshape((8, 8)),
cmap='seismic',
vmin=-1 * th,
vmax=th)
fig.sp.title("Attr c{:}".format(c))
fig.sp.yticks([])
fig.sp.xticks([])
fig.tight_layout()
fig.show()
def test_plot_decision_regions(self):
"""Test for `.plot_decision_regions` method."""
fig = CFigure(width=10, height=5)
fig.subplot(1, 2, 1)
fig.sp.plot_ds(self.dataset)
fig.sp.plot_decision_regions(
self.clf, n_grid_points=200, plot_background=False)
fig.subplot(1, 2, 2)
fig.sp.plot_ds(self.dataset)
fig.sp.plot_decision_regions(
self.clf, n_grid_points=200)
fig.show()
def test_plot(self):
ds = CDLRandom(n_samples=100,
n_features=2,
n_redundant=0,
random_state=100).load()
self.logger.info("Train Sec SVM")
sec_svm = CClassifierSecSVM(C=1, eta=0.1, eps=1e-3, lb=-0.1, ub=0.5)
sec_svm.verbose = 2
sec_svm.fit(ds.X, ds.Y)
self.logger.info("Train SVM")
svm = CClassifierSVM(C=1)
svm.fit(ds.X, ds.Y)
self._compute_alignment(ds, sec_svm, svm)
fig = CFigure(height=5, width=8)
fig.subplot(1, 2, 1)
# Plot dataset points
fig.sp.plot_ds(ds)
# Plot objective function
fig.sp.plot_fun(svm.predict,
multipoint=True,
plot_background=True,
plot_levels=False,
n_grid_points=100,
grid_limits=ds.get_bounds())
fig.sp.title("SVM")
fig.subplot(1, 2, 2)
# Plot dataset points
fig.sp.plot_ds(ds)
# Plot objective function
fig.sp.plot_fun(sec_svm.predict,
multipoint=True,
plot_background=True,
plot_levels=False,
n_grid_points=100,
grid_limits=ds.get_bounds())
fig.sp.title("Sec-SVM")
fig.show()
def _test_plot(self, clf, ds, levels=None):
"""Plot the decision function of a classifier."""
self.logger.info("Testing classifiers graphically")
# Preparation of the grid
fig = CFigure(width=8, height=4, fontsize=8)
clf.fit(ds.X, ds.Y)
fig.subplot(1, 2, 1)
fig.sp.plot_ds(ds)
fig.sp.plot_decision_regions(
clf, n_grid_points=50, grid_limits=ds.get_bounds())
fig.sp.title("Decision regions")
fig.subplot(1, 2, 2)
fig.sp.plot_ds(ds)
fig.sp.plot_fun(clf.decision_function, grid_limits=ds.get_bounds(),
levels=levels, y=1)
fig.sp.title("Discriminant function for y=1")
return fig
def test_draw(self):
""" Compare the classifiers graphically"""
self.logger.info("Testing classifiers graphically")
# generate 2D synthetic data
dataset = CDLRandom(n_features=2,
n_redundant=1,
n_informative=1,
n_clusters_per_class=1).load()
dataset.X = CNormalizerMinMax().fit_transform(dataset.X)
self.sgds[0].fit(dataset.X, dataset.Y)
svm = CClassifierSVM()
svm.fit(dataset.X, dataset.Y)
fig = CFigure(width=10, markersize=8)
fig.subplot(2, 1, 1)
# Plot dataset points
fig.sp.plot_ds(dataset)
# Plot objective function
fig.sp.plot_fun(svm.decision_function,
grid_limits=dataset.get_bounds(),
y=1)
fig.sp.title('SVM')
fig.subplot(2, 1, 2)
# Plot dataset points
fig.sp.plot_ds(dataset)
# Plot objective function
fig.sp.plot_fun(self.sgds[0].decision_function,
grid_limits=dataset.get_bounds(),
y=1)
fig.sp.title('SGD Classifier')
fig.savefig(
fm.join(fm.abspath(__file__), 'figs',
'test_c_classifier_sgd1.pdf'))
def _create_params_grad_plot(self, normalizer):
"""
Show the gradient of the classifier parameters w.r.t the poisoning
point
"""
self.logger.info("Create 2-dimensional plot of the poisoning "
"gradient")
self._test_init(normalizer)
pois_clf = self._clf_poisoning()[0]
if self.n_features == 2:
debug_pois_obj = _CAttackPoisoningLinTest(self.poisoning)
fig = CFigure(height=8, width=10)
n_rows = 2
n_cols = 2
fig.title(self.clf_idx)
fig.subplot(n_rows, n_cols, grid_slot=1)
fig.sp.title('w1 wrt xc')
self._plot_param_sub(fig, debug_pois_obj.w1,
debug_pois_obj.gradient_w1_xc, pois_clf)
fig.subplot(n_rows, n_cols, grid_slot=2)
fig.sp.title('w2 wrt xc')
self._plot_param_sub(fig, debug_pois_obj.w2,
debug_pois_obj.gradient_w2_xc, pois_clf)
fig.subplot(n_rows, n_cols, grid_slot=3)
fig.sp.title('b wrt xc')
self._plot_param_sub(fig, debug_pois_obj.b,
debug_pois_obj.gradient_b_xc, pois_clf)
fig.tight_layout()
exp_idx = "2d_grad_pois_"
exp_idx += self.clf_idx
if self.classifier.preprocess is not None:
exp_idx += "_norm"
fig.savefig(exp_idx + '.pdf', file_format='pdf')
def _show_adv(self, x0, y0, x_opt, y_pred, attack_idx, y_target):
"""Show the original and the modified sample.
Parameters
----------
x0 : CArray
Initial attack point.
y0 : CArray
Label of the initial attack point.
x_opt : CArray
Final optimal point.
y_pred : CArray
Predicted label of the final optimal point.
attack_idx : str
Identifier of the attack algorithm.
y_target : int or None
Attack target class.
"""
if self.make_figures is False:
self.logger.debug("Skipping figures...")
return
added_noise = abs(x_opt - x0) # absolute value of noise image
fig = CFigure(height=5.0, width=15.0)
fig.subplot(1, 3, 1)
fig.sp.title(self.digits[y0.item()])
fig.sp.imshow(x0.reshape((self.img_h, self.img_w)), cmap='gray')
fig.subplot(1, 3, 2)
fig.sp.imshow(added_noise.reshape((self.img_h, self.img_w)),
cmap='gray')
fig.subplot(1, 3, 3)
fig.sp.title(self.digits[y_pred.item()])
fig.sp.imshow(x_opt.reshape((self.img_h, self.img_w)), cmap='gray')
name_file = "{:}_MNIST_target-{:}.pdf".format(attack_idx, y_target)
fig.savefig(fm.join(self.images_folder, name_file), file_format='pdf')
def _show_adv(self, x0, y0, x_opt, y_pred):
"""Show the original and the modified sample.
Parameters
----------
x0 : CArray
Initial attack point.
y0 : CArray
Label of the initial attack point.
x_opt : CArray
Final optimal point.
y_pred : CArray
Predicted label of the final optimal point.
"""
if self.make_figures is False:
self.logger.debug("Skipping figures...")
return
added_noise = abs(x_opt - x0) # absolute value of noise image
fig = CFigure(height=5.0, width=15.0)
fig.subplot(1, 3, 1)
fig.sp.title(self._digits[y0.item()])
fig.sp.imshow(x0.reshape(
(self._tr.header.img_h, self._tr.header.img_w)),
cmap='gray')
fig.subplot(1, 3, 2)
fig.sp.imshow(added_noise.reshape(
(self._tr.header.img_h, self._tr.header.img_w)),
cmap='gray')
fig.subplot(1, 3, 3)
fig.sp.title(self._digits[y_pred.item()])
fig.sp.imshow(x_opt.reshape(
(self._tr.header.img_h, self._tr.header.img_w)),
cmap='gray')
fig.savefig(fm.join(self.images_folder, self.filename),
file_format='pdf')
def _make_plot(self, p_idx, eva, dmax):
if self.make_figures is False:
self.logger.debug("Skipping figures...")
return
x0 = self.ds.X[p_idx, :]
y0 = self.ds.Y[p_idx].item()
x_seq = CArray.empty((0, x0.shape[1]))
scores = CArray([])
f_seq = CArray([])
x = x0
for d_idx, d in enumerate(range(0, dmax + 1)):
self.logger.info("Evasion at dmax: " + str(d))
eva.dmax = d
x, f_opt = eva._run(x0=x0, y0=y0, x_init=x)
y_pred, score = self.multiclass.predict(
x, return_decision_function=True)
f_seq = f_seq.append(f_opt)
# not considering all iterations, just values at dmax
# for all iterations, you should bring eva.x_seq and eva.f_seq
x_seq = x_seq.append(x, axis=0)
s = score[:, y0 if self.y_target is None else self.y_target]
scores = scores.append(s)
self.logger.info("Predicted label after evasion: {:}".format(y_pred))
self.logger.info("Score after evasion: {:}".format(s))
self.logger.info("Objective function after evasion: {:}".format(f_opt))
fig = CFigure(height=9, width=10, markersize=6, fontsize=12)
# Get plot bounds, taking into account ds and evaded point path
bounds_x, bounds_y = self.ds.get_bounds()
min_x, max_x = bounds_x
min_y, max_y = bounds_y
min_x = min(min_x, x_seq[:, 0].min())
max_x = max(max_x, x_seq[:, 0].max())
min_y = min(min_y, x_seq[:, 1].min())
max_y = max(max_y, x_seq[:, 1].max())
ds_bounds = [(min_x, max_x), (min_y, max_y)]
# Plotting multiclass decision regions
fig.subplot(2, 2, 1)
fig = self._plot_decision_function(fig, plot_background=True)
fig.sp.plot_path(x_seq,
path_style='-',
start_style='o',
start_facecolor='w',
start_edgewidth=2,
final_style='o',
final_facecolor='k',
final_edgewidth=2)
# plot distance constraint
fig.sp.plot_fun(func=self._rescaled_distance,
multipoint=True,
plot_background=False,
n_grid_points=20,
levels_color='k',
grid_limits=ds_bounds,
levels=[0],
colorbar=False,
levels_linewidth=2.0,
levels_style=':',
alpha_levels=.4,
c=x0,
r=dmax)
fig.sp.grid(linestyle='--', alpha=.5, zorder=0)
# Plotting multiclass evasion objective function
fig.subplot(2, 2, 2)
fig = self._plot_decision_function(fig)
fig.sp.plot_fgrads(eva.objective_function_gradient,
grid_limits=ds_bounds,
n_grid_points=20,
color='k',
alpha=.5)
fig.sp.plot_path(x_seq,
path_style='-',
start_style='o',
start_facecolor='w',
start_edgewidth=2,
final_style='o',
final_facecolor='k',
final_edgewidth=2)
# plot distance constraint
fig.sp.plot_fun(func=self._rescaled_distance,
multipoint=True,
plot_background=False,
n_grid_points=20,
levels_color='w',
grid_limits=ds_bounds,
levels=[0],
colorbar=False,
levels_style=':',
levels_linewidth=2.0,
alpha_levels=.5,
c=x0,
r=dmax)
fig.sp.plot_fun(lambda z: eva.objective_function(z),
multipoint=True,
grid_limits=ds_bounds,
colorbar=False,
n_grid_points=20,
plot_levels=False)
fig.sp.grid(linestyle='--', alpha=.5, zorder=0)
fig.subplot(2, 2, 3)
if self.y_target is not None:
fig.sp.title("Classifier Score for Target Class (Targ. Evasion)")
else:
fig.sp.title("Classifier Score for True Class (Indiscr. Evasion)")
fig.sp.plot(scores)
fig.sp.grid()
fig.sp.xlim(0, dmax)
fig.sp.xlabel("dmax")
fig.subplot(2, 2, 4)
fig.sp.title("Objective Function")
fig.sp.plot(f_seq)
fig.sp.grid()
fig.sp.xlim(0, dmax)
fig.sp.xlabel("dmax")
fig.tight_layout()
k_name = self.kernel.class_type if self.kernel is not None else 'lin'
fig.savefig(
fm.join(
self.images_folder,
"pgd_ls_reject_threshold_{:}c_kernel-{:}_target-{:}.pdf".
format(self.ds.num_classes, k_name, self.y_target)))
from secml.array import CArray
from secml.figure import CFigure
def f(x, y):
return (1 - x / 2 + x**5 + y**3) * (-x**2 - y**2).exp()
fig = CFigure(width=10, title="Colorbar Example")
fig.subplot(1, 2, 1)
x_linspace = CArray.linspace(-3, 3, 256)
y_linspace = CArray.linspace(-3, 3, 256)
X, Y = CArray.meshgrid((x_linspace, y_linspace))
c = fig.sp.contourf(X, Y, f(X, Y), 8, alpha=.75, cmap='hot')
fig.sp.colorbar(c)
fig.sp.title("Hot Contourf")
fig.sp.xticks(())
fig.sp.yticks(())
fig.subplot(1, 2, 2)
c = fig.sp.contourf(X, Y, f(X, Y), 8, alpha=.75, cmap='winter')
fig.sp.colorbar(c)
fig.sp.title("Cold Contourf")
fig.sp.xticks(())
fig.sp.yticks(())
fig.show()
print(adv_label)
start_img = batch_c
eva_img = eva_adv_ds.X
# normalize perturbation for visualization
diff_img = start_img - eva_img
diff_img -= diff_img.min()
diff_img /= diff_img.max()
start_img = np.transpose(start_img.tondarray().reshape((3, 224, 224)),
(1, 2, 0))
diff_img = np.transpose(diff_img.tondarray().reshape((3, 224, 224)), (1, 2, 0))
eva_img = np.transpose(eva_img.tondarray().reshape((3, 224, 224)), (1, 2, 0))
fig = CFigure(width=15, height=5)
fig.subplot(1, 3, 1)
fig.sp.imshow(start_img)
fig.sp.title(predicted_label)
fig.sp.xticks([])
fig.sp.yticks([])
fig.subplot(1, 3, 2)
fig.sp.imshow(diff_img)
fig.sp.title("amplified perturbation")
fig.sp.xticks([])
fig.sp.yticks([])
fig.subplot(1, 3, 3)
fig.sp.imshow(eva_img)
fig.sp.title(adv_label)
fig.sp.xticks([])
def _make_plots(self, x_seq, dmax, eva, x0, scores, f_seq):
if self.make_figures is False:
self.logger.debug("Skipping figures...")
return
fig = CFigure(height=9, width=10, markersize=6, fontsize=12)
# Get plot bounds, taking into account ds and evaded point path
bounds_x, bounds_y = self.ds.get_bounds()
min_x, max_x = bounds_x
min_y, max_y = bounds_y
min_x = min(min_x, x_seq[:, 0].min())
max_x = max(max_x, x_seq[:, 0].max())
min_y = min(min_y, x_seq[:, 1].min())
max_y = max(max_y, x_seq[:, 1].max())
ds_bounds = [(min_x, max_x), (min_y, max_y)]
# Plotting multiclass decision regions
fig.subplot(2, 2, 1)
fig = self._plot_decision_function(fig, plot_background=True)
fig.sp.plot_path(x_seq,
path_style='-',
start_style='o',
start_facecolor='w',
start_edgewidth=2,
final_style='o',
final_facecolor='k',
final_edgewidth=2)
# plot distance constraint
fig.sp.plot_fun(func=self._rescaled_distance,
multipoint=True,
plot_background=False,
n_grid_points=20,
levels_color='k',
grid_limits=ds_bounds,
levels=[0],
colorbar=False,
levels_linewidth=2.0,
levels_style=':',
alpha_levels=.4,
c=x0,
r=dmax)
fig.sp.grid(linestyle='--', alpha=.5, zorder=0)
# Plotting multiclass evasion objective function
fig.subplot(2, 2, 2)
fig = self._plot_decision_function(fig)
fig.sp.plot_fgrads(eva._objective_function_gradient,
grid_limits=ds_bounds,
n_grid_points=20,
color='k',
alpha=.5)
fig.sp.plot_path(x_seq,
path_style='-',
start_style='o',
start_facecolor='w',
start_edgewidth=2,
final_style='o',
final_facecolor='k',
final_edgewidth=2)
# plot distance constraint
fig.sp.plot_fun(func=self._rescaled_distance,
multipoint=True,
plot_background=False,
n_grid_points=20,
levels_color='w',
grid_limits=ds_bounds,
levels=[0],
colorbar=False,
levels_style=':',
levels_linewidth=2.0,
alpha_levels=.5,
c=x0,
r=dmax)
fig.sp.plot_fun(lambda z: eva._objective_function(z),
multipoint=True,
grid_limits=ds_bounds,
colorbar=False,
n_grid_points=20,
plot_levels=False)
fig.sp.grid(linestyle='--', alpha=.5, zorder=0)
fig.subplot(2, 2, 3)
if self.y_target is not None:
fig.sp.title("Classifier Score for Target Class (Targ. Evasion)")
else:
fig.sp.title("Classifier Score for True Class (Indiscr. Evasion)")
fig.sp.plot(scores)
fig.sp.grid()
fig.sp.xlim(0, dmax)
fig.sp.xlabel("dmax")
fig.subplot(2, 2, 4)
fig.sp.title("Objective Function")
fig.sp.plot(f_seq)
fig.sp.grid()
fig.sp.xlim(0, dmax)
fig.sp.xlabel("dmax")
fig.tight_layout()
k_name = self.kernel.class_type if self.kernel is not None else 'lin'
fig.savefig(
fm.join(
self.images_folder,
"pgd_ls_multiclass_{:}c_kernel-{:}_target-{:}.pdf".format(
self.ds.num_classes, k_name, self.y_target)))
def test_compare_sklearn(self):
import numpy as np
from sklearn import svm, datasets
from sklearn.metrics import roc_curve, auc
from sklearn.model_selection import StratifiedKFold
from secml.figure import CFigure
roc_fig = CFigure(width=12)
# import some data to play with
iris = datasets.load_iris()
X = iris.data
y = iris.target
X, y = X[y != 2], y[y != 2]
n_samples, n_features = X.shape
# Add noisy features
random_state = np.random.RandomState(0)
X = np.c_[X, random_state.randn(n_samples, 200 * n_features)]
# Classification and ROC analysis
# Run classifier with cross-validation and plot ROC curves
classifier = svm.SVC(kernel='linear',
probability=True,
random_state=random_state)
roc_fig.subplot(1, 2, 1)
mean_tpr = 0.0
mean_fpr = np.linspace(0, 1, 1000)
cv = StratifiedKFold(n_splits=6)
for i, (train, test) in enumerate(cv.split(X, y)):
probas_ = classifier.fit(X[train], y[train]).predict_proba(X[test])
# Compute ROC curve and area the curve
fpr, tpr, thresholds = roc_curve(y[test], probas_[:, 1])
mean_tpr += np.interp(mean_fpr, fpr, tpr)
mean_tpr[0] = 0.0
roc_auc = auc(fpr, tpr)
roc_fig.sp.plot(fpr,
tpr,
linewidth=1,
label='ROC fold %d (area = %0.2f)' % (i, roc_auc))
roc_fig.sp.plot([0, 1], [0, 1],
'--',
color=(0.6, 0.6, 0.6),
label='Luck')
mean_tpr /= cv.get_n_splits()
mean_tpr[-1] = 1.0
mean_auc = auc(mean_fpr, mean_tpr)
roc_fig.sp.plot(mean_fpr,
mean_tpr,
'k--',
label='Mean ROC (area = %0.2f)' % mean_auc,
linewidth=2)
roc_fig.sp.xlim([-0.05, 1.05])
roc_fig.sp.ylim([-0.05, 1.05])
roc_fig.sp.xlabel('False Positive Rate')
roc_fig.sp.ylabel('True Positive Rate')
roc_fig.sp.title('Sklearn Receiver operating characteristic example')
roc_fig.sp.legend(loc="lower right")
roc_fig.sp.grid()
self.logger.info("Plotting using our CPLotRoc")
roc_fig.subplot(1, 2, 2)
score = []
true_y = []
for i, (train, test) in enumerate(cv.split(X, y)):
probas_ = classifier.fit(X[train], y[train]).predict_proba(X[test])
true_y.append(CArray(y[test]))
score.append(CArray(probas_[:, 1]))
self.roc_wmean = CRoc()
self.roc_wmean.compute(true_y, score)
fp, tp = self.roc_wmean.average()
roc_fig.sp.plot([0, 100], [0, 100],
'--',
color=(0.6, 0.6, 0.6),
label='Luck')
roc_fig.sp.xticks([0, 20, 40, 60, 80, 100])
roc_fig.sp.xticklabels(['0', '20', '40', '60', '80', '100'])
roc_fig.sp.plot_roc_mean(self.roc_wmean,
plot_std=True,
logx=False,
style='go-',
label='Mean ROC (area = %0.2f)' %
(auc(fp.tondarray(), tp.tondarray())))
roc_fig.sp.xlim([-0.05 * 100, 1.05 * 100])
roc_fig.sp.ylim([-0.05 * 100, 1.05 * 100])
roc_fig.sp.title('SecML Receiver operating characteristic example')
roc_fig.sp.legend(loc="lower right")
roc_fig.show()
from secml.array import CArray
from secml.figure import CFigure
n = 5
fig = CFigure()
x = CArray.arange(100)
y = 3. * CArray.sin(x * 2. * 3.14 / 100.)
for i in range(n):
temp = 510 + i
sp = fig.subplot(n, 1, i)
fig.sp.plot(x, y)
# for add space from the figure's border you must increased default value parameters
fig.subplots_adjust(bottom=0.4, top=0.85, hspace=0.001)
fig.sp.xticklabels(())
fig.sp.yticklabels(())
fig.show()
import numpy as np import matplotlib.pyplot as plt from secml.figure import CFigure fig = CFigure(fontsize=16) # create a new subplot fig.subplot(2, 2, 1) x = np.linspace(-np.pi, np.pi, 100) y = 2 * np.sin(x) # function `plot` will be applied to the last subplot created fig.sp.plot(x, y) # subplot indices are are the same of the first subplot # so the following function will be run inside the previous plot fig.subplot(2, 2, 1) y = x fig.sp.plot(x, y) # create a new subplot fig.subplot(2, 2, 3) fig.sp.plot(x, y) fig.subplot(2, 2, grid_slot=(1, slice(2))) y = 2 * np.sin(x) fig.sp.plot(x, y) plt.show()