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()