def threaded_run_test(args, prediction, folder, run, network_name,
model_params, real_key):
# Shuffle the data using same permutation for n_exp and calculate mean for GE of the model
y = []
for exp_i in range(args.num_exps):
# Select permutation
permutation = args.permutations[exp_i]
# Shuffle data
predictions_shuffled = shuffle_permutation(permutation,
np.array(prediction))
key_guesses_shuffled = shuffle_permutation(permutation, key_guesses)
# Test the data
x_exp, y_exp = test_with_key_guess_p(key_guesses_shuffled,
predictions_shuffled,
attack_size=args.attack_size,
real_key=real_key,
use_hw=args.use_hw)
y.append(y_exp)
# Calculate the mean over the experiments
y = np.mean(y, axis=0)
if args.use_noise_data:
save_path = '{}model_r{}_{}_noise{}.exp'.format(
folder, run, get_save_name(network_name, model_params),
args.noise_level)
else:
save_path = '{}model_r{}_{}.exp'.format(
folder, run, get_save_name(network_name, model_params))
print("Save path {}".format(save_path))
util.save_np(save_path, y, f="%f")
def retrieve_ge(net_setting):
print(model_params)
ge_x, ge_y, loss_acc = get_ge(network_name, model_params,
net_setting)
mean_y = np.mean(ge_y, axis=0)
ranks_x.append(ge_x)
ranks_y.append(ge_y)
rank_mean_y.append(mean_y)
name_models.append(
util_classes.get_save_name(network_name, model_params))
(lvl, ltl, lta, lva) = loss_acc
# loss_vali, loss_train, acc_train, acc_vali
net_setting['ge_x'].append(ge_x[0])
net_setting['ge_y'].append(mean_y)
net_setting['ta'].append(np.mean(lta, axis=0))
net_setting['va'].append(np.mean(lva, axis=0))
net_setting['tl'].append(np.mean(ltl, axis=0))
net_setting['vl'].append(np.mean(lvl, axis=0))
net_setting['line_title'].append(
util_classes.get_save_name(network_name, model_params))
all_loss_acc.append(loss_acc)
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 retrieve_ge():
print(model_params)
ge_x, ge_y, loss_acc = get_ge(network_name, model_params)
mean_y = np.mean(ge_y, axis=0)
ranks_x.append(ge_x)
ranks_y.append(ge_y)
rank_mean_y.append(mean_y)
name_models.append(get_save_name(network_name, model_params))
all_loss_acc.append(loss_acc)
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 = '/media/rico/Data/TU/thesis/runs{}/{}/subkey_{}/{}{}{}_SF{}_' \
'E{}_BZ{}_LR{}{}{}/train{}/'.format(
'3' if not experiment else '',
str(data_set),
sub_key_index,
'' if unmask else 'masked/',
'' if desync is 0 else 'desync{}/'.format(desync),
type_network,
spread_factor,
epochs,
batch_size,
'%.2E' % Decimal(lr),
'' if np.math.ceil(l2_penalty) <= 0 else '_L2_{}'.format(l2_penalty),
init,
train_size)
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_ge(net_name, model_parameters, load_parameters):
folder = '/media/rico/Data/TU/thesis/runs{}/{}/subkey_{}/{}{}{}_SF{}_' \
'E{}_BZ{}_LR{}{}/train{}/'.format(
load_parameters["experiment"],
load_parameters["data_set"],
load_parameters["subkey"],
load_parameters["masked"],
load_parameters["desync"],
load_parameters["hw"],
load_parameters["spread"],
load_parameters["epochs"],
load_parameters["batch_size"],
load_parameters["lr"],
load_parameters["l2"],
load_parameters["train_size"])
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 retrieve_ge(net_setting):
print(model_params)
ge_x, ge_y, loss_acc = get_ge(network_name, model_params, net_setting)
mean_y = np.mean(ge_y, axis=0)
ranks_x.append(ge_x)
ranks_y.append(ge_y)
rank_mean_y.append(mean_y)
name_models.append(get_save_name(network_name, model_params))
n_settings.append(net_setting)
(lta, lva, ltl, lvl) = loss_acc
net_setting['ge_x'].append(ge_x[0])
net_setting['ge_y'].append(mean_y)
net_setting['ta'].append(np.mean(lta, axis=0))
net_setting['va'].append(np.mean(lva, axis=0))
net_setting['tl'].append(np.mean(ltl, axis=0))
net_setting['vl'].append(np.mean(lvl, axis=0))
net_setting['line_title'].append(
f"{get_save_name(network_name, model_params)}, l2{model_params['l2_penalty']}"
)
all_loss_acc.append(loss_acc)
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')
"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)
str(args['data_set']),
args['subkey_index'],
'' if args['unmask'] else 'masked/',
'' if args['desync'] is 0 else 'desync{}/'.format(args['desync']),
args['type_network'],
args['spread_factor'],
args['epochs'],
args['batch_size'],
'%.2E' % Decimal(args['lr']),
args['train_size'])
# 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)
variables = ["conv1", "conv2", "conv3"]
for var in variables:
weights = model.__getattr__(var).weight.data.cpu().numpy()
ones = np.ones(np.shape(weights))
zeros = np.zeros(np.shape(weights))
plus = np.where(weights < THRESHOLD, ones, zeros)
minus = np.where(-THRESHOLD < weights, ones, zeros)
z = plus + minus
res = np.where(z == 2, ones, zeros)
# print(res)
