def _test_plot(self, evas):
"""Check if `stored_vars` is correctly populated.
Parameters
----------
evas : CAttackEvasionCleverhans
"""
if self.make_figures is False:
self.logger.debug("Skipping figures...")
return
fig = CFigure()
fig.sp.plot_path(evas.x_seq)
fig.sp.plot_fun(evas.objective_function,
plot_levels=False,
multipoint=True,
n_grid_points=50)
fig.sp.plot_decision_regions(self.clf,
plot_background=False,
n_grid_points=100)
fig.title("ATTACK: {}, y_target: {}".format(
evas._clvrh_attack_class.__name__, self.y_target))
name_file = '{}_evasion2D_target_{}.pdf'.format(
evas._clvrh_attack_class.__name__, self.y_target)
fig.savefig(fm.join(self.images_folder, name_file), file_format='pdf')
def test_plot_density(self):
N = 200
np.random.seed(1)
X = np.concatenate((np.random.normal(0, 1, int(0.3 * N)),
np.random.normal(5, 1, int(0.7 * N))))[:, np.newaxis]
X_plot = CArray(np.linspace(-5, 10, 1000)[:, np.newaxis])
true_dens = CArray(0.3 * norm(0, 1).pdf(X_plot[:, 0].tondarray())
+ 0.7 * norm(5, 1).pdf(X_plot[:, 0].tondarray()))
fig = CFigure(width=7)
fig.sp._sp.fill(X_plot[:, 0].tondarray(), true_dens.tondarray(),
fc='black', alpha=0.2,
label='input distribution')
for kernel in ['gaussian', 'tophat', 'epanechnikov']:
kde = CDensityEstimation(kernel=kernel, bandwidth=0.5)
x, y = kde.estimate_density(CArray(X), n_points=N)
fig.sp.plot(x, y, '-',
label="kernel = '{0}'".format(kernel))
fig.sp.text(6, 0.38, "N={0} points".format(N))
fig.sp.legend(loc='upper left')
fig.sp.plot(X[:, 0], -0.005 - 0.01 * np.random.random(X.shape[0]), '+k')
fig.sp.xlim(-4, 9)
fig.sp.ylim(-0.02, 0.4)
fig.show()
def test_fun(self):
"""Test for CPlotFunction.plot_fun method."""
fig = CFigure()
fig.sp.plot_ds(self.dataset)
fig.sp.plot_fun(self.clf.decision_function, y=1)
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_plot(self):
"""Test for LDA. Check LDA Result Graphically.
Apply Lda to Sklearn Iris Dataset and compare it with
"Linear Discriminant Analysis bit by bit" by Sebastian Raschka
http://sebastianraschka.com/Articles/2014_python_lda.html
into the plot we must see approximatively:
x axes: from -2 to -1 virginica, from -1 to 0 versicolor, from 1 to 2,3 setosa
y axes: from -1 to -1 virginica, from -1 to 0.5 versicolor, from -1 to 1 setosa
"""
from sklearn.datasets import load_iris
iris_db = load_iris()
patterns = CArray(iris_db.data)
labels = CArray(iris_db.target)
lda = CLDA()
lda.fit(patterns, labels)
# store dataset reduced with pca
red_dts = lda.fit_transform(patterns, labels)
fig = CFigure(width=10, markersize=8)
fig.sp.scatter(red_dts[:, 0].ravel(),
red_dts[:, 1].ravel(),
c=labels)
fig.show()
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 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 test_plot_decision_function(self):
"""Test plot of multiclass classifier decision function."""
# generate synthetic data
ds = CDLRandom(n_classes=3, n_features=2, n_redundant=0,
n_clusters_per_class=1, class_sep=1,
random_state=0).load()
multiclass = CClassifierMulticlassOVA(
classifier=CClassifierSVM,
class_weight='balanced',
preprocess='min-max')
# Training and classification
multiclass.fit(ds.X, ds.Y)
y_pred, score_pred = multiclass.predict(
ds.X, return_decision_function=True)
def plot_hyperplane(img, clf, min_v, max_v, linestyle, label):
"""Plot the hyperplane associated to the OVA clf."""
xx = CArray.linspace(
min_v - 5, max_v + 5) # make sure the line is long enough
# get the separating hyperplane
yy = -(clf.w[0] * xx + clf.b) / clf.w[1]
img.sp.plot(xx, yy, linestyle, label=label)
fig = CFigure(height=7, width=8)
fig.sp.title('{:} ({:})'.format(multiclass.__class__.__name__,
multiclass.classifier.__name__))
x_bounds, y_bounds = ds.get_bounds()
styles = ['go-', 'yp--', 'rs-.', 'bD--', 'c-.', 'm-', 'y-.']
for c_idx, c in enumerate(ds.classes):
# Plot boundary and predicted label for each OVA classifier
plot_hyperplane(fig, multiclass._binary_classifiers[c_idx],
x_bounds[0], x_bounds[1], styles[c_idx],
'Boundary\nfor class {:}'.format(c))
fig.sp.scatter(ds.X[ds.Y == c, 0],
ds.X[ds.Y == c, 1],
s=40, c=styles[c_idx][0])
fig.sp.scatter(ds.X[y_pred == c, 0], ds.X[y_pred == c, 1], s=160,
edgecolors=styles[c_idx][0],
facecolors='none', linewidths=2)
# Plotting multiclass decision function
fig.sp.plot_decision_regions(multiclass, n_grid_points=100,
grid_limits=ds.get_bounds(offset=5))
fig.sp.xlim(x_bounds[0] - .5 * x_bounds[1],
x_bounds[1] + .5 * x_bounds[1])
fig.sp.ylim(y_bounds[0] - .5 * y_bounds[1],
y_bounds[1] + .5 * y_bounds[1])
fig.sp.legend(loc=4) # lower, right
fig.show()
def test_compute(self):
self.roc.compute(self.ds1.Y, self.s1[:, 1].ravel())
fig = CFigure()
fig.sp.semilogx(self.roc.fpr, self.roc.tpr)
fig.sp.grid()
fig.show()
def test_fgrads(self):
"""Test for CPlotFunction.plot_fgrads method."""
fig = CFigure()
fig.sp.plot_ds(self.dataset)
fig.sp.plot_fun(self.clf.decision_function, y=1)
fig.sp.plot_fgrads(lambda x: self.clf.grad_f_x(x, y=1))
fig.show()
def _save_fig(self):
"""Visualizing the function being optimized with line search."""
x_range = CArray.arange(-5, 20, 0.5, )
score_range = x_range.T.apply_along_axis(self.fun.fun, axis=1)
ref_line = CArray.zeros(x_range.size)
fig = CFigure(height=6, width=12)
fig.sp.plot(x_range, score_range, color='b')
fig.sp.plot(x_range, ref_line, color='k')
filename = fm.join(fm.abspath(__file__), 'test_line_search_bisect.pdf')
fig.savefig(filename)
def test_simple():
"""Plot the result of a dot product operation."""
def test_dot():
a = CArray([1, 2, 3])
b = CArray([10, 20, 30])
return a.dot(b)
fig = CFigure()
fig.sp.plot(test_dot(), marker='o')
fig.show()
def _plot_sec_eval(sec_eval):
figure = CFigure(height=5, width=5)
figure.sp.plot_sec_eval(sec_eval.sec_eval_data,
label='SVM', marker='o',
show_average=True, mean=True)
figure.sp.title(sec_eval.attack.__class__.__name__)
figure.subplots_adjust()
figure.show()
def test_confusion_matrix(self):
"""Test for `CPlot.plot_confusion_matrix()` method."""
y_true = CArray([2, 0, 2, 2, 0, 1])
y_pred = CArray([0, 0, 2, 2, 0, 2])
fig = CFigure()
fig.sp.plot_confusion_matrix(y_true,
y_pred,
labels=['one', 'two', 'three'],
colorbar=True,
normalize=False)
fig.show()
def test_standard(self):
"""Plot of standard ROC."""
# Testing without input CFigure
roc_plot = CFigure()
roc_plot.sp.title('ROC Curve Standard')
# Plotting 2 times (to show multiple curves)
# add one curve for repetition and call it rep 0 and rep 1 of roc 1
roc_plot.sp.plot_roc(self.roc_wmean.mean_fpr, self.roc_wmean.mean_tpr)
roc_plot.show()
def _plot_sec_eval(self):
# figure creation
figure = CFigure(height=5, width=5)
sec_eval_data = [
sec_eval.sec_eval_data for sec_eval in self.sec_eval]
# plot security evaluation
figure.sp.plot_sec_eval(sec_eval_data, label='SVM', marker='o',
show_average=True, mean=True)
figure.subplots_adjust()
figure.show()
def test_mean(self):
self.roc.compute([self.ds1.Y, self.ds2.Y],
[self.s1[:, 1].ravel(), self.s2[:, 1].ravel()])
mean_fp, mean_tp, mean_std = self.roc.average(return_std=True)
fig = CFigure(linewidth=2)
fig.sp.errorbar(self.roc.mean_fpr, self.roc.mean_tpr, yerr=mean_std)
for rep in range(self.roc.n_reps):
fig.sp.semilogx(self.roc.fpr[rep], self.roc.tpr[rep])
fig.sp.semilogx(mean_fp, mean_tp)
fig.sp.grid()
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 _plot_2d_evasion(self, evas, ds, x0, filename, th=0, grid_limits=None):
"""Plot evasion attack results for 2D data.
Parameters
----------
evas : CAttackEvasion
ds : CDataset
x0 : CArray
Initial attack point.
filename : str
Name of the output pdf file.
th : scalar, optional
Scores threshold of the classifier. Default 0.
grid_limits : list of tuple or None, optional
If not specified, will be set as [(-1.5, 1.5), (-1.5, 1.5)].
"""
if self.make_figures is False:
self.logger.debug("Skipping figures...")
return
fig = CFigure(height=6, width=6)
if grid_limits is None:
grid_limits = [(-1.5, 1.5), (-1.5, 1.5)]
fig.sp.plot_ds(ds)
fig.sp.plot_fun(func=evas.objective_function,
grid_limits=grid_limits,
colorbar=False,
n_grid_points=50,
plot_levels=False)
fig.sp.plot_decision_regions(clf=evas.classifier,
plot_background=False,
grid_limits=grid_limits,
n_grid_points=50)
fig.sp.plot_constraint(self._box(evas),
n_grid_points=20,
grid_limits=grid_limits)
fig.sp.plot_fun(func=lambda z: self._constr(evas, x0).constraint(z),
plot_background=False,
n_grid_points=50,
grid_limits=grid_limits,
levels=[0],
colorbar=False)
fig.sp.plot_path(evas.x_seq)
fig.savefig(fm.join(self.images_folder, filename), file_format='pdf')
def test_single(self):
"""Plot of ROC repetitions."""
# Testing without input CFigure
roc_plot = CFigure()
roc_plot.sp.title('ROC Curve Repetitions')
# Plotting 2 times (to show multiple curves)
# add one curve for repetition and call it rep 0 and rep 1 of roc 1
roc_plot.sp.plot_roc_reps(self.roc_nomean, label='roc1')
# add one curve for repetition and call it rep 0 and rep 1 of roc 2
roc_plot.sp.plot_roc_reps(self.roc_nomean, label='roc2')
roc_plot.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_custom_params(self):
"""Plot of ROC altering default parameters."""
# Testing without input CFigure
roc_plot = CFigure()
roc_plot.sp.title('ROC Curve - Custom')
roc_plot.sp.xlim(0.1, 100)
roc_plot.sp.ylim(30, 100)
roc_plot.sp.yticks([70, 80, 90, 100])
roc_plot.sp.yticklabels(['70', '80', '90', '100'])
# Plotting 2 times (to show 2 curves)
roc_plot.sp.plot_roc_mean(self.roc_wmean, label='roc1')
roc_plot.sp.plot_roc_mean(self.roc_wmean, label='roc2')
roc_plot.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_mean(self):
"""Plot of average ROC."""
# Testing without input CFigure
roc_plot = CFigure()
roc_plot.sp.title('ROC Curve')
# Plotting 2 times (to show 2 curves)
roc_plot.sp.plot_roc_mean(self.roc_wmean,
label='roc1 mean',
plot_std=True)
roc_plot.sp.plot_roc_reps(self.roc_wmean, label='roc1')
roc_plot.show()
# Testing mean plot with no average
with self.assertRaises(ValueError):
roc_plot.sp.plot_roc_mean(self.roc_nomean)
def test_quiver(self):
"""Test for `CPlot.quiver()` method."""
# gradient values creation
xv = CArray.arange(0, 2 * constants.pi, .2)
yv = CArray.arange(0, 2 * constants.pi, .2)
X, Y = CArray.meshgrid((xv, yv))
U = CArray.cos(X)
V = CArray.sin(Y)
plot = CFigure()
plot.sp.title('Gradient arrow')
plot.sp.quiver(U, V)
plot.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_draw(self):
"""Drawing the loss functions.
Inspired by: https://en.wikipedia.org/wiki/Loss_functions_for_classification
"""
fig = CFigure()
x = CArray.arange(-1, 3.01, 0.01)
for loss_id in ('e-insensitive', 'e-insensitive-squared', 'quadratic'):
self.logger.info("Creating loss: {:}".format(loss_id))
loss_class = CLoss.create(loss_id)
fig.sp.plot(x, loss_class.loss(CArray([1]), x), label=loss_id)
fig.sp.grid()
fig.sp.legend()
fig.show()
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 _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 _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')