def PlotCalibration(self): CalibrationFile = self.lineEditFile.text() power_calibration = np.loadtxt(CalibrationFile) #plot the calibration plt.figure(1, figsize=(15, 10)) power_onto_cell_mW = power_calibration[1, :] cal_picker_power_mW = power_calibration[0, :] f.plot_data(cal_picker_power_mW,power_onto_cell_mW,'Picker power (mW)','Power onto cell (mW)',\ 'Calibration curve: Power onto cell vs Picker power',None,111,show=False) plt.savefig(self.getDailyDirectory() + '//Plot of Power onto cell vs Picker Power.png') plt.show()
def plot_originals(ax_array, path, col): with open(path) as axis_data: data = json.load(axis_data) time_samples = data['N_targets'] axis_targets = data['ang_pos_targets'] target_times = data['target_times'] tcp_vel = data['TCP_vel'] n_axes = data['n_axis'] delta_t = data['time_step_orig'] n_targets = data['N_targets'] axis_targets = axis_targets[0:n_axes] axis_vels = functions.derive_all(axis_targets, delta_t) axis_accs = functions.derive_all(axis_vels, delta_t) time_array = functions.real_time_array(n_targets, delta_t) functions.plot_data(ax_array[0][col], axis_targets, 'Angular Positions', time_array) functions.plot_data(ax_array[1][col], axis_vels, 'Angular Velocity', time_array) functions.plot_data( ax_array[2][col], axis_accs, 'Angular Acceleration ' + str(functions.acc_sum(axis_accs, delta_t)), time_array) plotter = Plotter(ax_array) plotter.plot_TCP(axis_targets, col, time_array)
def analyseCalibration(self): ephysfile = self.lineEditDir.text() #ephys .smr file mean_picker_volts = f.GetMeanVolts(ephysfile, self.pulse_duration_ms, self.energy_list, dead_time=2, test=True) plt.figure(2, figsize=(15, 10)) f.plot_data(self.energy_list,mean_picker_volts,'Input RL energy (uJ)','Mean Picker volts (V))',\ 'Calibration curve: Mean Picker Volts versus Input RL energy',None,111,show=False) plt.savefig( self.TimeDirectory + '\Figure 2- Plot of Mean Picker Volts versus Input RL energy.png') plt.show() plt.figure(3, figsize=(15, 10)) Power_density = f.convert_V_W(mean_picker_volts, self.picker_max_measurement_mW, self.picker_max_output_V, self.CalibrationFile, self.beam_diameter) f.plot_data(self.energy_list,Power_density,'Input RL energy (uJ)','Mean Power Density in sample (mW/um2))',\ 'Calibration curve: Mean Power Density in sample versus Input RL energy',None,111,show=False) plt.savefig( self.TimeDirectory + '\Figure 3- Plot of Mean Power Density in sample versus Input RL energy.png' ) plt.show() data = { 'energy_list': self.energy_list, 'mean_picker_volts': mean_picker_volts, 'Power_density': Power_density } results = pd.DataFrame(data=data) results.to_csv(self.TimeDirectory + '\Mean power density in sample vs energy list.csv') #Once saved, close window and go to next tab self.close()
def plotter_raw(ax_array, path, col): with open(path) as raw_data: data = json.load(raw_data) truth = data['jointArray'] #truth = data['theTruth'] delta_t = data['delta_t'] # n_axes = len(truth) time_samples = list(map(lambda a: len(a), truth))[0] + 2 axis_zeros = functions.build_zero_array(5, time_samples) # truth= [truth[:][0]] + axis_zeros n_axes = 6 all_axis_poses = list(map(lambda *a: list(a), *truth)) all_axis_poses = [all_axis_poses[0][:] ] + all_axis_poses + [all_axis_poses[-1][:]] axis_vels = functions.derive_all(all_axis_poses, delta_t) axis_accs = functions.derive_all(axis_vels, delta_t) time_array = functions.real_time_array(time_samples, delta_t) functions.plot_data(ax_array[0][col], np.transpose(all_axis_poses), text.position, time_array) oldvel = str(functions.vel_top(axis_vels, delta_t)) print('old top velocity:' + oldvel) functions.plot_data(ax_array[1][col], np.transpose(axis_vels), text.velocity + oldvel, time_array[:-1]) oldacc = str(functions.acc_sum(axis_accs, delta_t)) print('old acc sum: ' + oldacc) functions.plot_data(ax_array[2][col], np.transpose(axis_accs), text.acceleration + oldacc, time_array[:-2]) plotter = Plotter(ax_array) if (len(all_axis_poses) > 1): plotter.plot_TCP(all_axis_poses, col, time_array)
def PlotChannels(self): ephys, picker, Vm, Im, picker_units, Vm_units, Im_units, Vm_Hz, Im_Hz, picker_Hz = f.loadEphysData( self.lineEditDir.text()) # plot the data plt.figure(7, figsize=(20, 15)) f.plot_data(picker.times,np.squeeze(picker),'Time (s)','Picker power meter\nmeasurement output (V)',\ 'Picker power meter (measurement output) voltage vs time',None,311,show=False) f.plot_data(Vm.times, np.squeeze(Vm), None, f'Membrane Voltage\n({Vm.units})', 'Membrane voltage vs time', [-50, -10], 312, show=False) f.plot_data(Im.times, np.squeeze(Im), None, f'Membrane Current\n({Im.units})', 'Membrane current vs time', [-1, 1], 313, show=False) plt.savefig(self.TimeDirectory + '\Figure 7- Plot of Ephys Channels (Part 1).png') plt.show()
def plot_optimized(self, path, colNumber): with open(path) as axis_data: data = json.load(axis_data) resolution = data['resolution'] time_samples = data['N'] n_targets = data['N_targets'] axis_poses_original = data['optimal_poses'] axis_vels_original = data['optimal_velocity'] axis_accs_original = data['optimal_acceleration'] axis_poses = data['optimal_poses_decimated'] axis_vels = data['optimal_velocity_decimated'] axis_accs = data['optimal_acceleration_decimated'] axis_targets = data['ang_pos_targets'] target_times = data['target_times'] tcp_vel = data['TCP_vel'] tcp_vel_original = data['TCP_vel_original'] n_axes = data['n_axis'] delta_t = data['time_step_orig'] time_end = data['time_end'] n_targets = n_targets + 2 axis_poses_original = list( map(lambda a: list(map(lambda b: b - np.pi * 10, a)), axis_poses_original)) n_axes = 6 # axis_poses = list(map(lambda a: list(map(lambda b: b-np.pi*2,a)),axis_poses_original)) axis_poses = axis_poses_original axis_zeros = functions.build_zero_array(5, time_samples) # axis_poses_original = [axis_poses_original[:][0]] + axis_zeros if (len(axis_poses) > 1): axis_poses = list(map(lambda *a: list(a), *axis_poses)) axis_vels = functions.derive_all(axis_poses, delta_t) axis_accs = functions.derive_all(axis_vels, delta_t) if (len(axis_poses) > 1): axis_vels = np.transpose(axis_vels) axis_accs = np.transpose(axis_accs) time_array = functions.real_time_array(time_samples, delta_t) time_array_upsampled = functions.real_time_array( time_samples, delta_t * resolution) # functions.plot_data(self.ax_array[0][colNumber], axis_poses, 'Ang Pos Decimated', time_array) functions.plot_data(self.ax_array[0][colNumber], axis_poses_original, text.position, time_array_upsampled) # functions.plot_data(self.ax_array[1][colNumber], axis_vels, 'Angular Velocities Decimated ' +str(functions.vel_top(axis_vels,delta_t)), time_array[:-1]) newvel = str(functions.vel_top(axis_vels, delta_t)) print('new top velocity: ' + newvel) functions.plot_data(self.ax_array[1][colNumber], axis_vels_original, text.velocity + newvel, time_array_upsampled[:-1]) newacc = str(functions.acc_sum(axis_accs, delta_t)) print('new acc sum: ' + newacc) # functions.plot_data(self.ax_array[2][colNumber], axis_accs, 'Angular Acceleration ' +newacc, time_array[:-2]) functions.plot_data( self.ax_array[2][colNumber], axis_accs_original, text.acceleration + str(functions.acc_sum(axis_accs_original, delta_t / resolution)), time_array_upsampled[:-2]) # for k,t in enumerate(target_times): # self.ax_array[0][colNumber].scatter(t/(delta_t*resolution), axis_targets[0][k]) # for k,t in enumerate(target_times): # self.ax_array[0][colNumber+1].scatter(t/(delta_t*resolution), axis_targets[0][k]) if (len(axis_poses_original) > 1): # self.plot_TCP(axis_poses, colNumber, time_array) self.plot_TCP(np.transpose(axis_poses_original), colNumber, time_array_upsampled)
GOOG_df_M = GOOG_df.groupby(pd.Grouper(freq='M')).mean() SP500_df_M = SP500_df.groupby(pd.Grouper(freq='M')).mean() ############################################################################### ######################## GET ONLY THE ADJ CLOSE COLUMN ######################## AAPL_adj_close = AAPL_df_M['Adj Close'] MSFT_adj_close = MSFT_df_M['Adj Close'] AMZN_adj_close = AMZN_df_M['Adj Close'] GOOG_adj_close = GOOG_df_M['Adj Close'] SP500_adj_close = SP500_df_M['Adj Close'] ############################################################################### #################### PLOTTING THE STOCK TAKEN INTO ANALYSIS ################### f.plot_data(AAPL_adj_close, 'Adjusted close price of AAPL', ['Date (year)', 'Adj close price (USD)'], [colors[0]]) f.plot_data(MSFT_adj_close, 'Adjusted close price of MSFT', ['Date (year)', 'Adj close price (USD)'], [colors[1]]) f.plot_data(AMZN_adj_close, 'Adjusted close price of AMZN', ['Date (year)', 'Adj close price (USD)'], [colors[2]]) f.plot_data(GOOG_adj_close, 'Adjusted close price of GOOG', ['Date (year)', 'Adj close price (USD)'], [colors[3]]) ############################################################################### ############ MERGE ALL STOCKS DATA INTO A DATA OBJECT AND PLOT IT ############# STOCKS_adj_close = pd.concat( [AAPL_adj_close, MSFT_adj_close, AMZN_adj_close, GOOG_adj_close], axis=1)
plt.grid() plt.legend() plt.xlabel('Regularization parameter') plt.ylabel('Accuracy') plt.title('Accuracy of SVM with different kernels on 1st data matrix') plt.savefig('SVM1.png') plt.show() ''' Grid search using the multi-layer perceptron ''' y_train = y_train.reshape(-1, 1) y_test = y_test.reshape(-1, 1) y_train = to_categorical(y_train) y_test = to_categorical(y_test) nh = np.array([1, 2, 4, 8]) #hidden nodes et = np.array([0.001, 0.01, 0.05, 0.1]) #Learning rate train_accuracy = np.zeros((len(nh), len(et))) test_accuracy = np.zeros((len(nh), len(et))) for i, n in enumerate(nh): for j, e in enumerate(et): mlp1 = mlp.mlp(X_train, y_train, nhidden=n, eta=e, linear=False) mlp1.earlystopping(X_train, y_train, X_test, y_test) train_accuracy[i, j] = (mlp1.score(X_train, y_train)) test_accuracy[i, j] = (mlp1.score(X_test, y_test)) plot_data(et, nh, train_accuracy) plot_data(et, nh, test_accuracy)
test_accuracy = np.zeros((len(et), len(ld))) critical_accuracy = np.zeros((len(et), len(ld))) for i, l in enumerate(ld): for j, e in enumerate(et): clf = logistic_regression.logistic_regression(eta=e, num_iter=1000, ld=l) clf.fit(X_train, y_train) train_accuracy[i, j] = (clf.score(X_train, y_train)) test_accuracy[i, j] = (clf.score(X_test, y_test)) critical_accuracy[i, j] = (clf.score(data_critical, labels_critical)) plot_data(et, ld, train_accuracy) plot_data(et, ld, test_accuracy) plot_data(et, ld, critical_accuracy) ''' Now using MLP ''' #Turn into one-hot vector y_test = to_categorical(y_test) y_train = to_categorical(y_train) labels_critical = to_categorical(labels_critical) #parameter values nh = np.array([50, 100]) #hidden nodes et = np.array([0.01, 0.1]) #Learning rate
def main(): #getting and cleaning data data = functions.get_array('data') data = [i.split('\t') for i in data] #date range if wanted #mm/dd/yy format user_in = input("Date range? ") if(len(user_in) > 0): user_in = user_in.split(' ') dates = [functions.strip_time(i) for i in user_in] #trimming data if date range if given if 'dates' in locals(): data = functions.date_trim(data, dates) if(data == 0): print("No data in that range") return #binning data print("Total number of runs in selection: ",len(data)) sigma = 4.0 #sigma of data to trim bins = np.arange(45) #one bin for each km out to 45km data = functions.bin_data(data, bins, sigma) #splitting up data into variables and joining bins together start = list(itertools.chain.from_iterable(data[0])) time = list(itertools.chain.from_iterable(data[1])) distance = list(itertools.chain.from_iterable(data[2])) elevation = list(itertools.chain.from_iterable(data[3])) PRs = list(itertools.chain.from_iterable(data[4])) ################## # plots # ################## #time v distance functions.plot_data(time, distance, 1, "Time (minutes)", "Distance (km)", 211) #converting to miles miles = functions.convert_distance(distance,'miles') functions.plot_data(time, miles, 1, "Time (minutes)", "Distance (miles)", 212) #histogram of runs per distance bins = np.arange(45) functions.plot_hist(distance, bins, 2, "Distance (km)", "Number of runs", 211) bins = np.arange(28) functions.plot_hist(miles, bins, 2, "Distance (miles)", "Number of runs", 212) #distance v elevation #only plotting runs with >0 meters elevation index = [i for i in range(0,len(elevation)) if elevation[i] != 0] elevation1 = [elevation[i] for i in index] distance1 = [distance[i] for i in index] miles1 = [miles[i] for i in index] feet = functions.convert_distance(elevation1,'feet') functions.plot_data(distance1, elevation1, 3, "Distance (km)", "Elevation (m)", 211) functions.plot_data(miles1, feet, 3, "Distance (miles)", "Elevation (ft)", 212) #only plotting runs with >1 PR PR1 = [i for i in PRs if i != 0] bins = np.arange(25) functions.plot_hist(PR1, bins, 4, "PRs set in a single run", "Number of runs", 0) print("Average length of run: "+str(stats.mean(distance))+' km \t'+str(stats.mean(miles))+' miles') print("Average elevation of run: "+str(stats.mean(elevation))+' m \t'+str(stats.mean(feet))+' feet') plt.show() return
def main(argv=None): from cleverhans_tutorials import check_installation check_installation(__file__) if not os.path.exists( CONFIG.SAVE_PATH ): os.makedirs( CONFIG.SAVE_PATH ) save_path_data = CONFIG.SAVE_PATH + 'data/' if not os.path.exists( save_path_data ): os.makedirs( save_path_data ) model_path = CONFIG.SAVE_PATH + '../all/' + CONFIG.DATASET + '/' if not os.path.exists( model_path ): os.makedirs( model_path ) os.makedirs( model_path + 'data/' ) nb_epochs = FLAGS.nb_epochs batch_size = FLAGS.batch_size learning_rate = FLAGS.learning_rate nb_filters = FLAGS.nb_filters len_x = int(CONFIG.NUM_TEST/2) start = time.time() # Object used to keep track of (and return) key accuracies report = AccuracyReport() # Set seeds to improve reproducibility if CONFIG.DATASET == 'mnist' or CONFIG.DATASET == 'cifar10': tf.set_random_seed(1234) np.random.seed(1234) rd.seed(1234) elif CONFIG.DATASET == 'moon' or CONFIG.DATASET == 'dims': tf.set_random_seed(13) np.random.seed(1234) rd.seed(0) # Set logging level to see debug information set_log_level(logging.DEBUG) # Create TF session tf_config = tf.ConfigProto(allow_soft_placement=True,log_device_placement=True) tf_config.gpu_options.per_process_gpu_memory_fraction = 0.2 sess = tf.Session(config=tf_config) if CONFIG.DATASET == 'mnist': # Get MNIST data mnist = MNIST(train_start=0, train_end=CONFIG.NUM_TRAIN, test_start=0, test_end=CONFIG.NUM_TEST) x_train, y_train = mnist.get_set('train') x_test, y_test = mnist.get_set('test') elif CONFIG.DATASET == 'cifar10': # Get CIFAR10 data data = CIFAR10(train_start=0, train_end=CONFIG.NUM_TRAIN, test_start=0, test_end=CONFIG.NUM_TEST) dataset_size = data.x_train.shape[0] dataset_train = data.to_tensorflow()[0] dataset_train = dataset_train.map( lambda x, y: (random_shift(random_horizontal_flip(x)), y), 4) dataset_train = dataset_train.batch(batch_size) dataset_train = dataset_train.prefetch(16) x_train, y_train = data.get_set('train') x_test, y_test = data.get_set('test') elif CONFIG.DATASET == 'moon': # Create a two moon example X, y = make_moons(n_samples=(CONFIG.NUM_TRAIN+CONFIG.NUM_TEST), noise=0.2, random_state=0) X = StandardScaler().fit_transform(X) x_train1, x_test1, y_train1, y_test1 = train_test_split(X, y, test_size=(CONFIG.NUM_TEST/(CONFIG.NUM_TRAIN +CONFIG.NUM_TEST)), random_state=0) x_train, y_train, x_test, y_test = normalize_reshape_inputs_2d(model_path, x_train1, y_train1, x_test1, y_test1) elif CONFIG.DATASET == 'dims': X, y = make_moons(n_samples=(CONFIG.NUM_TRAIN+CONFIG.NUM_TEST), noise=0.2, random_state=0) X = StandardScaler().fit_transform(X) x_train1, x_test1, y_train1, y_test1 = train_test_split(X, y, test_size=(CONFIG.NUM_TEST/(CONFIG.NUM_TRAIN +CONFIG.NUM_TEST)), random_state=0) x_train2, y_train, x_test2, y_test = normalize_reshape_inputs_2d(model_path, x_train1, y_train1,x_test1, y_test1) x_train, x_test = add_noise_and_QR(x_train2, x_test2, CONFIG.NUM_DIMS) np.save(os.path.join(save_path_data, 'x_test'), x_test) np.save(os.path.join(save_path_data, 'y_test'), y_test) # Use Image Parameters img_rows, img_cols, nchannels = x_train.shape[1:4] nb_classes = y_train.shape[1] # Define input TF placeholder x = tf.placeholder(tf.float32, shape=(None, img_rows, img_cols, nchannels)) y = tf.placeholder(tf.float32, shape=(None, nb_classes)) # Train an model train_params = { 'nb_epochs': nb_epochs, 'batch_size': batch_size, 'learning_rate': learning_rate } eval_params = {'batch_size': 1} rng = np.random.RandomState([2017, 8, 30]) with open(CONFIG.SAVE_PATH + 'acc_param.txt', 'a') as fi: def do_eval(adv_x, preds, x_set, y_set, report_key): acc, pred_np, adv_x_np = model_eval(sess, x, y, preds, adv_x, nb_classes, x_set, y_set, args=eval_params) setattr(report, report_key, acc) if report_key: print('Accuracy on %s examples: %0.4f' % (report_key, acc), file=fi) return pred_np, adv_x_np if CONFIG.DATASET == 'mnist': trained_model_path = model_path + 'data/trained_model' model = ModelBasicCNN('model1', nb_classes, nb_filters) elif CONFIG.DATASET == 'cifar10': trained_model_path = model_path + 'data/trained_model' model = ModelAllConvolutional('model1', nb_classes, nb_filters, input_shape=[32, 32, 3]) elif CONFIG.DATASET == 'moon': trained_model_path = model_path + 'data/trained_model' model = ModelMLP('model1', nb_classes) elif CONFIG.DATASET == 'dims': trained_model_path = save_path_data + 'trained_model' model = ModelMLP_dyn('model1', nb_classes, CONFIG.NUM_DIMS) preds = model.get_logits(x) loss = CrossEntropy(model, smoothing=0.1) def evaluate(): _, _ = do_eval(x, preds, x_test, y_test, 'test during train') if os.path.isfile( trained_model_path + '.index' ): tf_model_load(sess, trained_model_path) else: if CONFIG.DATASET == 'mnist': train(sess, loss, x_train, y_train, evaluate=evaluate, args=train_params, rng=rng, var_list=model.get_params()) elif CONFIG.DATASET == 'cifar10': train(sess, loss, None, None, dataset_train=dataset_train, dataset_size=dataset_size, evaluate=evaluate, args=train_params, rng=rng, var_list=model.get_params()) elif CONFIG.DATASET == 'moon': train_2d(sess, loss, x, y, x_train, y_train, save=False, evaluate=evaluate, args=train_params, rng=rng, var_list=model.get_params()) elif CONFIG.DATASET == 'dims': train_2d(sess, loss, x, y, x_train, y_train, evaluate=evaluate, args=train_params, rng=rng, var_list=model.get_params()) saver = tf.train.Saver() saver.save(sess, trained_model_path) # Evaluate the accuracy on test examples if os.path.isfile( save_path_data + 'logits_zero_attacked.npy' ): logits_0 = np.load(save_path_data + 'logits_zero_attacked.npy') else: _, _ = do_eval(x, preds, x_train, y_train, 'train') logits_0, _ = do_eval(x, preds, x_test, y_test, 'test') np.save(os.path.join(save_path_data, 'logits_zero_attacked'), logits_0) if CONFIG.DATASET == 'moon': num_grid_points = 5000 if os.path.isfile( model_path + 'data/images_mesh' + str(num_grid_points) + '.npy' ): x_mesh = np.load(model_path + 'data/images_mesh' + str(num_grid_points) + '.npy') logits_mesh = np.load(model_path + 'data/logits_mesh' + str(num_grid_points) + '.npy') else: xx, yy = np.meshgrid(np.linspace(0, 1, num_grid_points), np.linspace(0, 1, num_grid_points)) x_mesh1 = np.stack([np.ravel(xx), np.ravel(yy)]).T y_mesh1 = np.ones((x_mesh1.shape[0]),dtype='int64') x_mesh, y_mesh, _, _ = normalize_reshape_inputs_2d(model_path, x_mesh1, y_mesh1) logits_mesh, _ = do_eval(x, preds, x_mesh, y_mesh, 'mesh') x_mesh = np.squeeze(x_mesh) np.save(os.path.join(model_path, 'data/images_mesh'+str(num_grid_points)), x_mesh) np.save(os.path.join(model_path, 'data/logits_mesh'+str(num_grid_points)), logits_mesh) points_x = x_test[:len_x] points_y = y_test[:len_x] points_x_bar = x_test[len_x:] points_y_bar = y_test[len_x:] # Initialize the CW attack object and graph cw = CarliniWagnerL2(model, sess=sess) # first attack attack_params = { 'learning_rate': CONFIG.CW_LEARNING_RATE, 'max_iterations': CONFIG.CW_MAX_ITERATIONS } if CONFIG.DATASET == 'moon': out_a = compute_polytopes_a(x_mesh, logits_mesh, model_path) attack_params['const_a_min'] = out_a attack_params['const_a_max'] = 100 adv_x = cw.generate(x, **attack_params) if os.path.isfile( save_path_data + 'images_once_attacked.npy' ): adv_img_1 = np.load(save_path_data + 'images_once_attacked.npy') logits_1 = np.load(save_path_data + 'logits_once_attacked.npy') else: #Evaluate the accuracy on adversarial examples preds_adv = model.get_logits(adv_x) logits_1, adv_img_1 = do_eval(adv_x, preds_adv, points_x_bar, points_y_bar, 'test once attacked') np.save(os.path.join(save_path_data, 'images_once_attacked'), adv_img_1) np.save(os.path.join(save_path_data, 'logits_once_attacked'), logits_1) # counter attack attack_params['max_iterations'] = 1024 if CONFIG.DATASET == 'moon': out_alpha2 = compute_epsilons_balls_alpha(x_mesh, np.squeeze(x_test), np.squeeze(adv_img_1), model_path, CONFIG.SAVE_PATH) attack_params['learning_rate'] = out_alpha2 attack_params['const_a_min'] = -1 attack_params['max_iterations'] = 2048 plot_data(np.squeeze(adv_img_1), logits_1, CONFIG.SAVE_PATH+'data_pred1.png', x_mesh, logits_mesh) adv_adv_x = cw.generate(x, **attack_params) x_k = np.concatenate((points_x, adv_img_1), axis=0) y_k = np.concatenate((points_y, logits_1), axis=0) if os.path.isfile( save_path_data + 'images_twice_attacked.npy' ): adv_img_2 = np.load(save_path_data + 'images_twice_attacked.npy') logits_2 = np.load(save_path_data + 'logits_twice_attacked.npy') else: # Evaluate the accuracy on adversarial examples preds_adv_adv = model.get_logits(adv_adv_x) logits_2, adv_img_2 = do_eval(adv_adv_x, preds_adv_adv, x_k, y_k, 'test twice attacked') np.save(os.path.join(save_path_data, 'images_twice_attacked'), adv_img_2) np.save(os.path.join(save_path_data, 'logits_twice_attacked'), logits_2) if CONFIG.DATASET == 'moon': plot_data(np.squeeze(adv_img_2[:len_x]), logits_2[:len_x], CONFIG.SAVE_PATH+'data_pred2.png', x_mesh, logits_mesh) plot_data(np.squeeze(adv_img_2[len_x:]), logits_2[len_x:], CONFIG.SAVE_PATH+'data_pred12.png', x_mesh, logits_mesh) test_balls(np.squeeze(x_k), np.squeeze(adv_img_2), logits_0, logits_1, logits_2, CONFIG.SAVE_PATH) compute_returnees(logits_0[len_x:], logits_1, logits_2[len_x:], logits_0[:len_x], logits_2[:len_x], CONFIG.SAVE_PATH) if x_test.shape[-1] > 1: num_axis=(1,2,3) else: num_axis=(1,2) D_p = np.squeeze(np.sqrt(np.sum(np.square(points_x-adv_img_2[:len_x]), axis=num_axis))) D_p_p = np.squeeze(np.sqrt(np.sum(np.square(adv_img_1-adv_img_2[len_x:]), axis=num_axis))) D_p_mod, D_p_p_mod = modify_D(D_p, D_p_p, logits_0[len_x:], logits_1, logits_2[len_x:], logits_0[:len_x], logits_2[:len_x]) if D_p_mod != [] and D_p_p_mod != []: plot_violins(D_p_mod, D_p_p_mod, CONFIG.SAVE_PATH) threshold_evaluation(D_p_mod, D_p_p_mod, CONFIG.SAVE_PATH) _ = compute_auroc(D_p_mod, D_p_p_mod, CONFIG.SAVE_PATH) plot_results_models(len_x, CONFIG.DATASET, CONFIG.SAVE_PATH) print('Time needed:', time.time()-start) return report