def get_ge(net_name, model_parameters, load_parameters): args = util.EmptySpace() for key, value in load_parameters.items(): setattr(args, key, value) folder = "/media/rico/Data/TU/thesis/runs{}/{}".format( args.experiment, util.generate_folder_name(args)) ge_x, ge_y = [], [] lta, lva, ltl, lvl = [], [], [], [] for run in runs: filename = '{}/model_r{}_{}'.format( folder, run, get_save_name(net_name, model_parameters)) ge_path = '{}.exp'.format(filename) y_r = util.load_csv(ge_path, delimiter=' ', dtype=np.float) x_r = range(len(y_r)) ge_x.append(x_r) ge_y.append(y_r) if show_losses or show_acc: ta, va, tl, vl = util.load_loss_acc(filename) lta.append(ta) lva.append(va) ltl.append(tl) lvl.append(vl) return ge_x, ge_y, (lta, lva, ltl, lvl)
def get_ranks(args): # Load the data and make it global global x_attack, y_attack, dk_plain, key_guesses x_attack, y_attack, key_guesses, real_key, dk_plain = load_data(args) model_params = {} map_accuracy = {} folder = "{}/{}/".format(args.models_path, generate_folder_name(args)) model_params.update({"max_pool": args.max_pool}) for channel_size in args.channels: model_params.update({"channel_size": channel_size}) for layers in args.layers: model_params.update({"num_layers": layers}) for kernel in args.kernels: model_params.update({"kernel_size": kernel}) # Calculate the accuracy mean_acc = 0.0 no_data = False for run in range(args.runs): model_path = '{}/model_r{}_{}.pt'.format( folder, run, get_save_name(args.network_name, model_params)) if not os.path.exists(model_path): print(util.BColors.WARNING + f"Path {model_path} does not exists" + util.BColors.ENDC) no_data = True break print('path={}'.format(model_path)) model = load_model(args.network_name, model_path) model.eval() print("Using {}".format(model)) model.to(args.device) # Calculate predictions if require_domain_knowledge(args.network_name): _, acc = accuracy2(model, x_attack, y_attack, dk_plain) else: _, acc = accuracy2(model, x_attack, y_attack, None) print('Accuracy: {} - {}%'.format(acc, acc * 100)) acc = acc * 100 mean_acc = mean_acc + acc if not no_data: mean_acc = mean_acc / float(args.runs) map_accuracy.update({f"c_{channel_size}_l{layers}_k{kernel}": mean_acc}) print(util.BColors.WARNING + f"Mean accuracy {mean_acc}" + util.BColors.ENDC) if args.noise_level >= 0: acc_filename = f"{folder}/acc_{args.network_name}_noise{args.noise_level}.json" else: acc_filename = f"{folder}/acc_{args.network_name}.json" print(acc_filename) with open(acc_filename, "w") as acc_file: acc_file.write(json.dumps(map_accuracy))
def get_ranks(args, network_name, model_params): # Load the data and make it global global x_attack, y_attack, dk_plain, key_guesses x_attack, y_attack, key_guesses, real_key, dk_plain = load_data( args, network_name) folder = "{}/{}/".format(args.models_path, generate_folder_name(args)) # Calculate the predictions before hand predictions = [] for run in args.runs: model_path = '{}/model_r{}_{}.pt'.format( folder, run, get_save_name(network_name, model_params)) print('path={}'.format(model_path)) model = load_model(network_name, model_path) model.eval() print("Using {}".format(model)) model.to(args.device) # Calculate predictions if require_domain_knowledge(network_name): prediction = accuracy(model, x_attack, y_attack, dk_plain) predictions.append(prediction.cpu().numpy()) else: prediction = accuracy(model, x_attack, y_attack, None) predictions.append(prediction.cpu().numpy()) # Check if it is only one run, if so don't do multi threading if len(args.runs) == 1: threaded_run_test(args, predictions[0], folder, args.runs[0], network_name, model_params, real_key) else: # Start a thread for each run processes = [] for i, run in enumerate(args.runs): p = Process(target=threaded_run_test, args=(args, predictions[i], folder, run, network_name, model_params, real_key)) processes.append(p) p.start() # Wait for them to finish for p in processes: p.join() print('Joined process')
def get_ge(net_name, model_parameters): folder = "{}/{}".format('/media/rico/Data/TU/thesis/runs/', util.generate_folder_name(args)) ge_x, ge_y = [], [] lta, lva, ltl, lvl = [], [], [], [] for run in runs: filename = '{}/model_r{}_{}'.format( folder, run, get_save_name(net_name, model_parameters)) ge_path = '{}.exp'.format(filename) y_r = util.load_csv(ge_path, delimiter=' ', dtype=np.float) x_r = range(len(y_r)) ge_x.append(x_r) ge_y.append(y_r) if show_losses or show_acc: ta, va, tl, vl = util.load_loss_acc(filename) lta.append(ta) lva.append(va) ltl.append(tl) lvl.append(vl) return ge_x, ge_y, (lta, lva, ltl, lvl)
def get_ranks(args, network_name, model_params, edit_model=disable_filter): folder = "{}/{}/".format(args.models_path, generate_folder_name(args)) # Calculate the predictions before hand # TODO: for multiple runs model_path = '{}/model_r{}_{}.pt'.format( folder, args.run, get_save_name(network_name, model_params)) print('path={}'.format(model_path)) if not os.path.exists(f"{model_path}.predictions1.npy"): # Load the data and make it global global x_attack, y_attack, dk_plain, key_guesses x_attack, y_attack, key_guesses, real_key, dk_plain = load_data( args, network_name) model = load_model(network_name, model_path) model.eval() model.to(args.device) predictions, correct_indices, sum_indices = edit_model(model) np_predictions = np.array(predictions) np_correct_indices = np.array(correct_indices) np_sum_indices = np.array(sum_indices) np.save(f"{model_path}.predictions1", np_predictions) np.save(f"{model_path}.correct_indices", np_correct_indices) np.save(f"{model_path}.sum_indices", np_sum_indices) print(sum_indices) else: predictions = np.load(f"{model_path}.predictions1.npy") real_key = util.load_csv('{}/{}/secret_key.csv'.format( args.traces_path, str(load_args.data_set)), dtype=np.int) key_guesses = util.load_csv( '{}/{}/Value/key_guesses_ALL_transposed.csv'.format( args.traces_path, str(load_args.data_set)), delimiter=' ', dtype=np.int, start=load_args.train_size + load_args.validation_size, size=load_args.attack_size) # Start a thread for each prediction groups_of = 7 for k in range(math.ceil(len(predictions) / float(groups_of))): # Start groups of processes processes = [] for i in range(k * groups_of, (k + 1) * groups_of, 1): if i >= len(predictions): break print(f"i: {i}") p = Process(target=threaded_run_test, args=(args, predictions[i], folder, args.run, network_name, model_params, real_key, i)) processes.append(p) p.start() # Wait for the processes to finish for p in processes: p.join() print('Joined process')
def run(args): # Save the models to this folder dir_name = generate_folder_name(args) # Arguments for loading data load_args = {"unmask": args.unmask, "use_hw": args.use_hw, "traces_path": args.traces_path, "sub_key_index": args.subkey_index, "raw_traces": args.raw_traces, "size": args.train_size + args.validation_size, "train_size": args.train_size, "validation_size": args.validation_size, "domain_knowledge": True, "desync": args.desync, "use_noise_data": args.use_noise_data, "start": 0, "data_set": args.data_set} # Load data and chop into the desired sizes load_function = load_data_set(args.data_set) print(load_args) x_train, y_train, plain = load_function(load_args) x_validation = x_train[args.train_size:args.train_size + args.validation_size] y_validation = y_train[args.train_size:args.train_size + args.validation_size] x_train = x_train[0:args.train_size] y_train = y_train[0:args.train_size] p_train = None p_validation = None if plain is not None: p_train = plain[0:args.train_size] p_validation = plain[args.train_size:args.train_size + args.validation_size] print('Shape x: {}'.format(np.shape(x_train))) # Arguments for initializing the model init_args = {"sf": args.spread_factor, "input_shape": args.input_shape, "n_classes": 9 if args.use_hw else 256, "kernel_size": args.kernel_size, "channel_size": args.channel_size, "num_layers": args.num_layers, "max_pool": args.max_pool } # Do the runs for i in range(args.runs): # Initialize the network and the weights network = args.init(init_args) init_weights(network, args.init_weights) # Filename of the model + the folder filename = 'model_r{}_{}'.format(i, network.name()) model_save_file = '{}/{}/{}.pt'.format(args.model_save_path, dir_name, filename) print('Training with learning rate: {}, desync {}'.format(args.lr, args.desync)) if args.domain_knowledge: network, res = train_dk2(x_train, y_train, p_train, train_size=args.train_size, x_validation=x_validation, y_validation=y_validation, p_validation=p_validation, validation_size=args.validation_size, network=network, epochs=args.epochs, batch_size=args.batch_size, lr=args.lr, checkpoints=args.checkpoints, save_path=model_save_file, loss_function=args.loss_function, l2_penalty=args.l2_penalty, ) else: network, res = train(x_train, y_train, train_size=args.train_size, x_validation=x_validation, y_validation=y_validation, validation_size=args.validation_size, network=network, epochs=args.epochs, batch_size=args.batch_size, lr=args.lr, checkpoints=args.checkpoints, save_path=model_save_file, loss_function=args.loss_function, l2_penalty=args.l2_penalty, optimizer=args.optimizer ) # Save the results of the accuracy and loss during training save_loss_acc(model_save_file, filename, res) # Make sure don't mess with our min/max of the spread network if isinstance(network, SpreadNet): network.training = False # Save the final model save_model(network, model_save_file)
"lr": '%.2E' % Decimal(0.0001), "l2_penalty": 0, "train_size": 1000, "kernel_size": 20, "num_layers": 2, "channel_size": 16, "network_name": "SpreadV3", #""DenseNorm", "init_weights": "", "run": 0 } args = util.EmptySpace() for key, value in settings.items(): setattr(args, key, value) folder = "/media/rico/Data/TU/thesis/runs{}/{}".format(args.experiment, util.generate_folder_name(args)) filename = folder + f"/model_r{args.run}_" + util_classes.get_save_name(args.network_name, settings) + ".pt" model = load_model(args.network_name, filename) print(model) x_test, _, _, _, _ = util.load_ascad_test_traces({ "sub_key_index": 2, "desync": 0, "traces_path": "/media/rico/Data/TU/thesis/data", "unmask": args.unmask, "use_hw": args.use_hw }) x_test = x_test print(f"Shape x_test {np.shape(x_test)}") x_test = torch.from_numpy(x_test.astype(np.float32)).to(util.device)
"l2_penalty": 0.0005, "train_size": 40000, "kernel_size": 50, "num_layers": 1, "channel_size": 128, "max_pool": 64, "network_name": "SmallCNN", "init_weights": "kaiming", "run": 0 } args = util.EmptySpace() for key, value in settings.items(): setattr(args, key, value) folder = "/media/rico/Data/TU/thesis/runs3{}/{}".format( args.experiment, util.generate_folder_name(args)) filename = folder + f"/model_r{args.run}_" + util_classes.get_save_name( args.network_name, settings) + ".pt" model = load_model(args.network_name, filename) print(model) c = model.cnn[0] print(c) # print(model.block1[0][0].weights) w = c.weight print(c.bias.size()) # exit() shape_weight = w.size() print(f"Shape weight: {shape_weight}") for channel_index in range(shape_weight[1]):